Exemplo n.º 1
0
// look for image-start markers more than 4 bytes into imageData.
// if one is found, remove the portion of the handle before it and return true.
// if none found, return false.
bool scanForAnotherImageMarker( Handle imageData )
{
	UInt8 *packetStart, *dataStart, *dataEnd, *data;
	Size handleSize = GetHandleSize( imageData );
	SInt32 offsetOfStart = -1L;
	
	packetStart = (UInt8*)imageData;
	dataStart = packetStart + 4;
	dataEnd = packetStart + handleSize;
	
	for( data = dataStart; data <= dataEnd-3; data++ ) {
		// JPEG SOI is FF D8, but it's always followed by another FF.
		if( ( 0xff == data[0] ) && ( 0xd8 == data[1] ) && ( 0xff == data[2] ) ) {
			offsetOfStart = data - packetStart;
			break;
		}
		
		// GIF start marker is 'GIF89a' etc.
		if ('G' == data[0] && 'I' == data[1] && 'F' == data[2] && '8' == data[3]) {
			offsetOfStart = data - packetStart;
			break;
		}
	}
	
	if( offsetOfStart > 0 ) {
		char mungerPleaseDelete;
		Munger( imageData, 0, nil, offsetOfStart, &mungerPleaseDelete, 0 );
		return true;
	}
	else {
		return false;
	}
}
Exemplo n.º 2
0
static LONGINT
Munger_invoker (Handle h, LONGINT offset, Ptr ptr1, LONGINT len1,
		Ptr ptr2, LONGINT len2, LONGINT *d0p)
{
  LONGINT retval;
  LONGINT d0_var;
  
  retval = Munger (h, ptr1, len1, ptr2, len2);
  asm { move.l d0, d0_var }

  *d0p = d0_var;

  return retval; 
}
// Runs write munging tests on BitcodeRecords with the given Edits. It
// then parses the written bitcode.  ErrorMessages is the expected
// error messages logged by the write munging, when no error recovery
// is allowed. ErrorRecoveryMessages are messages, in addition to
// ErrorMessages, when the writer applies error recovery.
void CheckParseEdits(const uint64_t *Edits, size_t EditsSize,
                     std::string ErrorMessages,
                     std::string ErrorRecoveryMessages) {
    NaClParseBitcodeMunger Munger(ARRAY_TERM(BitcodeRecords));
    EXPECT_FALSE(Munger.runTest(Edits, EditsSize, true));
    std::string BadResults(ErrorMessages);
    BadResults.append(UnableToContinue);
    EXPECT_EQ(BadResults, Munger.getTestResults());

    Munger.setTryToRecoverOnWrite(true);
    EXPECT_TRUE(Munger.runTest(Edits, EditsSize, true));
    std::string GoodResults(ErrorMessages);
    GoodResults.append(ErrorRecoveryMessages);
    GoodResults.append("Successful parse!\n");
    EXPECT_EQ(GoodResults, Munger.getTestResults());
}
// Show that writing out an illegal abbreviation index, causes the
// parser to fail.
TEST(MyNaClMungerWriteErrorTests, DieOnWriteBadAbbreviationIndex) {
    NaClWriteMunger Munger(ARRAY_TERM(BitcodeRecords));
    Munger.setWriteBadAbbrevIndex(true);
    Munger.setRunAsDeathTest(true);
    EXPECT_DEATH(
        Munger.runTest(ARRAY(AbbrevIndex4VoidTypeEdit)),
        ".*"
        // Report problem while writing.
        "Error \\(Block 17\\)\\: Uses illegal abbreviation index\\: 4\\: \\[2\\]"
        ".*"
        // Corresponding error while parsing.
        "Fatal\\(35\\:0)\\: Invalid abbreviation \\# 4 defined for record"
        ".*"
        // Output of report_fatal_error.
        "LLVM ERROR\\: Unable to continue"
        ".*");
}
static void set_about_item(void){
	Str255 aboutitem;
	StringHandle abouthandle;

	GetMenuItemText( GetMenuHandle(mApple), iAbout, aboutitem);
	abouthandle = NewString( aboutitem);
	if( abouthandle){
		StringPtr curApName = LMGetCurApName();
		long len = Munger( (Handle)abouthandle, 1, "MathLink\252", 9, curApName + 1, *curApName); 
		if( len > 0){
			**abouthandle = (unsigned char)len; 
			HLock( (Handle)abouthandle);
			SetMenuItemText( GetMenuHandle(mApple), iAbout, *abouthandle);
		}
		DisposeHandle( (Handle)abouthandle);
	}
}
// Show how we deal with additional abbreviations defined for a block,
// once a bad abbreviation definition record is found. That is, we
// remove all succeeding abbreviations definitions for that block. In
// addition, any record refering to a remove abbreviation is changed
// to use the default abbreviation.
TEST(NaClMungedWriteErrorTests, TestRemovingAbbrevWithMultAbbrevs) {
    NaClWriteMunger Munger(ARRAY_TERM(BitcodeRecords));
    const uint64_t FunctionEnterIndex = 7;
    const uint64_t Edits[] {
        FunctionEnterIndex, NaClMungedBitcode::Replace,   // Set Abbrev bits = 3
        1, naclbitc::BLK_CODE_ENTER, naclbitc::FUNCTION_BLOCK_ID, 3, Terminator,
        RetVoidIndex, NaClMungedBitcode::AddBefore,  // bad abbreviation!
        2, naclbitc::BLK_CODE_DEFINE_ABBREV, 1, // 1,
        naclbitc::FUNC_CODE_INST_RET - 1, Terminator,
        RetVoidIndex, NaClMungedBitcode::AddBefore,  // good abbreviation to ignore.
        2, naclbitc::BLK_CODE_DEFINE_ABBREV, 1, 1,
        naclbitc::FUNC_CODE_INST_RET, Terminator,
        RetVoidIndex, NaClMungedBitcode::Replace,  // reference to good abreviation.
        5, naclbitc::FUNC_CODE_INST_RET, Terminator
    };

    CheckDumpEdits(
        ARRAY(Edits),
        "Error (Block 12): Bad abbreviation operand encoding 9:"
        " 2: [65533, 1, 9]\n",
        "Error (Block 12): Ignoring abbreviation: 2: [65533, 1, 1, 10]\n"
        "Error (Block 12): Uses illegal abbreviation index: 5: [10]\n",
        "       0:0|<65532, 80, 69, 88, 69, 1, 0,|Magic Number: 'PEXE' (80, 69,"
        " 88, 69)\n"
        "          | 8, 0, 17, 0, 4, 0, 2, 0, 0, |PNaCl Version: 2\n"
        "          | 0>                          |\n"
        "      16:0|1: <65535, 8, 2>             |module {  // BlockID = 8\n"
        "      24:0|  1: <65535, 17, 3>          |  types {  // BlockID = 17\n"
        "      32:0|    3: <1, 2>                |    count 2;\n"
        "      34:5|    3: <2>                   |    @t0 = void;\n"
        "      36:4|    3: <21, 0, 0>            |    @t1 = void ();\n"
        "      39:7|  0: <65534>                 |  }\n"
        "      44:0|  3: <8, 1, 0, 0, 0>         |  define external void @f0();\n"
        // Edit to change number of abbrev bits to 3.
        "      48:6|  1: <65535, 12, 3>          |  function void @f0() {  \n"
        "          |                             |                   // BlockID"
        " = 12\n"
        "      56:0|    3: <1, 1>                |    blocks 1;\n"
        "          |                             |  %b0:\n"
        "      58:5|    3: <10>                  |    ret void;\n"
        "      60:4|  0: <65534>                 |  }\n"
        "      64:0|0: <65534>                   |}\n");
}
// Same as CheckParseEdits, but also runs the bitcode dumper on the
// written bitcode records. DumpedBitcode is the expected dumped
// bitcode.
void CheckDumpEdits(const uint64_t *Edits, size_t EditsSize,
                    std::string ErrorMessages,
                    std::string ErrorRecoveryMessages,
                    std::string DumpedBitcode,
                    bool RecoveredTestHasError=false) {
    NaClObjDumpMunger Munger(ARRAY_TERM(BitcodeRecords));
    EXPECT_FALSE(Munger.runTest(Edits, EditsSize));
    std::string BadResults(ErrorMessages);
    BadResults.append(UnableToContinue);
    EXPECT_EQ(BadResults, Munger.getTestResults());

    Munger.setTryToRecoverOnWrite(true);
    if (RecoveredTestHasError)
        EXPECT_FALSE(Munger.runTest(Edits, EditsSize));
    else
        EXPECT_TRUE(Munger.runTest(Edits, EditsSize));
    std::string GoodResults(ErrorMessages);
    GoodResults.append(ErrorRecoveryMessages);
    GoodResults.append(DumpedBitcode);
    EXPECT_EQ(GoodResults, Munger.getTestResults());

    // Verify that we can also parse the bitcode.
    CheckParseEdits(Edits, EditsSize, ErrorMessages, ErrorRecoveryMessages);
}
// Show that no error occurs if we write out the maximum allowable
// block abbreviation index bit limit.
TEST(NaClMungerWriteErrorTests, CanWriteBlockWithMaxLimit) {
    // Replace initial block enter with maximum bit size.
    const uint64_t Edit[] = {
        0, NaClMungedBitcode::Replace,
        1, naclbitc::BLK_CODE_ENTER, naclbitc::MODULE_BLOCK_ID,
        naclbitc::MaxAbbrevWidth, Terminator
    };
    NaClWriteMunger Munger(ARRAY_TERM(BitcodeRecords));
    EXPECT_TRUE(Munger.runTest(ARRAY(Edit)));
    EXPECT_EQ(
        "       1: [65535, 8, 32]\n" // Max abbreviation bit limit (32).
        "         1: [65535, 17, 3]\n"
        "           3: [1, 2]\n"
        "           3: [2]\n"
        "           3: [21, 0, 0]\n"
        "         0: [65534]\n"
        "         3: [8, 1, 0, 0, 0]\n"
        "         1: [65535, 12, 2]\n"
        "           3: [1, 1]\n"
        "           3: [10]\n"
        "         0: [65534]\n"
        "       0: [65534]\n",
        Munger.getTestResults());
}
Exemplo n.º 9
0
static OSErr	FSpGetFullPath(const FSSpec *spec,
							   short *fullPathLength,
							   Handle *fullPath)
{
	OSErr		result;
	OSErr		realResult;
	FSSpec		tempSpec;
	CInfoPBRec	pb;
	
	*fullPathLength = 0;
	*fullPath = nil;
	
	
	/* Default to noErr */
	realResult = result = noErr;
	
	result = FSMakeFSSpecCompat(spec->vRefNum, spec->parID, spec->name, &tempSpec);

	if ( result == noErr )
	{
		if ( tempSpec.parID == fsRtParID )
		{
			/* The object is a volume */
			
			/* Add a colon to make it a full pathname */
			++tempSpec.name[0];
			tempSpec.name[tempSpec.name[0]] = ':';
			
			/* We're done */
			result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
			*fullPathLength = tempSpec.name[0];
		}
		else
		{
			/* The object isn't a volume */
			
			/* Is the object a file or a directory? */
			pb.dirInfo.ioNamePtr = tempSpec.name;
			pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
			pb.dirInfo.ioDrDirID = tempSpec.parID;
			pb.dirInfo.ioFDirIndex = 0;
			result = PBGetCatInfoSync(&pb);
			// Allow file/directory name at end of path to not exist.
			realResult = result;
			if ( (result == noErr) || (result == fnfErr) )
			{
				/* if the object is a directory, append a colon so full pathname ends with colon */
				if ( (result == noErr) && (pb.hFileInfo.ioFlAttrib & kioFlAttribDirMask) != 0 )
				{
					++tempSpec.name[0];
					tempSpec.name[tempSpec.name[0]] = ':';
				}
				
				/* Put the object name in first */
				result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
				*fullPathLength = tempSpec.name[0];
				if ( result == noErr )
				{
					/* Get the ancestor directory names */
					pb.dirInfo.ioNamePtr = tempSpec.name;
					pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
					pb.dirInfo.ioDrParID = tempSpec.parID;
					do	/* loop until we have an error or find the root directory */
					{
						pb.dirInfo.ioFDirIndex = -1;
						pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
						result = PBGetCatInfoSync(&pb);
						if ( result == noErr )
						{
							/* Append colon to directory name */
							++tempSpec.name[0];
							tempSpec.name[tempSpec.name[0]] = ':';
							
							/* Add directory name to beginning of fullPath */
							(void) Munger(*fullPath, 0, nil, 0, &tempSpec.name[1], tempSpec.name[0]);
							*fullPathLength += tempSpec.name[0];
							result = MemError();
						}
					} while ( (result == noErr) && (pb.dirInfo.ioDrDirID != fsRtDirID) );
				}
			}
		}
	}
	
	if ( result == noErr )
	{
		/* Return the length */
///		*fullPathLength = GetHandleSize(*fullPath);
		result = realResult;	// return realResult in case it was fnfErr
	}
	else
	{
		/* Dispose of the handle and return nil and zero length */
		if ( *fullPath != nil )
		{
			DisposeHandle(*fullPath);
		}
		*fullPath = nil;
		*fullPathLength = 0;
	}
	
	return ( result );
}
// Show that we can dump the bitcode records
TEST(NaClMungeWriteErrorTests, DumpBitcodeRecords) {
    NaClObjDumpMunger Munger(ARRAY_TERM(BitcodeRecords));
    EXPECT_TRUE(Munger.runTest());
    EXPECT_EQ(ExpectedDumpedBitcode, Munger.getTestResults());
}
Exemplo n.º 11
0
static void QTDR_DrawFrame (short theTrackWidth, short theTrackHeight, long theNumSample, GWorldPtr theGWorld)
{
	Handle								myHandle = NULL;
	char								myData[kPICTFileHeaderSize];
	static PicHandle					myPicture = NULL;
	static GWorldPtr					myGWorld = NULL;
	static GraphicsImportComponent		myImporter = NULL;
	Rect								myRect;
	RGBColor							myColor;
	ComponentResult						myErr = noErr;

	MacSetRect(&myRect, 0, 0, theTrackWidth, theTrackHeight);

	if (myPicture == NULL) {
		myErr = NewGWorld(&myGWorld, kPixelDepth, &myRect, NULL, NULL, (GWorldFlags)0);
		if (myErr != noErr)
			goto bail;

		// read a picture from our resource file
		myPicture = GetPicture(kPictureID);
		if (myPicture == NULL)
			goto bail;

		// use Munger to prepend a 512-byte header onto the picture data; this converts the PICT
		// resource data into in-memory PICT file data (see Ice Floe 14 for an explanation of this)
		myHandle = (Handle)myPicture;
		Munger(myHandle, 0, NULL, 0, myData, kPICTFileHeaderSize);

		// get a graphics importer for the picture
		myErr = OpenADefaultComponent(GraphicsImporterComponentType, kQTFileTypePicture, &myImporter); 
		if (myErr != noErr)
			goto bail;
				
		// configure the graphics importer
		myErr = GraphicsImportSetGWorld(myImporter, myGWorld, NULL);
		if (myErr != noErr)
			goto bail;
		
		myErr = GraphicsImportSetDataHandle(myImporter, myHandle);
		if (myErr != noErr)
			goto bail;
			
		myErr = GraphicsImportSetBoundsRect(myImporter, &myRect);
		if (myErr != noErr)
			goto bail;
			
		// draw the picture into the source GWorld
		myErr = GraphicsImportDraw(myImporter);
		if (myErr != noErr)
			goto bail;
	}
	
	// set the blend amount (0 = fully transparent; 0xffff = fully opaque)
	myColor.red = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
	myColor.green = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
	myColor.blue = (theNumSample - 1) * (0xffff / kNumVideoFrames - 1);
	OpColor(&myColor);
	
	// blend the picture (in the source GWorld) into the empty rectangle (in the destination GWorld)
	CopyBits((BitMapPtr)*GetGWorldPixMap(myGWorld),
			 (BitMapPtr)*GetGWorldPixMap(theGWorld),
			 &myRect,
			 &myRect,
			 blend,
			 NULL);

	if (theNumSample == kNumVideoFrames)
		goto bail;
		
	return;
	
bail:
	if (myHandle != NULL)
		DisposeHandle(myHandle);
		
	if (myPicture != NULL)
		ReleaseResource((Handle)myPicture);
		
	if (myImporter != NULL)
		CloseComponent(myImporter);
} 
Exemplo n.º 12
0
OSErr
FSpPathFromLocation(
    FSSpec *spec,		/* The location we want a path for. */
    int *length,		/* Length of the resulting path. */
    Handle *fullPath)		/* Handle to path. */
{
    OSErr err;
    FSSpec tempSpec;
    CInfoPBRec pb;
	
    *fullPath = NULL;
	
    /* 
     * Make a copy of the input FSSpec that can be modified.
     */
    BlockMoveData(spec, &tempSpec, sizeof(FSSpec));
	
    if (tempSpec.parID == fsRtParID) {
	/* 
	 * The object is a volume.  Add a colon to make it a full 
	 * pathname.  Allocate a handle for it and we are done.
	 */
	tempSpec.name[0] += 2;
	tempSpec.name[tempSpec.name[0] - 1] = ':';
	tempSpec.name[tempSpec.name[0]] = '\0';
		
	err = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
    } else {
	/* 
	 * The object isn't a volume.  Is the object a file or a directory? 
	 */
	pb.dirInfo.ioNamePtr = tempSpec.name;
	pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
	pb.dirInfo.ioDrDirID = tempSpec.parID;
	pb.dirInfo.ioFDirIndex = 0;
	err = PBGetCatInfoSync(&pb);

	if ((err == noErr) || (err == fnfErr)) {
	    /* 
	     * If the file doesn't currently exist we start over.  If the
	     * directory exists everything will work just fine.  Otherwise we
	     * will just fail later.  If the object is a directory, append a
	     * colon so full pathname ends with colon, but only if the name is
	     * not empty.  NavServices returns FSSpec's with the parent ID set,
	     * but the name empty...
	     */
	    if (err == fnfErr) {
		BlockMoveData(spec, &tempSpec, sizeof(FSSpec));
	    } else if ( (pb.hFileInfo.ioFlAttrib & ioDirMask) != 0 ) {
	        if (tempSpec.name[0] > 0) {
		    tempSpec.name[0] += 1;
		    tempSpec.name[tempSpec.name[0]] = ':';
		}
	    }
			
	    /* 
	     * Create a new Handle for the object - make it a C string.
	     */
	    tempSpec.name[0] += 1;
	    tempSpec.name[tempSpec.name[0]] = '\0';
	    err = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
	    if (err == noErr) {
		/* 
		 * Get the ancestor directory names - loop until we have an 
		 * error or find the root directory.
		 */
		pb.dirInfo.ioNamePtr = tempSpec.name;
		pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
		pb.dirInfo.ioDrParID = tempSpec.parID;
		do {
		    pb.dirInfo.ioFDirIndex = -1;
		    pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
		    err = PBGetCatInfoSync(&pb);
		    if (err == noErr) {
			/* 
			 * Append colon to directory name and add 
			 * directory name to beginning of fullPath.
			 */
			++tempSpec.name[0];
			tempSpec.name[tempSpec.name[0]] = ':';
						
			(void) Munger(*fullPath, 0, NULL, 0, &tempSpec.name[1],
				tempSpec.name[0]);
			err = MemError();
		    }
		} while ( (err == noErr) &&
			(pb.dirInfo.ioDrDirID != fsRtDirID) );
	    }
	}
    }
    
    /*
     * On error Dispose the handle, set it to NULL & return the err.
     * Otherwise, set the length & return.
     */
    if (err == noErr) {
	*length = GetHandleSize(*fullPath) - 1;
    } else {
	if ( *fullPath != NULL ) {
	    DisposeHandle(*fullPath);
	}
	*fullPath = NULL;
	*length = 0;
    }

    return err;
}
Exemplo n.º 13
0
pascal	OSErr	FSpGetFullPath(const FSSpec *spec,
							   short *fullPathLength,
							   Handle *fullPath)
{
	OSErr		result;
	OSErr		realResult;
	FSSpec		tempSpec;
	CInfoPBRec	pb;

	*fullPathLength = 0;
	*fullPath = NULL;

	// Default to noErr
	realResult = noErr;

	/* Make a copy of the input FSSpec that can be modified */
	BlockMoveData(spec, &tempSpec, sizeof(FSSpec));

	if ( tempSpec.parID == fsRtParID )
	{
		/* The object is a volume */

		/* Add a colon to make it a full pathname */
		++tempSpec.name[0];
		tempSpec.name[tempSpec.name[0]] = ':';

		/* We are done */
		result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
	}
	else
	{
		/* The object is NOT a volume */

		/* Is the object a file or a directory? */
		pb.dirInfo.ioNamePtr = tempSpec.name;
		pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
		pb.dirInfo.ioDrDirID = tempSpec.parID;
		pb.dirInfo.ioFDirIndex = 0;
		result = PBGetCatInfoSync(&pb);
		/* Allow file/directory name at end of path to not exist. */
		realResult = result;
		if ( (result == noErr) || (result == fnfErr) )
		{
			/* if the object is a directory, append a colon so full pathname ends with colon */
			if ( (result == noErr) && (pb.hFileInfo.ioFlAttrib & ioDirMask) != 0 )
			{
				++tempSpec.name[0];
				tempSpec.name[tempSpec.name[0]] = ':';
			}

			/* Put the object name in first */
			result = PtrToHand(&tempSpec.name[1], fullPath, tempSpec.name[0]);
			if ( result == noErr )
			{
				/* Get the ancestor directory names */
				pb.dirInfo.ioNamePtr = tempSpec.name;
				pb.dirInfo.ioVRefNum = tempSpec.vRefNum;
				pb.dirInfo.ioDrParID = tempSpec.parID;
				do	/* loop until we have an error or find the root directory */
				{
					pb.dirInfo.ioFDirIndex = -1;
					pb.dirInfo.ioDrDirID = pb.dirInfo.ioDrParID;
					result = PBGetCatInfoSync(&pb);
					if ( result == noErr )
					{
						/* Append colon to directory name */
						++tempSpec.name[0];
						tempSpec.name[tempSpec.name[0]] = ':';

						/* Add directory name to beginning of fullPath */
						(void) Munger(*fullPath, 0, NULL, 0, &tempSpec.name[1], tempSpec.name[0]);
						result = MemError();
					}
				} while ( (result == noErr) && (pb.dirInfo.ioDrDirID != fsRtDirID) );
			}
		}
	}
	if ( result == noErr )
	{
		/* Return the length */
		*fullPathLength = InlineGetHandleSize(*fullPath);
		result = realResult;	// return realResult in case it was fnfErr
	}
	else
	{
		/* Dispose of the handle and return NULL and zero length */
		if ( *fullPath != NULL )
		{
			DisposeHandle(*fullPath);
		}
		*fullPath = NULL;
		*fullPathLength = 0;
	}

	return ( result );
}