diff --git a/loader/Makefile b/loader/Makefile index fe48cc08ce..6679f17e34 100644 --- a/loader/Makefile +++ b/loader/Makefile @@ -6,7 +6,7 @@ DEFINES=$(WIN32_PATH) -DMPLAYER -D__WINE__ -Ddbg_printf=__vprintf \ LIB_OBJECTS= ldt_keeper.o pe_image.o module.o \ ext.o win32.o driver.o pe_resource.o \ -resource.o registry.o elfdll.o afl.o vfl.o +resource.o registry.o elfdll.o afl.o vfl.o wrapper.o # gcc-3.0 produces buggy code for acmStreamOpen() with # "-O3 -fomit-frame-pointer" or "-O2 -fomit-frame-pointer diff --git a/loader/module.c b/loader/module.c index b532c06def..81a699d09c 100644 --- a/loader/module.c +++ b/loader/module.c @@ -3,6 +3,13 @@ * * Copyright 1995 Alexandre Julliard */ + +// define for quicktime calls debugging and/or MacOS-level emulation: +//#define EMU_QTX_API + +// define for quicktime debugging (verbose logging): +//#define DEBUG_QTX_API + #include "config.h" #include @@ -15,13 +22,15 @@ #include #include - #include "wine/windef.h" #include "wine/winerror.h" #include "wine/heap.h" #include "wine/module.h" #include "wine/pe_image.h" #include "wine/debugtools.h" + +#undef HAVE_LIBDL + #ifdef HAVE_LIBDL #include #include "wine/elfdll.h" @@ -29,6 +38,12 @@ #include "win32.h" #include "driver.h" +#ifdef EMU_QTX_API +#include "wrapper.h" +static int report_func(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags); +static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags); +#endif + //#undef TRACE //#define TRACE printf @@ -43,7 +58,8 @@ WINE_MODREF* MODULE_FindModule(LPCSTR m) TRACE("Module %s request\n", m); if(list==NULL) return NULL; - while(strcmp(m, list->wm->filename)) +// while(strcmp(m, list->wm->filename)) + while(!strstr(list->wm->filename, m)) { TRACE("%s: %x\n", list->wm->filename, list->wm->module); list=list->prev; @@ -295,6 +311,17 @@ static WINE_MODREF *MODULE_LoadLibraryExA( LPCSTR libname, HFILE hfile, DWORD fl /* decrement the dependencies through the MODULE_FreeLibrary call. */ pwm->refCount++; +#ifdef EMU_QTX_API + if(strstr(libname,"QuickTime.qts")){ + void** ptr=0x62b75ca4; + fprintf(stderr,"QuickTime.qts entrypoint patched!!! old=%p\n",ptr[0]); + report_entry = report_func; + report_ret = report_func_ret; + wrapper_target=ptr[0]; + ptr[0]=wrapper; + } +#endif + SetLastError( err ); /* restore last error */ return pwm; } @@ -344,6 +371,10 @@ HMODULE WINAPI LoadLibraryExA(LPCSTR libname, HANDLE hfile, DWORD flags) SetLastError(ERROR_INVALID_PARAMETER); return 0; } + + wm=MODULE_FindModule(libname); + if(wm) return wm->module; + // if(fs_installed==0) // install_fs(); @@ -472,6 +503,337 @@ FARPROC WINAPI GetProcAddress( HMODULE hModule, LPCSTR function ) return MODULE_GetProcAddress( hModule, function, TRUE ); } +#ifdef DEBUG_QTX_API + +struct ComponentParameters { + unsigned char flags; /* call modifiers: sync/async, deferred, immed, etc */ + unsigned char paramSize; /* size in bytes of actual parameters passed to this call */ + short what; /* routine selector, negative for Component management calls */ + long params[1]; /* actual parameters for the indicated routine */ +}; +typedef struct ComponentParameters ComponentParameters; + +static char* component_func(int what){ +switch(what){ +case -1: return "kComponentOpenSelect"; +case -2: return "kComponentCloseSelect"; +case -3: return "kComponentCanDoSelect"; +case -4: return "kComponentVersionSelect"; +case -5: return "kComponentRegisterSelect"; +case -6: return "kComponentTargetSelect"; +case -7: return "kComponentUnregisterSelect"; +} +return "???"; +} + +static char* component_func_type(int type,int what){ +if(type==1) switch(what){ +case 0: return "kImageCodecGetCodecInfoSelect"; +case 1: return "kImageCodecGetCompressionTimeSelect"; +case 5: return "kImageCodecPreDecompressSelect"; +case 6: return "kImageCodecBandDecompressSelect"; +case 0x12: return "kImageCodecDisposeMemorySelect"; +case 0x10: return "kImageCodecIsImageDescriptionEquivalentSelect"; +case 0x14: return "kImageCodecNewImageBufferMemorySelect"; +case 0x28: return "kImageCodecRequestGammaLevelSelect"; +} +return "???"; +} + + +static int c_level=0; + +static int dump_component(char* name,int type,void* _orig, ComponentParameters *params,void** glob){ + int ( *orig)(ComponentParameters *params, void** glob) = _orig; + int ret,i; + + if(params->what<0) + fprintf(stderr,"%*sComponentCall: %s flags=0x%X size=%d what=%d %s\n",3*c_level,"",name,params->flags, params->paramSize, params->what, component_func(params->what)); + else + fprintf(stderr,"%*sComponentCall: %s flags=0x%X size=%d what=0x%X %s\n",3*c_level,"",name,params->flags, params->paramSize, params->what, component_func_type(type,params->what)); + + for(i=0;iparamSize/4;i++) + fprintf(stderr,"%*s param[%d] = 0x%X\n",3*c_level,"",i,params->params[i]); + + ++c_level; + ret=orig(params,glob); + --c_level; + + if(ret>=0x1000) + fprintf(stderr,"%*s return=0x%X\n",3*c_level,"",ret); + else + fprintf(stderr,"%*s return=%d\n",3*c_level,"",ret); + return ret; +} + +#define DECL_COMPONENT(sname,name,type) \ + static void* real_ ## sname = NULL; \ + static int fake_ ## sname(ComponentParameters *params,void** glob){ \ + return dump_component(name,type,real_ ## sname, params, glob); \ + } + +#include "qt_comp.h" + +#undef DECL_COMPONENT + +#include "qt_fv.h" + +#endif + +#ifdef EMU_QTX_API + +static u_int32_t ret_array[4096]; +static int ret_i=0; + +static int report_func(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags) +{ +#ifdef DEBUG_QTX_API + int i; + int* dptr; + void* pwrapper=NULL; + void* pptr=NULL; + char* pname=NULL; + int plen=-1; + // find the code: + + dptr=0x62b67ae0;dptr+=2*((reg->eax>>16)&255); +// printf("FUNC: flag=%d ptr=%p\n",dptr[0],dptr[1]); + if(dptr[0]&255){ + dptr=dptr[1];dptr+=4*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",dptr[1],dptr[0],dptr[2]); + pwrapper=dptr[1]; pptr=dptr[0]; plen=dptr[2]; + } else { + pwrapper=0x62924910; + switch(dptr[1]){ + case 0x629248d0: + dptr=0x62b672c0;dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + case 0x62924e40: + dptr=0x62b67c70;dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + case 0x62924e60: + dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + case 0x62924e80: + dptr=0x62b68108;if(reg->eax&0x8000) dptr+=2*(reg->eax|0xffff0000); else dptr+=2*(reg->eax&65535); +// printf("FUNC: ptr2=%p eax=%p edx=%p\n",0x62924910,dptr[0],dptr[1]); + pptr=dptr[0]; plen=dptr[1]; + break; + default: + printf("FUNC: unknown ptr & psize!\n"); + pwrapper=dptr[1]; + } + } + + for(i=0;qt_fv_list[i].name;i++){ + if(qt_fv_list[i].id==reg->eax){ + pname=qt_fv_list[i].name; + break; + } + } + + printf("FUNC[%X/%s]: wrapper=%p func=%p len=%d\n",reg->eax, + pname?pname:"???",pwrapper,pptr,plen); + + printf("FUNC: caller=%p ebx=%p\n",((u_int32_t *)stack_base)[0],reg->ebx); + + if(pname) + printf("%*sENTER(%d): %s(",ret_i*2,"",ret_i,pname); + else + printf("%*sENTER(%d): %X(",ret_i*2,"",ret_i,reg->eax); + for (i=0;i=0x20 && fcc[0]<128 && + fcc[1]>=0x20 && fcc[1]<128 && + fcc[2]>=0x20 && fcc[2]<128 && + fcc[3]>=0x20 && fcc[3]<128) printf("='%c%c%c%c'",fcc[3],fcc[2],fcc[1],fcc[0]); + else if(val>=8 && val<65536) printf("=%d",val); + } + printf(")\n"); + fflush(stdout); + +#endif + +#if 1 + // emulate some functions: + switch(reg->eax){ + // memory management: + case 0x150011: //NewPtrClear + case 0x150012: //NewPtrSysClear + reg->eax=malloc(((u_int32_t *)stack_base)[1]); + memset(reg->eax,0,((u_int32_t *)stack_base)[1]); +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + case 0x15000F: //NewPtr + case 0x150010: //NewPtrSys + reg->eax=malloc(((u_int32_t *)stack_base)[1]); +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + case 0x15002f: //DisposePtr + if(((u_int32_t *)stack_base)[1]>=0x60000000) + printf("WARNING! Invalid Ptr handle!\n"); + else + free(((u_int32_t *)stack_base)[1]); + reg->eax=0; +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + // mutexes: + case 0x1d0033: //QTMLCreateMutex + reg->eax=0xdeadbabe; +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + case 0x1d0034: //QTMLDestroyMutex + case 0x1d0035: //QTMLGrabMutex + case 0x1d0036: //QTMLReturnMutex + case 0x1d003d: //QTMLTryGrabMutex + reg->eax=0; +#ifdef DEBUG_QTX_API + printf("%*sLEAVE(%d): EMULATED! 0x%X\n",ret_i*2,"",ret_i, reg->eax); +#endif + return 1; + } +#endif + +#if 0 + switch(reg->eax){ +// case 0x00010000: +// printf("FUNC: ImageCodecInitialize/ImageCodecGetCodecInfo(ci=%p,&icap=%p)\n",((u_int32_t *)stack_base)[1],((u_int32_t *)stack_base)[4]); +// break; + case 0x00010003: + printf("FUNC: CountComponents(&desc=%p)\n",((u_int32_t *)stack_base)[1]); + break; + case 0x00010004: + printf("FUNC: FindNextComponent(prev=%p,&desc=%p)\n",((u_int32_t *)stack_base)[1],((u_int32_t *)stack_base)[2]); + break; + case 0x00010007: + printf("FUNC: OpenComponent(prev=%p)\n",((u_int32_t *)stack_base)[1]); + break; + case 0x0003008b: + printf("FUNC: QTNewGWorldFromPtr(&pts=%p,fourcc=%.4s,&rect=%p,x1=%p,x2=%p,x3=%p,plane=%p,stride=%d)\n", + ((u_int32_t *)stack_base)[1], + &(((u_int32_t *)stack_base)[2]), + ((u_int32_t *)stack_base)[3], + ((u_int32_t *)stack_base)[4], + ((u_int32_t *)stack_base)[5], + ((u_int32_t *)stack_base)[6], + ((u_int32_t *)stack_base)[7], + ((u_int32_t *)stack_base)[8]); + break; + case 0x001c0018: + printf("FUNC: GetGWorldPixMap(gworld=%p)\n",((u_int32_t *)stack_base)[1]); + break; + case 0x00110001: + printf("FUNC: Gestalt(fourcc=%.4s, &ret=%p)\n",&(((u_int32_t *)stack_base)[1]),((u_int32_t *)stack_base)[2]); + break; + default: { + int i; + for(i=0;qt_fv_list[i].name;i++){ + if(qt_fv_list[i].id==reg->eax){ + printf("FUNC: %s\n",qt_fv_list[i].name); + break; + } + } + } + } + + // print stack/reg information + printf("ENTER(%d) stack = %d bytes @ %p\n" + "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n" + "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n" + "flags = 0x%08x\n", ret_i, + stack_size, stack_base, + reg->eax, reg->edx, reg->ebx, reg->ecx, + reg->esp, reg->ebp, reg->esi, reg->edi, + *flags); +#endif + + // save ret addr: + ret_array[ret_i]=((u_int32_t *)stack_base)[0]; + ++ret_i; + +#if 0 + // print first 7 longs in the stack (return address, arg[1], arg[2] ... ) + printf("stack[] = { "); + for (i=0;i<7;i++) { + printf("%08x ", ((u_int32_t *)stack_base)[i]); + } + printf("}\n\n"); +#endif + +// // mess with function parameters +// ((u_int32_t *)stack_base)[1] = 0x66554433; + +// // mess with return address... +// reg->eax = 0x11223344; + return 0; +} + +static int report_func_ret(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags) +{ + int i; + short err; + + // restore ret addr: + --ret_i; + ((u_int32_t *)stack_base)[0]=ret_array[ret_i]; + +#ifdef DEBUG_QTX_API + +#if 1 + printf("%*sLEAVE(%d): 0x%X",ret_i*2,"",ret_i, reg->eax); + err=reg->eax; + if(err && (reg->eax>>16)==0) printf(" = %d",err); + printf("\n"); + fflush(stdout); +#else + // print stack/reg information + printf("LEAVE(%d) stack = %d bytes @ %p\n" + "eax = 0x%08x edx = 0x%08x ebx = 0x%08x ecx = 0x%08x\n" + "esp = 0x%08x ebp = 0x%08x esi = 0x%08x edi = 0x%08x\n" + "flags = 0x%08x\n", ret_i, + stack_size, stack_base, + reg->eax, reg->edx, reg->ebx, reg->ecx, + reg->esp, reg->ebp, reg->esi, reg->edi, + *flags); +#endif + +#if 0 + // print first 7 longs in the stack (return address, arg[1], arg[2] ... ) + printf("stack[] = { "); + for (i=0;i<7;i++) { + printf("%08x ", ((u_int32_t *)stack_base)[i]); + } + printf("}\n\n"); +#endif + +#endif + +// // mess with function parameters +// ((u_int32_t *)stack_base)[1] = 0x66554433; + +// // mess with return address... +// reg->eax = 0x11223344; + return 0; +} + +#endif + /*********************************************************************** * MODULE_GetProcAddress (internal) */ @@ -484,10 +846,17 @@ FARPROC MODULE_GetProcAddress( // WINE_MODREF *wm=local_wm; FARPROC retproc; +#ifdef DEBUG_QTX_API if (HIWORD(function)) - TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function); + fprintf(stderr,"XXX GetProcAddress(%08lx,%s)\n",(DWORD)hModule,function); else - TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function); + fprintf(stderr,"XXX GetProcAddress(%08lx,%p)\n",(DWORD)hModule,function); +#endif + +// TRACE_(win32)("(%08lx,%s)\n",(DWORD)hModule,function); +// else +// TRACE_(win32)("(%08lx,%p)\n",(DWORD)hModule,function); + if (!wm) { SetLastError(ERROR_INVALID_HANDLE); return (FARPROC)0; @@ -497,7 +866,7 @@ FARPROC MODULE_GetProcAddress( case MODULE32_PE: retproc = PE_FindExportedFunction( wm, function, snoop ); if (!retproc) SetLastError(ERROR_PROC_NOT_FOUND); - return retproc; + break; #ifdef HAVE_LIBDL case MODULE32_ELF: retproc = (FARPROC) dlsym( (void*) wm->module, function); @@ -509,6 +878,35 @@ FARPROC MODULE_GetProcAddress( SetLastError(ERROR_INVALID_HANDLE); return (FARPROC)0; } + +#ifdef EMU_QTX_API + if (HIWORD(function) && retproc){ + +#ifdef DEBUG_QTX_API +#define DECL_COMPONENT(sname,name,type) \ + if(!strcmp(function,name)){ \ + fprintf(stderr,name "dispatcher catched -> %p\n",retproc); \ + real_ ## sname = retproc; retproc = fake_ ## sname; \ + } +#include "qt_comp.h" +#undef DECL_COMPONENT +#endif + + if(!strcmp(function,"theQuickTimeDispatcher") +// || !strcmp(function,"_CallComponentFunctionWithStorage") +// || !strcmp(function,"_CallComponent") + ){ + fprintf(stderr,"theQuickTimeDispatcher catched -> %p\n",retproc); + report_entry = report_func; + report_ret = report_func_ret; + wrapper_target=retproc; + retproc=wrapper; + } + + } +#endif + + return retproc; } static int acounter = 0; diff --git a/loader/qt_comp.h b/loader/qt_comp.h new file mode 100644 index 0000000000..7ceeb5dbbb --- /dev/null +++ b/loader/qt_comp.h @@ -0,0 +1,27 @@ + +DECL_COMPONENT(sorenson3,"SMD_ComponentDispatch",1) +DECL_COMPONENT(sorenson,"SorensonYUV9Dispatcher",1) +DECL_COMPONENT(sorenson1,"SVD_ComponentDispatch",1) +DECL_COMPONENT(genericd,"GenericComponentDispatch",0) +DECL_COMPONENT(stmedia,"STMediaComponentDispatch",0) +DECL_COMPONENT(handlecd,"HandleComponentDispatch",0) +DECL_COMPONENT(pcxcd,"PCExchangeComponentDispatch",0) +DECL_COMPONENT(capcd,"CapComponentDispatch",0) +DECL_COMPONENT(videocd,"VideoComponentDispatch",0) +DECL_COMPONENT(soundcd,"SoundComponentDispatch",0) +DECL_COMPONENT(scalingcd,"ScalingCodecDispatcher",0) +DECL_COMPONENT(formatcnv,"FormatConverterDispatch",0) + +DECL_COMPONENT(basecd,"Base_CDComponentDispatch",1) +DECL_COMPONENT(ddcd,"DD_CDComponentDispatch",0) +DECL_COMPONENT(fakergb,"FakeRGBDispatcher",0) +DECL_COMPONENT(rawcd,"RAW_CDComponentDispatch",0) +DECL_COMPONENT(yuvsgi,"YUVSGI_CDComponentDispatch",0) +DECL_COMPONENT(yuvs,"YUVS_CDComponentDispatch",0) +DECL_COMPONENT(yuvu,"YUVU_CDComponentDispatch",0) + +DECL_COMPONENT(qdm2d,"QDM2Decompressor",0) +DECL_COMPONENT(mace3d,"Mace3DecompDispatch",0) + +//DECL_COMPONENT(,"",0) + diff --git a/loader/qt_fv.h b/loader/qt_fv.h new file mode 100644 index 0000000000..6531e4a1c1 --- /dev/null +++ b/loader/qt_fv.h @@ -0,0 +1,1586 @@ +typedef struct qt_fv_s { + unsigned int id; + char* name; +} qt_fv_t; + +qt_fv_t qt_fv_list[]={ +{ 0x20001, "EnterMovies"}, +{ 0x20002, "ExitMovies"}, +{ 0x20003, "GetMoviesError"}, +{ 0x20004, "GetMoviesStickyError"}, +{ 0x20005, "MoviesTask"}, +{ 0x20006, "PrerollMovie"}, +{ 0x20007, "LoadMovieIntoRam"}, +{ 0x20008, "LoadMediaIntoRam"}, +{ 0x20009, "SetMovieActive"}, +{ 0x2000a, "GetMovieActive"}, +{ 0x2000b, "StartMovie"}, +{ 0x2000c, "StopMovie"}, +{ 0x2000d, "GoToBeginningOfMovie"}, +{ 0x2000e, "GoToEndOfMovie"}, +{ 0x2000f, "GetMoviePreviewMode"}, +{ 0x20010, "SetMoviePreviewMode"}, +{ 0x20011, "ShowMoviePoster"}, +{ 0x20012, "GetMovieTimeBase"}, +{ 0x20015, "GetMovieGWorld"}, +{ 0x20016, "SetMovieGWorld"}, +{ 0x2001d, "GetMoviePict"}, +{ 0x2001e, "GetTrackPict"}, +{ 0x2001f, "UpdateMovie"}, +{ 0x20022, "PutMovieIntoHandle"}, +{ 0x20023, "DisposeMovie"}, +{ 0x20026, "GetMovieCreationTime"}, +{ 0x20027, "GetMovieModificationTime"}, +{ 0x20029, "GetMovieTimeScale"}, +{ 0x2002a, "SetMovieTimeScale"}, +{ 0x2002b, "GetMovieDuration"}, +{ 0x2002c, "GetMovieRate"}, +{ 0x2002d, "SetMovieRate"}, +{ 0x2002e, "GetMovieVolume"}, +{ 0x2002f, "SetMovieVolume"}, +{ 0x20031, "GetMovieMatrix"}, +{ 0x20032, "SetMovieMatrix"}, +{ 0x20033, "GetMoviePreviewTime"}, +{ 0x20034, "SetMoviePreviewTime"}, +{ 0x20035, "GetMoviePosterTime"}, +{ 0x20036, "SetMoviePosterTime"}, +{ 0x20037, "GetMovieSelection"}, +{ 0x20038, "SetMovieSelection"}, +{ 0x20039, "GetMovieTime"}, +{ 0x2003c, "SetMovieTime"}, +{ 0x2003d, "SetMovieTimeValue"}, +{ 0x2003e, "GetMovieUserData"}, +{ 0x2003f, "GetMovieTrackCount"}, +{ 0x20040, "GetMovieTrack"}, +{ 0x20042, "DisposeMovieTrack"}, +{ 0x20043, "GetTrackCreationTime"}, +{ 0x20044, "GetTrackModificationTime"}, +{ 0x20045, "GetTrackEnabled"}, +{ 0x20046, "SetTrackEnabled"}, +{ 0x20047, "GetTrackUsage"}, +{ 0x20048, "SetTrackUsage"}, +{ 0x2004b, "GetTrackDuration"}, +{ 0x2004c, "GetTrackOffset"}, +{ 0x2004d, "SetTrackOffset"}, +{ 0x20050, "GetTrackLayer"}, +{ 0x20051, "SetTrackLayer"}, +{ 0x20052, "GetTrackAlternate"}, +{ 0x20053, "SetTrackAlternate"}, +{ 0x20054, "GetTrackVolume"}, +{ 0x20055, "SetTrackVolume"}, +{ 0x20056, "GetTrackMatrix"}, +{ 0x20057, "SetTrackMatrix"}, +{ 0x2005d, "GetTrackDimensions"}, +{ 0x2005e, "SetTrackDimensions"}, +{ 0x2005f, "GetTrackUserData"}, +{ 0x20061, "DisposeTrackMedia"}, +{ 0x20062, "GetTrackMedia"}, +{ 0x20066, "GetMediaCreationTime"}, +{ 0x20067, "GetMediaModificationTime"}, +{ 0x20068, "GetMediaTimeScale"}, +{ 0x20069, "SetMediaTimeScale"}, +{ 0x2006a, "GetMediaDuration"}, +{ 0x2006b, "GetMediaLanguage"}, +{ 0x2006c, "SetMediaLanguage"}, +{ 0x2006d, "GetMediaQuality"}, +{ 0x2006e, "SetMediaQuality"}, +{ 0x2006f, "GetMediaHandlerDescription"}, +{ 0x20070, "GetMediaUserData"}, +{ 0x20071, "GetMediaHandler"}, +{ 0x20072, "BeginMediaEdits"}, +{ 0x20073, "EndMediaEdits"}, +{ 0x20074, "AddEmptyTrackToMovie"}, +{ 0x20077, "GetMediaSampleDescriptionCount"}, +{ 0x20078, "GetMediaSampleDescription"}, +{ 0x20079, "GetMediaSampleCount"}, +{ 0x2007a, "SampleNumToMediaTime"}, +{ 0x2007b, "MediaTimeToSampleNum"}, +{ 0x2007c, "AddMediaSample"}, +{ 0x2007d, "AddMediaSampleReference"}, +{ 0x2007e, "GetMediaSample"}, +{ 0x2007f, "GetMediaSampleReference"}, +{ 0x20084, "CloneRgn"}, +{ 0x20085, "InsertTrackSegment"}, +{ 0x20086, "InsertMovieSegment"}, +{ 0x20087, "InsertEmptyTrackSegment"}, +{ 0x20088, "InsertEmptyMovieSegment"}, +{ 0x20089, "DeleteTrackSegment"}, +{ 0x2008a, "DeleteMovieSegment"}, +{ 0x2008b, "ScaleTrackSegment"}, +{ 0x2008c, "ScaleMovieSegment"}, +{ 0x2008d, "CutMovieSelection"}, +{ 0x2008e, "CopyMovieSelection"}, +{ 0x2008f, "PasteMovieSelection"}, +{ 0x20096, "TrackTimeToMediaTime"}, +{ 0x20098, "GetMovieDataSize"}, +{ 0x20099, "GetMediaDataSize"}, +{ 0x2009a, "PtInMovie"}, +{ 0x2009b, "PtInTrack"}, +{ 0x2009c, "SetMovieLanguage"}, +{ 0x2009d, "SetTrackGWorld"}, +{ 0x2009e, "GetUserData"}, +{ 0x2009f, "AddUserData"}, +{ 0x200a0, "RemoveUserData"}, +{ 0x200a5, "NewTimeBase"}, +{ 0x200a6, "GetTimeBaseTime"}, +{ 0x200a7, "SetTimeBaseTime"}, +{ 0x200a8, "SetTimeBaseValue"}, +{ 0x200a9, "GetTimeBaseRate"}, +{ 0x200aa, "SetTimeBaseRate"}, +{ 0x200ab, "GetTimeBaseStartTime"}, +{ 0x200ac, "SetTimeBaseStartTime"}, +{ 0x200ad, "GetTimeBaseStopTime"}, +{ 0x200ae, "SetTimeBaseStopTime"}, +{ 0x200af, "GetTimeBaseMasterTimeBase"}, +{ 0x200b0, "GetTimeBaseMasterClock"}, +{ 0x200b1, "GetTimeBaseFlags"}, +{ 0x200b2, "SetTimeBaseFlags"}, +{ 0x200b3, "SetTimeBaseMasterClock"}, +{ 0x200b4, "SetTimeBaseMasterTimeBase"}, +{ 0x200b5, "ConvertTime"}, +{ 0x200b6, "DisposeTimeBase"}, +{ 0x200b7, "ConvertTimeScale"}, +{ 0x200b8, "CallMeWhen"}, +{ 0x200b9, "CancelCallBack"}, +{ 0x200c5, "GetMediaTrack"}, +{ 0x200cb, "PasteHandleIntoMovie"}, +{ 0x200cc, "IsScrapMovie"}, +{ 0x200d0, "GetTrackMovie"}, +{ 0x200d5, "CloseMovieFile"}, +{ 0x200d7, "AddMovieResource"}, +{ 0x200d8, "UpdateMovieResource"}, +{ 0x200d9, "HasMovieChanged"}, +{ 0x200dd, "IsMovieDone"}, +{ 0x200de, "ClearMoviesStickyError"}, +{ 0x200e1, "ClearMovieSelection"}, +{ 0x200e2, "GetTrackNextInterestingTime"}, +{ 0x200eb, "NewCallBack"}, +{ 0x200ec, "DisposeCallBack"}, +{ 0x200ed, "GetCallBackType"}, +{ 0x200ee, "GetCallBackTimeBase"}, +{ 0x200ef, "SetMoviesErrorProc"}, +{ 0x200f0, "NewMovieFromFile"}, +{ 0x200f1, "NewMovieFromHandle"}, +{ 0x200f2, "PlayMoviePreview"}, +{ 0x200f3, "GetMoviePreferredRate"}, +{ 0x200f4, "SetMoviePreferredRate"}, +{ 0x200f5, "GetMoviePreferredVolume"}, +{ 0x200f6, "SetMoviePreferredVolume"}, +{ 0x200f7, "GetMoviePosterPict"}, +{ 0x200f9, "GetMovieBox"}, +{ 0x200fa, "SetMovieBox"}, +{ 0x200fb, "GetMovieDisplayBoundsRgn"}, +{ 0x200fc, "GetMovieDisplayClipRgn"}, +{ 0x200fd, "SetMovieDisplayClipRgn"}, +{ 0x200fe, "GetMovieBoundsRgn"}, +{ 0x200ff, "GetTrackMovieBoundsRgn"}, +{ 0x20100, "GetMovieClipRgn"}, +{ 0x20101, "SetMovieClipRgn"}, +{ 0x20102, "GetTrackClipRgn"}, +{ 0x20103, "SetTrackClipRgn"}, +{ 0x20104, "NewMovieEditState"}, +{ 0x20105, "UseMovieEditState"}, +{ 0x20106, "DisposeMovieEditState"}, +{ 0x20107, "NewTrackEditState"}, +{ 0x20108, "UseTrackEditState"}, +{ 0x20109, "DisposeTrackEditState"}, +{ 0x2010b, "GetTimeBaseStatus"}, +{ 0x2010c, "AddTime"}, +{ 0x2010d, "SubtractTime"}, +{ 0x2010e, "GetMovieNextInterestingTime"}, +{ 0x20111, "GetTrackBoundsRgn"}, +{ 0x20112, "GetTrackDisplayBoundsRgn"}, +{ 0x20113, "ClearMovieChanged"}, +{ 0x20115, "GetTrackMatte"}, +{ 0x20116, "SetTrackMatte"}, +{ 0x20117, "GetMovieIndTrack"}, +{ 0x20121, "SetMediaShadowSync"}, +{ 0x20122, "GetMediaShadowSync"}, +{ 0x20123, "GetTrackEditRate"}, +{ 0x20124, "GetTimeBaseEffectiveRate"}, +{ 0x20126, "GetUserDataItem"}, +{ 0x20127, "GetTrackID"}, +{ 0x20128, "SetTimeBaseZero"}, +{ 0x20129, "AddCallBackToTimeBase"}, +{ 0x2012a, "RemoveCallBackFromTimeBase"}, +{ 0x2012b, "GetFirstCallBack"}, +{ 0x2012c, "GetNextCallBack"}, +{ 0x2012d, "ExecuteCallBack"}, +{ 0x2012e, "SetUserDataItem"}, +{ 0x2012f, "NewUserData"}, +{ 0x20130, "DisposeUserData"}, +{ 0x20131, "NewUserDataFromHandle"}, +{ 0x20132, "PutUserDataIntoHandle"}, +{ 0x20149, "GetTrackDataSize"}, +{ 0x2014a, "DisposeMatte"}, +{ 0x2014b, "CountUserDataType"}, +{ 0x2014c, "AddUserDataText"}, +{ 0x2014d, "GetUserDataText"}, +{ 0x2014e, "RemoveUserDataText"}, +{ 0x20152, "AddMovieSelection"}, +{ 0x20153, "CopyTrackSettings"}, +{ 0x20154, "CopyMovieSettings"}, +{ 0x2015c, "SetMovieActiveSegment"}, +{ 0x2015d, "GetMovieActiveSegment"}, +{ 0x2015e, "SetAutoTrackAlternatesEnabled"}, +{ 0x2015f, "SelectMovieAlternates"}, +{ 0x20167, "SetMovieMasterTimeBase"}, +{ 0x20168, "SetMovieMasterClock"}, +{ 0x2016b, "GetTrackSegmentDisplayBoundsRgn"}, +{ 0x2016c, "GetMovieSegmentDisplayBoundsRgn"}, +{ 0x2016d, "GetMediaNextInterestingTime"}, +{ 0x2016e, "LoadTrackIntoRam"}, +{ 0x2016f, "GetPosterBox"}, +{ 0x20170, "SetPosterBox"}, +{ 0x20172, "GetTrackStatus"}, +{ 0x20173, "GetMovieStatus"}, +{ 0x20175, "DeleteMovieFile"}, +{ 0x20176, "RemoveMovieResource"}, +{ 0x20179, "SetMovieCoverProcs"}, +{ 0x20183, "InsertMediaIntoTrack"}, +{ 0x20187, "NewMovie"}, +{ 0x20188, "NewMovieTrack"}, +{ 0x2018a, "NewMovieController"}, +{ 0x2018b, "DisposeMovieController"}, +{ 0x2018c, "PutMovieOnScrap"}, +{ 0x2018d, "NewMovieFromScrap"}, +{ 0x2018e, "NewTrackMedia"}, +{ 0x20190, "SetMediaHandler"}, +{ 0x20191, "CreateMovieFile"}, +{ 0x20192, "OpenMovieFile"}, +{ 0x20197, "GetMediaDataRef"}, +{ 0x20198, "AddMediaDataRef"}, +{ 0x20199, "GetMediaDataRefCount"}, +{ 0x2019a, "SetMovieProgressProc"}, +{ 0x2019b, "FlattenMovie"}, +{ 0x2019c, "FlattenMovieData"}, +{ 0x2019e, "GetMediaDataHandlerDescription"}, +{ 0x2019f, "GetMediaDataHandler"}, +{ 0x201a0, "SetMediaDataHandler"}, +{ 0x201a1, "SetMoviePlayHints"}, +{ 0x201a2, "SetMediaPlayHints"}, +{ 0x201a5, "GetNextUserDataType"}, +{ 0x201b3, "NewMovieFromDataFork"}, +{ 0x201b4, "PutMovieIntoDataFork"}, +{ 0x201c1, "SetMovieDefaultDataRef"}, +{ 0x201c9, "SetMediaDataRef"}, +{ 0x201ca, "SetMediaDataRefAttributes"}, +{ 0x201cb, "ConvertFileToMovieFile"}, +{ 0x201cc, "ConvertMovieToFile"}, +{ 0x201cd, "PutMovieIntoTypedHandle"}, +{ 0x201d0, "SetMediaSampleDescription"}, +{ 0x201d2, "GetMovieDefaultDataRef"}, +{ 0x201dd, "GetMovieCoverProcs"}, +{ 0x201de, "SetMovieDrawingCompleteProc"}, +{ 0x201e0, "SetMediaDefaultDataRefIndex"}, +{ 0x201e3, "SetTrackLoadSettings"}, +{ 0x201e4, "GetTrackLoadSettings"}, +{ 0x201ec, "NewMovieFromUserProc"}, +{ 0x201ed, "GetDataHandler"}, +{ 0x201f0, "AddTrackReference"}, +{ 0x201f1, "DeleteTrackReference"}, +{ 0x201f2, "SetTrackReference"}, +{ 0x201f3, "GetTrackReference"}, +{ 0x201f4, "GetNextTrackReferenceType"}, +{ 0x201f5, "GetTrackReferenceCount"}, +{ 0x201f7, "AddMediaSampleReferences"}, +{ 0x201f8, "SetMediaPreferredChunkSize"}, +{ 0x201f9, "GetMediaPreferredChunkSize"}, +{ 0x201fa, "GetNextTrackForCompositing"}, +{ 0x201fb, "GetPrevTrackForCompositing"}, +{ 0x201ff, "QTSwapAtoms"}, +{ 0x20200, "QTNextChildAnyType"}, +{ 0x20201, "QTNewAlias"}, +{ 0x20205, "SetMovieColorTable"}, +{ 0x20206, "GetMovieColorTable"}, +{ 0x20207, "MovieSearchText"}, +{ 0x20208, "GetMovieIndTrackType"}, +{ 0x20209, "ShowMovieInformation"}, +{ 0x2020c, "QTNewAtomContainer"}, +{ 0x2020d, "QTDisposeAtomContainer"}, +{ 0x2020e, "QTGetNextChildType"}, +{ 0x2020f, "QTCountChildrenOfType"}, +{ 0x20210, "QTFindChildByIndex"}, +{ 0x20211, "QTSetAtomData"}, +{ 0x20212, "QTCopyAtomDataToHandle"}, +{ 0x20213, "QTCopyAtomDataToPtr"}, +{ 0x20214, "QTCopyAtom"}, +{ 0x20215, "QTLockContainer"}, +{ 0x20216, "QTGetAtomDataPtr"}, +{ 0x20217, "QTUnlockContainer"}, +{ 0x20218, "QTInsertChild"}, +{ 0x20219, "QTInsertChildren"}, +{ 0x2021a, "QTRemoveAtom"}, +{ 0x2021b, "QTRemoveChildren"}, +{ 0x2021c, "QTReplaceAtom"}, +{ 0x2021d, "QTFindChildByID"}, +{ 0x20220, "NewMovieFromDataRef"}, +{ 0x2022a, "InvalidateMovieRegion"}, +{ 0x2022b, "TaskMovie"}, +{ 0x2022c, "GetMovieNaturalBoundsRect"}, +{ 0x2022e, "SetMediaPropertyAtom"}, +{ 0x2022f, "GetMediaPropertyAtom"}, +{ 0x20231, "QTSetAtomID"}, +{ 0x20232, "QTGetAtomTypeAndID"}, +{ 0x20233, "BeginFullScreen"}, +{ 0x20234, "EndFullScreen"}, +{ 0x20235, "GetMediaSampleReferences"}, +{ 0x20239, "NewSpriteWorld"}, +{ 0x2023a, "DisposeSpriteWorld"}, +{ 0x2023b, "SetSpriteWorldClip"}, +{ 0x2023c, "SetSpriteWorldMatrix"}, +{ 0x2023d, "SpriteWorldIdle"}, +{ 0x2023e, "InvalidateSpriteWorld"}, +{ 0x2023f, "DisposeAllSprites"}, +{ 0x20240, "NewSprite"}, +{ 0x20241, "DisposeSprite"}, +{ 0x20242, "InvalidateSprite"}, +{ 0x20243, "SetSpriteProperty"}, +{ 0x20244, "GetSpriteProperty"}, +{ 0x20246, "SpriteWorldHitTest"}, +{ 0x20247, "SpriteHitTest"}, +{ 0x20249, "GetMediaInputMap"}, +{ 0x2024a, "SetMediaInputMap"}, +{ 0x20263, "GetTrackDisplayMatrix"}, +{ 0x2027a, "ITextAddString"}, +{ 0x2027b, "ITextRemoveString"}, +{ 0x2027c, "ITextGetString"}, +{ 0x20282, "GetTrackSoundLocalizationSettings"}, +{ 0x20283, "SetTrackSoundLocalizationSettings"}, +{ 0x20284, "SetMoviePropertyAtom"}, +{ 0x20285, "GetMoviePropertyAtom"}, +{ 0x2029d, "QTNewTween"}, +{ 0x2029e, "QTDoTween"}, +{ 0x2029f, "QTDisposeTween"}, +{ 0x202b2, "GetMediaSyncSampleCount"}, +{ 0x202b3, "QTGetAccessKeys"}, +{ 0x202b4, "QTRegisterAccessKey"}, +{ 0x202b5, "QTUnregisterAccessKey"}, +{ 0x202be, "MakeTrackTimeTable"}, +{ 0x202bf, "MakeMediaTimeTable"}, +{ 0x202c0, "GetMaxLoadedTimeInMovie"}, +{ 0x202c2, "SetSpriteWorldFlags"}, +{ 0x202c3, "QTMovieNeedsTimeTable"}, +{ 0x202c6, "QTGetDataRefMaxFileOffset"}, +{ 0x202c7, "GetMovieImporterForDataRef"}, +{ 0x202c9, "QTGetEffectsList"}, +{ 0x202ca, "QTCreateStandardParameterDialog"}, +{ 0x202cb, "QTIsStandardParameterDialogEvent"}, +{ 0x202cc, "QTDismissStandardParameterDialog"}, +{ 0x202cd, "QTStandardParameterDialogDoAction"}, +{ 0x202ce, "GetMediaPlayHints"}, +{ 0x202cf, "AddSoundDescriptionExtension"}, +{ 0x202d0, "GetSoundDescriptionExtension"}, +{ 0x202d1, "RemoveSoundDescriptionExtension"}, +{ 0x202d2, "QTGetEffectSpeed"}, +{ 0x202d3, "QuickTimeExtensionLoaded"}, +{ 0x202d4, "GetQuickTimePreference"}, +{ 0x202d5, "SetQuickTimePreference"}, +{ 0x202d9, "SetSpriteWorldGraphicsMode"}, +{ 0x202da, "CheckQuickTimeRegistration"}, +{ 0x202db, "QTTextToNativeText"}, +{ 0x202e8, "AddMediaSampleReferences64"}, +{ 0x202e9, "GetMediaSampleReferences64"}, +{ 0x202ea, "PutMovieIntoDataFork64"}, +{ 0x202eb, "GetMovieDataSize64"}, +{ 0x202ec, "GetTrackDataSize64"}, +{ 0x202ed, "GetMediaDataSize64"}, +{ 0x202ee, "NewMovieFromDataFork64"}, +{ 0x202ef, "QTGetAtomParent"}, +{ 0x202f1, "QTReportMissingSoftware"}, +{ 0x202f4, "InstallQuickTimeExtensionRequest"}, +{ 0x202f5, "QTBandwidthRequest"}, +{ 0x202f6, "QTBandwidthRelease"}, +{ 0x202f7, "PrePrerollMovie"}, +{ 0x202f8, "AbortPrePrerollMovie"}, +{ 0x202f9, "QTTempNewHandle"}, +{ 0x202fa, "CreateShortcutMovieFile"}, +{ 0x202fe, "QTAltGetComputerSpeed"}, +{ 0x20300, "GetMovieProgressProc"}, +{ 0x20302, "AddMovieExecuteWiredActionsProc"}, +{ 0x20303, "RemoveMovieExecuteWiredActionsProc"}, +{ 0x20304, "MovieExecuteWiredActions"}, +{ 0x20310, "QTScheduledBandwidthRequest"}, +{ 0x20311, "QTScheduledBandwidthRelease"}, +{ 0x20314, "GetMovieLoadState"}, +{ 0x20315, "SetMovieAnchorDataRef"}, +{ 0x20316, "GetMovieAnchorDataRef"}, +{ 0x20318, "QTBandwidthRequestForTimeBase"}, +{ 0x20319, "QTParseTextHREF"}, +{ 0x2031b, "QTDoCallBacks"}, +{ 0x2031c, "OpenADataHandler"}, +{ 0x2031d, "QTListNew"}, +{ 0x2031e, "QTListDispose"}, +{ 0x2031f, "QTListElementRefNew"}, +{ 0x20320, "QTListElementRefDispose"}, +{ 0x20321, "QTListElementRefGetList"}, +{ 0x20322, "QTListElementRefClone"}, +{ 0x20323, "QTListInsertNewElement"}, +{ 0x20324, "QTListSetElementDataAs"}, +{ 0x20325, "QTListSetElementName"}, +{ 0x20326, "QTListDeleteElement"}, +{ 0x20327, "QTListCutSublist"}, +{ 0x20328, "QTListCopySublist"}, +{ 0x20329, "QTListPasteSublist"}, +{ 0x2032a, "QTListDeleteSublist"}, +{ 0x2032b, "QTListSetMatchingElementData"}, +{ 0x2032c, "QTListCountChildElements"}, +{ 0x2032d, "QTListFindRootElement"}, +{ 0x2032e, "QTListFindParentElement"}, +{ 0x2032f, "QTListFindElementByName"}, +{ 0x20330, "QTListFindElementByIndex"}, +{ 0x20331, "QTListFindChildElementByPathName"}, +{ 0x20332, "QTListGetElementName"}, +{ 0x20333, "QTListGetElementPathName"}, +{ 0x20334, "QTListGetElementTypeAndSize"}, +{ 0x20335, "QTListGetElementIndex"}, +{ 0x20336, "QTListInsertNewAttribute"}, +{ 0x20337, "QTListCopyElementDataToPtr"}, +{ 0x20338, "QTListValidateDataType"}, +{ 0x20339, "QTListWriteToXML"}, +{ 0x2033a, "QTListReadFromXML"}, +{ 0x2033e, "CanQuickTimeOpenFile"}, +{ 0x2033f, "CanQuickTimeOpenDataRef"}, +{ 0x20340, "SetMovieVideoOutput"}, +{ 0x20344, "AddClonedTrackToMovie"}, +{ 0x20347, "QTGetWallClockTimeBase"}, +{ 0x2034f, "QTListDeleteAttribute"}, +{ 0x20350, "QTListCountAttributes"}, +{ 0x20351, "QTListFindAttributeByIndex"}, +{ 0x20352, "QTListFindAttributeByName"}, +{ 0x20353, "QTListFindAttributeParentElement"}, +{ 0x20354, "QTListSetAttributeDataAs"}, +{ 0x20355, "QTListSetAttributeName"}, +{ 0x20356, "QTListGetAttributeName"}, +{ 0x20357, "QTListAttributeRefNew"}, +{ 0x20358, "QTListAttributeRefDispose"}, +{ 0x20359, "QTListAttributeRefClone"}, +{ 0x2035a, "QTListGetAttributeTypeAndSize"}, +{ 0x2035b, "QTListGetAttributeIndex"}, +{ 0x2035c, "QTListCopyAttributeDataToPtr"}, +{ 0x190002, "NewPalette"}, +{ 0x190003, "GetNewPalette"}, +{ 0x190004, "DisposePalette"}, +{ 0x190005, "ActivatePalette"}, +{ 0x190006, "SetPalette"}, +{ 0x190007, "NSetPalette"}, +{ 0x190008, "GetPalette"}, +{ 0x190009, "CopyPalette"}, +{ 0x19000a, "PmForeColor"}, +{ 0x19000b, "PmBackColor"}, +{ 0x19000e, "GetEntryColor"}, +{ 0x19000f, "SetEntryColor"}, +{ 0x190010, "GetEntryUsage"}, +{ 0x190011, "SetEntryUsage"}, +{ 0x190012, "CTab2Palette"}, +{ 0x190013, "Palette2CTab"}, +{ 0x190014, "Entry2Index"}, +{ 0x190016, "MacResizePalette"}, +{ 0x190017, "SaveFore"}, +{ 0x190018, "SaveBack"}, +{ 0x190019, "RestoreFore"}, +{ 0x19001a, "RestoreBack"}, +{ 0x19001d, "PMgrVersion"}, +{ 0x19001e, "SetPaletteUpdates"}, +{ 0x19001f, "GetPaletteUpdates"}, +{ 0x190020, "GetGray"}, +{ 0x1e0002, "OpenPort"}, +{ 0x1e0003, "InitPort"}, +{ 0x1e0004, "ClosePort"}, +{ 0x1e0005, "MacSetPort"}, +{ 0x1e0006, "GetPort"}, +{ 0x1e0008, "SetPortBits"}, +{ 0x1e0009, "PortSize"}, +{ 0x1e000a, "MovePortTo"}, +{ 0x1e000b, "SetOrigin"}, +{ 0x1e000c, "SetClip"}, +{ 0x1e000d, "GetClip"}, +{ 0x1e000e, "ClipRect"}, +{ 0x1e000f, "BackPat"}, +{ 0x1e0010, "InitCursor"}, +{ 0x1e0011, "MacSetCursor"}, +{ 0x1e0012, "HideCursor"}, +{ 0x1e0013, "MacShowCursor"}, +{ 0x1e0014, "ObscureCursor"}, +{ 0x1e0015, "HidePen"}, +{ 0x1e0016, "ShowPen"}, +{ 0x1e0017, "GetPen"}, +{ 0x1e0018, "GetPenState"}, +{ 0x1e0019, "SetPenState"}, +{ 0x1e001a, "PenSize"}, +{ 0x1e001b, "PenMode"}, +{ 0x1e001c, "PenPat"}, +{ 0x1e001d, "PenNormal"}, +{ 0x1e001e, "MoveTo"}, +{ 0x1e001f, "Move"}, +{ 0x1e0020, "MacLineTo"}, +{ 0x1e0021, "Line"}, +{ 0x1e0022, "ForeColor"}, +{ 0x1e0023, "BackColor"}, +{ 0x1e0024, "ColorBit"}, +{ 0x1e0025, "MacSetRect"}, +{ 0x1e0026, "MacOffsetRect"}, +{ 0x1e0027, "MacInsetRect"}, +{ 0x1e0028, "SectRect"}, +{ 0x1e0029, "MacUnionRect"}, +{ 0x1e002a, "MacEqualRect"}, +{ 0x1e002b, "EmptyRect"}, +{ 0x1e002c, "MacFrameRect"}, +{ 0x1e002d, "PaintRect"}, +{ 0x1e002e, "EraseRect"}, +{ 0x1e002f, "MacInvertRect"}, +{ 0x1e0030, "MacFillRect"}, +{ 0x1e0031, "FrameOval"}, +{ 0x1e0032, "PaintOval"}, +{ 0x1e0033, "EraseOval"}, +{ 0x1e0034, "InvertOval"}, +{ 0x1e0035, "FillOval"}, +{ 0x1e0036, "FrameRoundRect"}, +{ 0x1e0037, "PaintRoundRect"}, +{ 0x1e0038, "EraseRoundRect"}, +{ 0x1e0039, "InvertRoundRect"}, +{ 0x1e003a, "FillRoundRect"}, +{ 0x1e003b, "FrameArc"}, +{ 0x1e003c, "PaintArc"}, +{ 0x1e003d, "EraseArc"}, +{ 0x1e003e, "InvertArc"}, +{ 0x1e003f, "FillArc"}, +{ 0x1e0040, "NewRgn"}, +{ 0x1e0041, "OpenRgn"}, +{ 0x1e0042, "CloseRgn"}, +{ 0x1e0043, "BitMapToRegion"}, +{ 0x1e0044, "DisposeRgn"}, +{ 0x1e0045, "MacCopyRgn"}, +{ 0x1e0046, "SetEmptyRgn"}, +{ 0x1e0047, "MacSetRectRgn"}, +{ 0x1e0048, "RectRgn"}, +{ 0x1e0049, "MacOffsetRgn"}, +{ 0x1e004a, "InsetRgn"}, +{ 0x1e004b, "SectRgn"}, +{ 0x1e004c, "MacUnionRgn"}, +{ 0x1e004d, "DiffRgn"}, +{ 0x1e004e, "MacXorRgn"}, +{ 0x1e004f, "RectInRgn"}, +{ 0x1e0050, "MacEqualRgn"}, +{ 0x1e0051, "EmptyRgn"}, +{ 0x1e0052, "MacFrameRgn"}, +{ 0x1e0053, "MacPaintRgn"}, +{ 0x1e0054, "EraseRgn"}, +{ 0x1e0055, "MacInvertRgn"}, +{ 0x1e0056, "MacFillRgn"}, +{ 0x1e0057, "ScrollRect"}, +{ 0x1e0058, "CopyBits"}, +{ 0x1e0059, "SeedFill"}, +{ 0x1e005a, "CalcMask"}, +{ 0x1e005b, "CopyMask"}, +{ 0x1e005c, "OpenPicture"}, +{ 0x1e005d, "PicComment"}, +{ 0x1e005e, "ClosePicture"}, +{ 0x1e005f, "DrawPicture"}, +{ 0x1e0060, "KillPicture"}, +{ 0x1e0061, "OpenPoly"}, +{ 0x1e0062, "ClosePoly"}, +{ 0x1e0063, "KillPoly"}, +{ 0x1e0064, "OffsetPoly"}, +{ 0x1e0065, "FramePoly"}, +{ 0x1e0066, "PaintPoly"}, +{ 0x1e0067, "ErasePoly"}, +{ 0x1e0068, "InvertPoly"}, +{ 0x1e0069, "FillPoly"}, +{ 0x1e006a, "SetPt"}, +{ 0x1e006b, "LocalToGlobal"}, +{ 0x1e006c, "GlobalToLocal"}, +{ 0x1e006d, "Random"}, +{ 0x1e006e, "StuffHex"}, +{ 0x1e006f, "MacGetPixel"}, +{ 0x1e0070, "ScalePt"}, +{ 0x1e0071, "MapPt"}, +{ 0x1e0072, "MapRect"}, +{ 0x1e0073, "MapRgn"}, +{ 0x1e0074, "MapPoly"}, +{ 0x1e0075, "SetStdProcs"}, +{ 0x1e0076, "StdRect"}, +{ 0x1e0077, "StdRRect"}, +{ 0x1e0078, "StdOval"}, +{ 0x1e0079, "StdArc"}, +{ 0x1e007a, "StdPoly"}, +{ 0x1e007b, "StdRgn"}, +{ 0x1e007c, "StdBits"}, +{ 0x1e007d, "StdComment"}, +{ 0x1e007e, "StdGetPic"}, +{ 0x1e007f, "StdPutPic"}, +{ 0x1e0080, "AddPt"}, +{ 0x1e0081, "EqualPt"}, +{ 0x1e0082, "MacPtInRect"}, +{ 0x1e0083, "Pt2Rect"}, +{ 0x1e0084, "PtToAngle"}, +{ 0x1e0085, "SubPt"}, +{ 0x1e0086, "PtInRgn"}, +{ 0x1e0087, "StdLine"}, +{ 0x1e0088, "OpenCPort"}, +{ 0x1e0089, "InitCPort"}, +{ 0x1e008a, "CloseCPort"}, +{ 0x1e008b, "NewPixMap"}, +{ 0x1e008c, "DisposePixMap"}, +{ 0x1e008d, "CopyPixMap"}, +{ 0x1e008e, "NewPixPat"}, +{ 0x1e008f, "DisposePixPat"}, +{ 0x1e0090, "CopyPixPat"}, +{ 0x1e0091, "PenPixPat"}, +{ 0x1e0092, "BackPixPat"}, +{ 0x1e0093, "GetPixPat"}, +{ 0x1e0094, "MakeRGBPat"}, +{ 0x1e0095, "FillCRect"}, +{ 0x1e0096, "FillCOval"}, +{ 0x1e0097, "FillCRoundRect"}, +{ 0x1e0098, "FillCArc"}, +{ 0x1e0099, "FillCRgn"}, +{ 0x1e009a, "FillCPoly"}, +{ 0x1e009b, "RGBForeColor"}, +{ 0x1e009c, "RGBBackColor"}, +{ 0x1e009d, "SetCPixel"}, +{ 0x1e009e, "SetPortPix"}, +{ 0x1e009f, "GetCPixel"}, +{ 0x1e00a0, "GetForeColor"}, +{ 0x1e00a1, "GetBackColor"}, +{ 0x1e00a2, "SeedCFill"}, +{ 0x1e00a3, "CalcCMask"}, +{ 0x1e00a4, "OpenCPicture"}, +{ 0x1e00a5, "OpColor"}, +{ 0x1e00a6, "HiliteColor"}, +{ 0x1e00a7, "DisposeCTable"}, +{ 0x1e00a8, "GetCTable"}, +{ 0x1e00a9, "GetCCursor"}, +{ 0x1e00aa, "SetCCursor"}, +{ 0x1e00ac, "DisposeCCursor"}, +{ 0x1e00b0, "SetStdCProcs"}, +{ 0x1e00b1, "GetMaxDevice"}, +{ 0x1e00b2, "GetCTSeed"}, +{ 0x1e00b3, "GetDeviceList"}, +{ 0x1e00b4, "GetMainDevice"}, +{ 0x1e00b5, "GetNextDevice"}, +{ 0x1e00b6, "TestDeviceAttribute"}, +{ 0x1e00b7, "SetDeviceAttribute"}, +{ 0x1e00b8, "InitGDevice"}, +{ 0x1e00b9, "NewGDevice"}, +{ 0x1e00ba, "DisposeGDevice"}, +{ 0x1e00bb, "SetGDevice"}, +{ 0x1e00bc, "GetGDevice"}, +{ 0x1e00bd, "Color2Index"}, +{ 0x1e00be, "Index2Color"}, +{ 0x1e00bf, "InvertColor"}, +{ 0x1e00c0, "RealColor"}, +{ 0x1e00c1, "GetSubTable"}, +{ 0x1e00c2, "MakeITable"}, +{ 0x1e00c3, "AddSearch"}, +{ 0x1e00c4, "AddComp"}, +{ 0x1e00c5, "DelSearch"}, +{ 0x1e00c6, "DelComp"}, +{ 0x1e00c7, "SetClientID"}, +{ 0x1e00c8, "ProtectEntry"}, +{ 0x1e00c9, "ReserveEntry"}, +{ 0x1e00ca, "SetEntries"}, +{ 0x1e00cb, "SaveEntries"}, +{ 0x1e00cc, "RestoreEntries"}, +{ 0x1e00cd, "QDError"}, +{ 0x1e00ce, "CopyDeepMask"}, +{ 0x1e00cf, "DeviceLoop"}, +{ 0x1e00d3, "MacGetCursor"}, +{ 0x1e00d4, "GetPicture"}, +{ 0x1e00d6, "ShieldCursor"}, +{ 0x1e00d9, "PackBits"}, +{ 0x1e00da, "UnpackBits"}, +{ 0x1e00db, "SlopeFromAngle"}, +{ 0x1e00dc, "AngleFromSlope"}, +{ 0x1e00dd, "LockPortBits"}, +{ 0x1e00de, "UnlockPortBits"}, +{ 0x1e00e1, "UpdatePort"}, +{ 0x1e00e4, "CopyBitsGDI"}, +{ 0x30000, "CodecManagerVersion"}, +{ 0x30001, "GetCodecNameList"}, +{ 0x30003, "GetCodecInfo"}, +{ 0x30004, "GetMaxCompressionSize"}, +{ 0x30005, "GetCompressionTime"}, +{ 0x30006, "CompressImage"}, +{ 0x30007, "FCompressImage"}, +{ 0x30008, "DecompressImage"}, +{ 0x30009, "FDecompressImage"}, +{ 0x3000a, "CompressSequenceBegin"}, +{ 0x3000b, "CompressSequenceFrame"}, +{ 0x3000c, "StdPix"}, +{ 0x3000d, "DecompressSequenceBegin"}, +{ 0x3000e, "DecompressSequenceFrame"}, +{ 0x3000f, "DisposeCodecNameList"}, +{ 0x30010, "SetDSequenceMatrix"}, +{ 0x30011, "SetDSequenceMatte"}, +{ 0x30012, "SetDSequenceMask"}, +{ 0x30013, "SetDSequenceTransferMode"}, +{ 0x30014, "SetDSequenceDataProc"}, +{ 0x30015, "GetDSequenceImageBuffer"}, +{ 0x30016, "GetDSequenceScreenBuffer"}, +{ 0x30017, "SetCSequenceQuality"}, +{ 0x30018, "SetCSequencePrev"}, +{ 0x30019, "GetCSequencePrevBuffer"}, +{ 0x3001a, "CDSequenceBusy"}, +{ 0x3001b, "CDSequenceEnd"}, +{ 0x3001c, "GetCompressedImageSize"}, +{ 0x3001d, "GetSimilarity"}, +{ 0x3001e, "GetImageDescriptionCTable"}, +{ 0x3001f, "SetImageDescriptionCTable"}, +{ 0x30020, "GetImageDescriptionExtension"}, +{ 0x30021, "AddImageDescriptionExtension"}, +{ 0x30023, "FindCodec"}, +{ 0x30024, "CompressPicture"}, +{ 0x30025, "FCompressPicture"}, +{ 0x30026, "CompressPictureFile"}, +{ 0x30027, "FCompressPictureFile"}, +{ 0x30028, "GetPictureFileHeader"}, +{ 0x30029, "DrawPictureFile"}, +{ 0x3002a, "MakeThumbnailFromPicture"}, +{ 0x3002b, "MakeThumbnailFromPictureFile"}, +{ 0x3002c, "MakeThumbnailFromPixMap"}, +{ 0x3002d, "TrimImage"}, +{ 0x3002e, "DrawTrimmedPicture"}, +{ 0x3002f, "DrawTrimmedPictureFile"}, +{ 0x30030, "ConvertImage"}, +{ 0x30033, "SetCSequenceFlushProc"}, +{ 0x30034, "SetDSequenceAccuracy"}, +{ 0x30035, "SetDSequenceSrcRect"}, +{ 0x30036, "SetCSequenceKeyFrameRate"}, +{ 0x30037, "GetCompressedPixMapInfo"}, +{ 0x30038, "SetCompressedPixMapInfo"}, +{ 0x30039, "TransformRgn"}, +{ 0x3003a, "RemoveImageDescriptionExtension"}, +{ 0x3003b, "CountImageDescriptionExtensionType"}, +{ 0x3003c, "GetNextImageDescriptionExtensionType"}, +{ 0x30041, "SFGetFilePreview"}, +{ 0x30042, "SFPGetFilePreview"}, +{ 0x30043, "StandardGetFilePreview"}, +{ 0x30044, "CustomGetFilePreview"}, +{ 0x30045, "MakeFilePreview"}, +{ 0x30046, "AddFilePreview"}, +{ 0x30047, "DecompressSequenceFrameS"}, +{ 0x3004b, "GetCSequenceKeyFrameRate"}, +{ 0x3004c, "AlignScreenRect"}, +{ 0x3004d, "AlignWindow"}, +{ 0x3004e, "DragAlignedWindow"}, +{ 0x3004f, "DragAlignedGrayRgn"}, +{ 0x30050, "SetCSequenceDataRateParams"}, +{ 0x30051, "SetCSequenceFrameNumber"}, +{ 0x30052, "NewImageGWorld"}, +{ 0x30053, "GetCSequenceDataRateParams"}, +{ 0x30054, "GetCSequenceFrameNumber"}, +{ 0x30055, "GetBestDeviceRect"}, +{ 0x30056, "SetSequenceProgressProc"}, +{ 0x30057, "SetDSequenceFlags"}, +{ 0x3005a, "GDHasScale"}, +{ 0x3005b, "GDGetScale"}, +{ 0x3005c, "GDSetScale"}, +{ 0x3005d, "DecompressSequenceBeginS"}, +{ 0x3005e, "DecompressSequenceFrameWhen"}, +{ 0x3005f, "CDSequenceFlush"}, +{ 0x30061, "QTGetFileNameExtension"}, +{ 0x30062, "ICMShieldSequenceCursor"}, +{ 0x30063, "ICMDecompressComplete"}, +{ 0x30064, "SetDSequenceTimeCode"}, +{ 0x30065, "CDSequenceEquivalentImageDescription"}, +{ 0x30066, "CDSequenceNewMemory"}, +{ 0x30067, "CDSequenceDisposeMemory"}, +{ 0x30068, "CDSequenceNewDataSource"}, +{ 0x30069, "CDSequenceDisposeDataSource"}, +{ 0x3006a, "CDSequenceSetSourceData"}, +{ 0x3006b, "CDSequenceChangedSourceData"}, +{ 0x3006c, "PtInDSequenceData"}, +{ 0x3006d, "ImageFieldSequenceBegin"}, +{ 0x3006e, "GetGraphicsImporterForFile"}, +{ 0x3006f, "ImageTranscodeSequenceBegin"}, +{ 0x30070, "ImageTranscodeSequenceEnd"}, +{ 0x30071, "ImageTranscodeFrame"}, +{ 0x30072, "ImageTranscodeDisposeFrameData"}, +{ 0x30073, "CDSequenceInvalidate"}, +{ 0x30074, "GetCSequenceMaxCompressionSize"}, +{ 0x30075, "ImageFieldSequenceExtractCombine"}, +{ 0x30076, "ImageFieldSequenceEnd"}, +{ 0x30077, "GetGraphicsImporterForDataRef"}, +{ 0x30078, "SetCSequencePreferredPacketSize"}, +{ 0x30079, "CDSequenceSetTimeBase"}, +{ 0x3007a, "MakeImageDescriptionForPixMap"}, +{ 0x3007b, "CDSequenceSetSourceDataQueue"}, +{ 0x3007c, "ICMSequenceLockBits"}, +{ 0x3007d, "ICMSequenceUnlockBits"}, +{ 0x3007e, "ICMSequenceGetChainMember"}, +{ 0x3007f, "CDSequenceGetDataSource"}, +{ 0x30080, "QTNewGWorld"}, +{ 0x30081, "QTUpdateGWorld"}, +{ 0x30082, "ICMDecompressCompleteS"}, +{ 0x30083, "ICMGetPixelFormatInfo"}, +{ 0x30084, "GetGraphicsImporterForFileWithFlags"}, +{ 0x30085, "GetGraphicsImporterForDataRefWithFlags"}, +{ 0x30086, "QTGetPixelSize"}, +{ 0x30087, "HitTestDSequenceData"}, +{ 0x30089, "ICMSequenceGetInfo"}, +{ 0x3008a, "ICMSetPixelFormatInfo"}, +{ 0x3008b, "QTNewGWorldFromPtr"}, +{ 0x3008d, "QTGetPixMapPtrRowBytes"}, +{ 0x3008e, "QTGetPixMapHandleRowBytes"}, +{ 0x3008f, "QTSetPixMapHandleRowBytes"}, +{ 0x30090, "QTSetPixMapPtrRowBytes"}, +{ 0x30091, "GetDSequenceMatrix"}, +{ 0x30092, "MakeImageDescriptionForEffect"}, +{ 0x30093, "QTGetPixMapPtrGammaLevel"}, +{ 0x30094, "QTSetPixMapPtrGammaLevel"}, +{ 0x30095, "QuadToQuadMatrix"}, +{ 0x30096, "QTGetPixMapHandleGammaLevel"}, +{ 0x30097, "QTSetPixMapHandleGammaLevel"}, +{ 0x30098, "QTGetPixMapPtrRequestedGammaLevel"}, +{ 0x30099, "QTSetPixMapPtrRequestedGammaLevel"}, +{ 0x3009a, "QTGetPixMapHandleRequestedGammaLevel"}, +{ 0x3009b, "QTSetPixMapHandleRequestedGammaLevel"}, +{ 0x3009c, "OpenPreviewComponentForFile"}, +{ 0x3009d, "ICMSequenceSetInfo"}, +{ 0x3009f, "CDSequenceEquivalentImageDescriptionS"}, +{ 0x300a0, "ReplaceDSequenceImageDescription"}, +{ 0x200003, "CloseResFile"}, +{ 0x200004, "ResError"}, +{ 0x200005, "CurResFile"}, +{ 0x200006, "HomeResFile"}, +{ 0x200009, "UseResFile"}, +{ 0x20000a, "CountTypes"}, +{ 0x20000b, "Count1Types"}, +{ 0x20000c, "GetIndType"}, +{ 0x20000d, "Get1IndType"}, +{ 0x20000e, "SetResLoad"}, +{ 0x20000f, "CountResources"}, +{ 0x200010, "Count1Resources"}, +{ 0x200011, "GetIndResource"}, +{ 0x200012, "Get1IndResource"}, +{ 0x200013, "GetResource"}, +{ 0x200014, "Get1Resource"}, +{ 0x200015, "GetNamedResource"}, +{ 0x200016, "Get1NamedResource"}, +{ 0x200017, "MacLoadResource"}, +{ 0x200018, "ReleaseResource"}, +{ 0x200019, "DetachResource"}, +{ 0x20001a, "UniqueID"}, +{ 0x20001b, "Unique1ID"}, +{ 0x20001c, "GetResAttrs"}, +{ 0x20001d, "GetResInfo"}, +{ 0x20001e, "SetResInfo"}, +{ 0x20001f, "AddResource"}, +{ 0x200020, "GetResourceSizeOnDisk"}, +{ 0x200023, "SetResAttrs"}, +{ 0x200024, "ChangedResource"}, +{ 0x200025, "RemoveResource"}, +{ 0x200026, "UpdateResFile"}, +{ 0x200027, "WriteResource"}, +{ 0x200028, "SetResPurge"}, +{ 0x200029, "GetResFileAttrs"}, +{ 0x20002a, "SetResFileAttrs"}, +{ 0x20002f, "FSpOpenResFile"}, +{ 0x200030, "FSpCreateResFile"}, +{ 0x200033, "SetResourceSize"}, +{ 0x200036, "RegisterResourceEndianFilter"}, +{ 0x200037, "GetIndString"}, +{ 0x0c0003, "NewDialog"}, +{ 0x0c0004, "GetNewDialog"}, +{ 0x0c0006, "CloseDialog"}, +{ 0x0c0007, "DisposeDialog"}, +{ 0x0c0008, "ModalDialog"}, +{ 0x0c0009, "IsDialogEvent"}, +{ 0x0c000a, "DialogSelect"}, +{ 0x0c000b, "DrawDialog"}, +{ 0x0c000c, "UpdateDialog"}, +{ 0x0c000d, "HideDialogItem"}, +{ 0x0c000e, "ShowDialogItem"}, +{ 0x0c000f, "FindDialogItem"}, +{ 0x0c0014, "Alert"}, +{ 0x0c0015, "StopAlert"}, +{ 0x0c0016, "NoteAlert"}, +{ 0x0c0017, "CautionAlert"}, +{ 0x0c0018, "GetDialogItem"}, +{ 0x0c0019, "SetDialogItem"}, +{ 0x0c001a, "ParamText"}, +{ 0x0c001b, "SelectDialogItemText"}, +{ 0x0c001c, "GetDialogItemText"}, +{ 0x0c001d, "SetDialogItemText"}, +{ 0x0c0021, "AppendDITL"}, +{ 0x0c0022, "CountDITL"}, +{ 0x0c0023, "ShortenDITL"}, +{ 0x0c0024, "StdFilterProc"}, +{ 0x0c0025, "GetStdFilterProc"}, +{ 0x0c0026, "SetDialogDefaultItem"}, +{ 0x0c0027, "SetDialogCancelItem"}, +{ 0x0c0028, "SetDialogTracksCursor"}, +{ 0x0c002d, "NewColorDialog"}, +{ 0x0c002e, "SetModelessDialogCallbackProc"}, +{ 0x0c002f, "GetDialogItemAsControl"}, +{ 0x0c0030, "SetDialogMovableModal"}, +{ 0x0c0031, "MoveDialogItem"}, +{ 0x0c0032, "SizeDialogItem"}, +{ 0x1c0001, "NewGWorld"}, +{ 0x1c0002, "LockPixels"}, +{ 0x1c0003, "UnlockPixels"}, +{ 0x1c0004, "UpdateGWorld"}, +{ 0x1c0005, "DisposeGWorld"}, +{ 0x1c0006, "GetGWorld"}, +{ 0x1c0007, "SetGWorld"}, +{ 0x1c0008, "CTabChanged"}, +{ 0x1c0009, "PixPatChanged"}, +{ 0x1c000a, "PortChanged"}, +{ 0x1c000b, "GDeviceChanged"}, +{ 0x1c000c, "AllowPurgePixels"}, +{ 0x1c000d, "NoPurgePixels"}, +{ 0x1c000e, "GetPixelsState"}, +{ 0x1c000f, "SetPixelsState"}, +{ 0x1c0010, "GetPixBaseAddr"}, +{ 0x1c0011, "NewScreenBuffer"}, +{ 0x1c0012, "DisposeScreenBuffer"}, +{ 0x1c0013, "GetGWorldDevice"}, +{ 0x1c0014, "QDDone"}, +{ 0x1c0015, "OffscreenVersion"}, +{ 0x1c0016, "NewTempScreenBuffer"}, +{ 0x1c0017, "PixMap32Bit"}, +{ 0x1c0018, "GetGWorldPixMap"}, +{ 0x1c0019, "NewGWorldFromPtr"}, +{ 0x160001, "GetMBarHeight"}, +{ 0x160002, "NewMenu"}, +{ 0x160003, "MacGetMenu"}, +{ 0x160004, "MacAppendMenu"}, +{ 0x160005, "MacInsertMenu"}, +{ 0x160006, "MacDeleteMenu"}, +{ 0x160007, "AppendResMenu"}, +{ 0x160008, "MacInsertMenuItem"}, +{ 0x160009, "SetMenuItemText"}, +{ 0x16000a, "GetMenuItemText"}, +{ 0x16000b, "SetItemMark"}, +{ 0x16000c, "GetItemMark"}, +{ 0x16000d, "SetItemCmd"}, +{ 0x16000e, "GetItemCmd"}, +{ 0x16000f, "SetItemIcon"}, +{ 0x160010, "GetItemIcon"}, +{ 0x160011, "SetItemStyle"}, +{ 0x160012, "GetItemStyle"}, +{ 0x160013, "GetMenuHandle"}, +{ 0x160014, "CalcMenuSize"}, +{ 0x160015, "DisableItem"}, +{ 0x160016, "EnableItem"}, +{ 0x160017, "FlashMenuBar"}, +{ 0x160018, "PopUpMenuSelect"}, +{ 0x16001f, "MacDrawMenuBar"}, +{ 0x160020, "InvalMenuBar"}, +{ 0x160021, "InitProcMenu"}, +{ 0x160022, "GetMenuBar"}, +{ 0x160023, "SetMenuBar"}, +{ 0x160024, "SystemEdit"}, +{ 0x160025, "SystemMenu"}, +{ 0x160026, "GetNewMBar"}, +{ 0x160027, "ClearMenuBar"}, +{ 0x160028, "CheckItem"}, +{ 0x160029, "CountMItems"}, +{ 0x16002a, "SetMenuFlash"}, +{ 0x16002b, "InitMenus"}, +{ 0x16002c, "MenuKey"}, +{ 0x16002d, "MenuSelect"}, +{ 0x16002e, "MenuChoice"}, +{ 0x16002f, "DisposeMenu"}, +{ 0x160030, "DeleteMenuItem"}, +{ 0x160031, "HiliteMenu"}, +{ 0x160032, "InsertResMenu"}, +{ 0x160033, "InsertFontResMenu"}, +{ 0x160034, "InsertIntlResMenu"}, + +{ 0x1d0001, "CreatePortAssociation"}, +{ 0x1d0002, "DestroyPortAssociation"}, +{ 0x1d0003, "GetNativeWindowPort"}, +{ 0x1d0004, "GetPortNativeWindow"}, +{ 0x1d0008, "QTMLInitInternals"}, +{ 0x1d0009, "QTMLTermInternals"}, +{ 0x1d000a, "NativeEventToMacEvent"}, +{ 0x1d000e, "RegisterAbortAction"}, +{ 0x1d000f, "UnregisterAbortAction"}, +{ 0x1d0010, "InitializeQHdr"}, +{ 0x1d0011, "TerminateQHdr"}, +{ 0x1d0012, "QTMLYieldCPU"}, +{ 0x1d0013, "QTMLRegisterInterruptSafeThread"}, +{ 0x1d0014, "QTMLUnregisterInterruptSafeThread"}, +{ 0x1d0017, "Endian64_Swap"}, +{ 0x1d0019, "GetColor"}, +{ 0x1d001a, "FindFolderEx"}, +{ 0x1d001d, "ldtox80"}, +{ 0x1d001e, "x80told"}, +{ 0x1d0021, "Debugger"}, +{ 0x1d0022, "DebugStr"}, +{ 0x1d0024, "QTMLYieldCPUTime"}, +{ 0x1d0027, "QTMLGetCanonicalPathName"}, +{ 0x1d0028, "QTMLGetVolumeRootPath"}, +{ 0x1d0029, "QTMLAcquireWindowList"}, +{ 0x1d002a, "QTMLReleaseWindowList"}, +{ 0x1d002b, "NativeRegionToMacRegion"}, +{ 0x1d002c, "MacRegionToNativeRegion"}, +{ 0x1d002d, "FSSpecToNativePathName"}, +{ 0x1d002e, "NativePathNameToFSSpec"}, + +{ 0x1d0033, "QTMLCreateMutex"}, +{ 0x1d0034, "QTMLDestroyMutex"}, +{ 0x1d0035, "QTMLGrabMutex"}, +{ 0x1d0036, "QTMLReturnMutex"}, + +{ 0x1d0037, "QTMLCreateSyncVar"}, +{ 0x1d0038, "QTMLDestroySyncVar"}, +{ 0x1d0039, "QTMLTestAndSetSyncVar"}, +{ 0x1d003a, "QTMLWaitAndSetSyncVar"}, +{ 0x1d003b, "QTMLResetSyncVar"}, + +{ 0x1d003d, "QTMLTryGrabMutex"}, + +{ 0x1d004e, "QTMLGetDirectXObject"}, +{ 0x1d004f, "QTMLSetDirectXObject"}, +{ 0x1d0052, "QTGetAliasInfo"}, + +{ 0x170001, "NewGWorldFromHBITMAP"}, +{ 0x170003, "QTSetDDPrimarySurface"}, +{ 0x170004, "QTGetDDObject"}, +{ 0x170005, "QTMLSetWindowWndProc"}, +{ 0x170006, "QTMLGetWindowWndProc"}, +{ 0x170007, "GetPortHDC"}, +{ 0x170008, "GetPortHBITMAP"}, +{ 0x170009, "GetPortHPALETTE"}, +{ 0x17000a, "GetPortHFONT"}, +{ 0x17000b, "ShowHideTaskBar"}, +{ 0x17000c, "IsTaskBarVisible"}, +{ 0x17000e, "QTSetDDObject"}, +{ 0x17000f, "GetDIBFromPICT"}, +{ 0x170010, "GetPICTFromDIB"}, +{ 0x170011, "GetGDeviceSurface"}, +{ 0x170012, "GetGDeviceAttributes"}, +{ 0x150002, "SystemZone"}, +{ 0x150003, "ApplicationZone"}, +{ 0x150006, "MemError"}, +{ 0x150007, "GetZone"}, +{ 0x150008, "NewHandle"}, +{ 0x150009, "NewHandleSys"}, +{ 0x15000a, "NewHandleClear"}, +{ 0x15000b, "NewHandleSysClear"}, +{ 0x15000c, "HandleZone"}, +{ 0x15000d, "RecoverHandle"}, +{ 0x15000f, "NewPtr"}, +{ 0x150010, "NewPtrSys"}, +{ 0x150011, "NewPtrClear"}, +{ 0x150012, "NewPtrSysClear"}, +{ 0x150013, "PtrZone"}, +{ 0x150014, "MaxBlock"}, +{ 0x150015, "MaxBlockSys"}, +{ 0x150017, "NewEmptyHandle"}, +{ 0x150018, "NewEmptyHandleSys"}, +{ 0x150019, "HLock"}, +{ 0x15001a, "HUnlock"}, +{ 0x15001b, "HPurge"}, +{ 0x15001c, "HNoPurge"}, +{ 0x15001d, "HLockHi"}, +{ 0x15001e, "TempNewHandle"}, +{ 0x15001f, "TempMaxMem"}, +{ 0x150020, "TempFreeMem"}, +{ 0x150022, "SetZone"}, +{ 0x150023, "CompactMem"}, +{ 0x150024, "CompactMemSys"}, +{ 0x150025, "PurgeMem"}, +{ 0x150026, "PurgeMemSys"}, +{ 0x150027, "FreeMem"}, +{ 0x150028, "FreeMemSys"}, +{ 0x150029, "ReserveMem"}, +{ 0x15002a, "ReserveMemSys"}, +{ 0x15002b, "MaxMem"}, +{ 0x15002c, "MaxMemSys"}, +{ 0x15002e, "MoveHHi"}, +{ 0x15002f, "DisposePtr"}, +{ 0x150030, "GetPtrSize"}, +{ 0x150031, "SetPtrSize"}, +{ 0x150032, "DisposeHandle"}, +{ 0x150033, "SetHandleSize"}, +{ 0x150034, "GetHandleSize"}, +{ 0x150036, "ReallocateHandle"}, +{ 0x150038, "EmptyHandle"}, +{ 0x15003b, "HGetState"}, +{ 0x15003c, "HSetState"}, +{ 0x15003d, "PurgeSpace"}, +{ 0x15003e, "BlockMove"}, +{ 0x15003f, "BlockMoveData"}, +{ 0x150045, "TempHLock"}, +{ 0x150046, "TempHUnlock"}, +{ 0x150047, "TempDisposeHandle"}, +{ 0x15005b, "HandToHand"}, +{ 0x15005c, "PtrToXHand"}, +{ 0x15005d, "PtrToHand"}, +{ 0x15005e, "HandAndHand"}, +{ 0x15005f, "PtrAndHand"}, +{ 0x2a0002, "NewWindow"}, +{ 0x2a0003, "GetNewWindow"}, +{ 0x2a0004, "NewCWindow"}, +{ 0x2a0005, "DisposeWindow"}, +{ 0x2a0006, "MacCloseWindow"}, +{ 0x2a0007, "InvalRect"}, +{ 0x2a0008, "InvalRgn"}, +{ 0x2a0009, "ValidRect"}, +{ 0x2a000a, "ValidRgn"}, +{ 0x2a0015, "GetNewCWindow"}, +{ 0x2a0016, "SetWTitle"}, +{ 0x2a0017, "GetWTitle"}, +{ 0x2a0018, "GetWMgrPort"}, +{ 0x2a0019, "GetCWMgrPort"}, +{ 0x2a001a, "SetWRefCon"}, +{ 0x2a001b, "GetWRefCon"}, +{ 0x2a001c, "SelectWindow"}, +{ 0x2a001d, "HideWindow"}, +{ 0x2a001e, "MacShowWindow"}, +{ 0x2a001f, "ShowHide"}, +{ 0x2a0021, "BringToFront"}, +{ 0x2a0022, "SendBehind"}, +{ 0x2a0023, "FrontWindow"}, +{ 0x2a0025, "MacMoveWindow"}, +{ 0x2a0026, "SizeWindow"}, +{ 0x2a0027, "ZoomWindow"}, +{ 0x2a0028, "BeginUpdate"}, +{ 0x2a0029, "EndUpdate"}, +{ 0x2a002d, "MacFindWindow"}, +{ 0x2a002e, "PinRect"}, +{ 0x2a0034, "GetWVariant"}, +{ 0x2a0036, "GetGrayRgn"}, +{ 0x290001, "BitTst"}, +{ 0x290002, "BitSet"}, +{ 0x290003, "BitClr"}, +{ 0x290004, "BitAnd"}, +{ 0x290005, "BitOr"}, +{ 0x290006, "BitXor"}, +{ 0x290007, "BitNot"}, +{ 0x290008, "BitShift"}, +{ 0x29000a, "HiWord"}, +{ 0x29000b, "LoWord"}, +{ 0x0e0001, "GetMouse"}, +{ 0x0e0002, "Button"}, +{ 0x0e0003, "StillDown"}, +{ 0x0e0005, "TickCount"}, +{ 0x0e0007, "GetCaretTime"}, +{ 0x0e0008, "GetEvQHdr"}, +{ 0x0e0009, "GetDblTime"}, +{ 0x0e000a, "SetEventMask"}, +{ 0x0e000b, "PPostEvent"}, +{ 0x0e000c, "GetNextEvent"}, +{ 0x0e000d, "WaitNextEvent"}, +{ 0x0e000e, "EventAvail"}, +{ 0x0e000f, "PostEvent"}, +{ 0x0e0010, "OSEventAvail"}, +{ 0x0e0011, "GetOSEvent"}, +{ 0x0e0012, "FlushEvents"}, +{ 0x0e0014, "SystemTask"}, +{ 0x0e0016, "GetKeys"}, +{ 0x0e0017, "MacGetDoubleClickTime"}, +{ 0x10000, "CallComponent"}, +{ 0x10001, "RegisterComponent"}, +{ 0x10002, "UnregisterComponent"}, +{ 0x10003, "CountComponents"}, +{ 0x10004, "FindNextComponent"}, +{ 0x10005, "GetComponentInfo"}, +{ 0x10006, "GetComponentListModSeed"}, +{ 0x10007, "OpenComponent"}, +{ 0x10008, "CloseComponent"}, +{ 0x10009, "DestroyComponent"}, +{ 0x1000a, "GetComponentInstanceError"}, +{ 0x1000b, "SetComponentInstanceError"}, +{ 0x1000c, "GetComponentInstanceStorage"}, +{ 0x1000d, "SetComponentInstanceStorage"}, +{ 0x1000e, "GetComponentInstanceA5"}, +{ 0x1000f, "SetComponentInstanceA5"}, +{ 0x10010, "GetComponentRefcon"}, +{ 0x10011, "SetComponentRefcon"}, +{ 0x10012, "RegisterComponentResource"}, +{ 0x10013, "CountComponentInstances"}, +{ 0x10014, "RegisterComponentResourceFile"}, +{ 0x10015, "OpenComponentResFile"}, +{ 0x10018, "CloseComponentResFile"}, +{ 0x1001c, "CaptureComponent"}, +{ 0x1001d, "UncaptureComponent"}, +{ 0x1001e, "SetDefaultComponent"}, +{ 0x10020, "ResolveComponentAlias"}, +{ 0x10021, "OpenDefaultComponent"}, +{ 0x10024, "DelegateComponentCall"}, +{ 0x10029, "GetComponentIconSuite"}, +{ 0x1002c, "GetComponentTypeModSeed"}, +{ 0x1002d, "OpenAComponent"}, +{ 0x1002e, "OpenADefaultComponent"}, +{ 0x1002f, "OpenAComponentResFile"}, +{ 0x10035, "GetComponentResource"}, +{ 0x10036, "GetComponentIndString"}, +{ 0x10038, "GetComponentPublicResource"}, +{ 0x10039, "GetComponentPublicResourceList"}, +{ 0x1003a, "GetComponentPublicIndString"}, +{ 0x220003, "FontScript"}, +{ 0x220004, "IntlScript"}, +{ 0x220006, "IsCmdChar"}, +{ 0x220007, "FontToScript"}, +{ 0x220008, "GetScriptManagerVariable"}, +{ 0x22000a, "GetScriptVariable"}, +{ 0x22000c, "CharacterByteType"}, +{ 0x22000d, "CharacterType"}, +{ 0x220018, "CharByte"}, +{ 0x220019, "CharType"}, +{ 0x1f0001, "TextFont"}, +{ 0x1f0002, "TextFace"}, +{ 0x1f0003, "TextMode"}, +{ 0x1f0004, "TextSize"}, +{ 0x1f0005, "SpaceExtra"}, +{ 0x1f0006, "DrawChar"}, +{ 0x1f0007, "DrawString"}, +{ 0x1f0008, "MacDrawText"}, +{ 0x1f0009, "CharWidth"}, +{ 0x1f000a, "StringWidth"}, +{ 0x1f000b, "TextWidth"}, +{ 0x1f000c, "MeasureText"}, +{ 0x1f000d, "GetFontInfo"}, +{ 0x1f000f, "StdText"}, +{ 0x1f0010, "StdTxMeas"}, +{ 0x250003, "SysBeep"}, +{ 0x250004, "SndDoCommand"}, +{ 0x250005, "SndDoImmediate"}, +{ 0x250006, "SndNewChannel"}, +{ 0x250007, "SndDisposeChannel"}, +{ 0x250008, "SndPlay"}, +{ 0x250009, "SndAddModifier"}, +{ 0x25000a, "SndControl"}, +{ 0x25000b, "SndSoundManagerVersion"}, +{ 0x25000f, "SndChannelStatus"}, +{ 0x250010, "SndManagerStatus"}, +{ 0x250015, "Comp3to1"}, +{ 0x250016, "Exp1to3"}, +{ 0x250017, "Comp6to1"}, +{ 0x250018, "Exp1to6"}, +{ 0x25001b, "GetDefaultOutputVolume"}, +{ 0x25001c, "SetDefaultOutputVolume"}, +{ 0x25001d, "GetSoundHeaderOffset"}, +{ 0x25001e, "UnsignedFixedMulDiv"}, +{ 0x25001f, "GetCompressionInfo"}, +{ 0x250020, "SetSoundPreference"}, +{ 0x250021, "GetSoundPreference"}, +{ 0x250022, "SndGetInfo"}, +{ 0x250023, "SndSetInfo"}, +{ 0x250024, "GetSoundOutputInfo"}, +{ 0x250025, "SetSoundOutputInfo"}, +{ 0x250026, "GetCompressionName"}, +{ 0x250027, "SoundConverterOpen"}, +{ 0x250028, "SoundConverterClose"}, +{ 0x250029, "SoundConverterGetBufferSizes"}, +{ 0x25002a, "SoundConverterBeginConversion"}, +{ 0x25002b, "SoundConverterConvertBuffer"}, +{ 0x25002c, "SoundConverterEndConversion"}, +{ 0x25002d, "SoundConverterGetInfo"}, +{ 0x25002e, "SoundConverterSetInfo"}, +{ 0x25002f, "OpenMixerSoundComponent"}, +{ 0x250030, "CloseMixerSoundComponent"}, +{ 0x25003f, "SoundConverterFillBuffer"}, +{ 0x250040, "SoundManagerGetInfo"}, +{ 0x250041, "SoundManagerSetInfo"}, +{ 0x40001, "CompAdd"}, +{ 0x40002, "CompSub"}, +{ 0x40003, "CompNeg"}, +{ 0x40004, "CompShift"}, +{ 0x40005, "CompMul"}, +{ 0x40006, "CompDiv"}, +{ 0x40007, "CompFixMul"}, +{ 0x40008, "CompMulDiv"}, +{ 0x40009, "CompCompare"}, +{ 0x4000a, "FixMulDiv"}, +{ 0x4000b, "FracSinCos"}, +{ 0x4000c, "CompMulDivTrunc"}, +{ 0x4000d, "UnsignedFixMulDiv"}, +{ 0x4000e, "FixExp2"}, +{ 0x4000f, "FixLog2"}, +{ 0x40010, "FixPow"}, +{ 0x40011, "CompSquareRoot"}, +{ 0x40014, "GetMatrixType"}, +{ 0x40015, "SetIdentityMatrix"}, +{ 0x40016, "RotateMatrix"}, +{ 0x40017, "ScaleMatrix"}, +{ 0x40018, "SkewMatrix"}, +{ 0x40019, "TranslateMatrix"}, +{ 0x4001b, "ConcatMatrix"}, +{ 0x4001c, "InverseMatrix"}, +{ 0x4001d, "MapMatrix"}, +{ 0x4001e, "RectMatrix"}, +{ 0x40020, "CopyMatrix"}, +{ 0x40021, "EqualMatrix"}, +{ 0x40022, "TransformFixedPoints"}, +{ 0x40023, "TransformPoints"}, +{ 0x40024, "TransformFixedRect"}, +{ 0x40025, "TransformRect"}, +{ 0x260001, "SFPutFile"}, +{ 0x260002, "CustomPutFile"}, +{ 0x260003, "SFGetFile"}, +{ 0x260004, "SFPPutFile"}, +{ 0x260005, "SFPGetFile"}, +{ 0x260006, "StandardPutFile"}, +{ 0x260007, "StandardGetFile"}, +{ 0x260008, "CustomGetFile"}, +{ 0x180008, "GetDateTime"}, +{ 0x18000c, "DateToSeconds"}, +{ 0x18000d, "SecondsToDate"}, +{ 0x18000e, "DTInstall"}, +{ 0x180011, "Delay"}, +{ 0x180013, "Enqueue"}, +{ 0x180014, "Dequeue"}, +{ 0x18001f, "ReadLocation"}, +{ 0x180022, "InsTime"}, +{ 0x180023, "InsXTime"}, +{ 0x180024, "Microseconds"}, +{ 0x180025, "PrimeTime"}, +{ 0x180026, "RmvTime"}, +{ 0x180027, "MacGetCurrentProcess"}, +{ 0x110001, "Gestalt"}, +{ 0x110004, "NewGestaltValue"}, +{ 0x110005, "ReplaceGestaltValue"}, +{ 0x110006, "SetGestaltValue"}, +{ 0x110007, "DeleteGestaltValue"}, +{ 0x120001, "GetCIcon"}, +{ 0x120002, "PlotCIcon"}, +{ 0x120003, "DisposeCIcon"}, +{ 0x120004, "GetIcon"}, +{ 0x120005, "PlotIcon"}, +{ 0x120006, "PlotIconID"}, +{ 0x120021, "PlotIconHandle"}, +{ 0x120022, "PlotSICNHandle"}, +{ 0x120023, "PlotCIconHandle"}, +{ 0x0b0001, "NewControl"}, +{ 0x0b0003, "DisposeControl"}, +{ 0x0b0004, "KillControls"}, +{ 0x0b0005, "ShowControl"}, +{ 0x0b0006, "HideControl"}, +{ 0x0b0007, "DrawControls"}, +{ 0x0b0008, "Draw1Control"}, +{ 0x0b0009, "UpdateControls"}, +{ 0x0b000a, "HiliteControl"}, +{ 0x0b000b, "TrackControl"}, +{ 0x0b000e, "FindControl"}, +{ 0x0b000f, "MoveControl"}, +{ 0x0b0010, "SizeControl"}, +{ 0x0b0011, "SetControlTitle"}, +{ 0x0b0012, "GetControlTitle"}, +{ 0x0b0013, "GetControlValue"}, +{ 0x0b0014, "SetControlValue"}, +{ 0x0b0015, "GetControlMinimum"}, +{ 0x0b0016, "SetControlMinimum"}, +{ 0x0b0017, "GetControlMaximum"}, +{ 0x0b0018, "SetControlMaximum"}, +{ 0x0b001a, "SetControlAction"}, +{ 0x0b001b, "GetControlAction"}, +{ 0x0b0020, "GetControlComponentInstance"}, +{ 0x0b0021, "GetDialogControlNotificationProc"}, +{ 0x0b0022, "GetControlHandleFromCookie"}, +{ 0x0b0023, "SetControlDefProc"}, +{ 0x0b0024, "SetControlReference"}, +{ 0x0b0025, "GetControlReference"}, +{ 0x280001, "Munger"}, +{ 0x280002, "NewString"}, +{ 0x280004, "GetString"}, +{ 0x280005, "StyledLineBreak"}, +{ 0x280006, "TruncString"}, +{ 0x280007, "TruncText"}, +{ 0x280008, "FindWordBreaks"}, +{ 0x280017, "c2pstr"}, +{ 0x280018, "p2cstr"}, +{ 0x280019, "c2pstrcpy"}, +{ 0x28001a, "p2cstrcpy"}, +{ 0x28001c, "IUCompPString"}, +{ 0x28001d, "IUDateString"}, +{ 0x28001e, "IUTimeString"}, +{ 0x28001f, "IUEqualString"}, +{ 0x280020, "IUMagIDString"}, +{ 0x280021, "IUMagString"}, +{ 0x280022, "EqualString"}, +{ 0x280023, "RelString"}, +{ 0x280024, "NumToString"}, +{ 0x280025, "StringToNum"}, +{ 0x280028, "ExtendedToString"}, +{ 0x28002a, "IUMagIDPString"}, +{ 0x230006, "ExitToShell"}, +{ 0x0f0007, "PBReadSync"}, +{ 0x0f0008, "PBReadAsync"}, +{ 0x0f000a, "PBWriteSync"}, +{ 0x0f000b, "PBWriteAsync"}, +{ 0x0f000d, "PBGetVInfoSync"}, +{ 0x0f0021, "PBGetFInfoSync"}, +{ 0x0f0023, "PBSetFInfoSync"}, +{ 0x0f002d, "PBGetEOFSync"}, +{ 0x0f002f, "PBSetEOFSync"}, +{ 0x0f0035, "PBFlushFileSync"}, +{ 0x0f003e, "SetVol"}, +{ 0x0f0041, "FlushVol"}, +{ 0x0f0046, "FSClose"}, +{ 0x0f0047, "FSRead"}, +{ 0x0f0048, "FSWrite"}, +{ 0x0f004a, "GetFInfo"}, +{ 0x0f004b, "GetVol"}, +{ 0x0f004d, "FSDelete"}, +{ 0x0f004f, "Rename"}, +{ 0x0f0054, "GetEOF"}, +{ 0x0f0055, "SetEOF"}, +{ 0x0f0056, "GetFPos"}, +{ 0x0f0057, "SetFPos"}, +{ 0x0f0067, "PBGetFCBInfoSync"}, +{ 0x0f0069, "PBGetCatInfoSync"}, +{ 0x0f006d, "PBAllocContigSync"}, +{ 0x0f0075, "PBHGetVInfoSync"}, +{ 0x0f0077, "PBHOpenSync"}, +{ 0x0f0079, "PBHOpenRFSync"}, +{ 0x0f007b, "PBHOpenDFSync"}, +{ 0x0f007d, "PBHCreateSync"}, +{ 0x0f00a2, "PBHGetVolParmsSync"}, +{ 0x0f00e2, "FSMakeFSSpec"}, +{ 0x0f00e3, "FSpOpenDF"}, +{ 0x0f00e4, "FSpOpenRF"}, +{ 0x0f00e5, "FSpCreate"}, +{ 0x0f00e7, "FSpDelete"}, +{ 0x0f00e8, "FSpGetFInfo"}, +{ 0x0f00ec, "FSpRename"}, +{ 0x100001, "FixRatio"}, +{ 0x100002, "FixMul"}, +{ 0x100003, "FixRound"}, +{ 0x100004, "Fix2Frac"}, +{ 0x100005, "Fix2Long"}, +{ 0x100006, "Long2Fix"}, +{ 0x100007, "Frac2Fix"}, +{ 0x100008, "FracMul"}, +{ 0x100009, "FixDiv"}, +{ 0x10000a, "FracDiv"}, +{ 0x10000b, "FracSqrt"}, +{ 0x10000c, "FracSin"}, +{ 0x10000d, "FracCos"}, +{ 0x10000e, "FixATan2"}, +{ 0x10000f, "RefFrac2X"}, +{ 0x100010, "RefFix2X"}, +{ 0x100011, "RefX2Fix"}, +{ 0x100012, "RefX2Frac"}, +{ 0x80001, "NewAlias"}, +{ 0x80002, "NewAliasMinimal"}, +{ 0x80003, "NewAliasMinimalFromFullPath"}, +{ 0x80004, "ResolveAlias"}, +{ 0x80005, "GetAliasInfo"}, +{ 0x80006, "ResolveAliasFile"}, +{ 0x80008, "UpdateAlias"}, +{ 0x80009, "MatchAlias"}, +{ 0x2b0002, "GetFontName"}, +{ 0x2b0003, "RealFont"}, +{ 0x2b0004, "GetFNum"}, +{ 0x130001, "LNew"}, +{ 0x130002, "LDispose"}, +{ 0x130004, "LAddRow"}, +{ 0x130006, "LDelRow"}, +{ 0x130007, "LGetSelect"}, +{ 0x130008, "LLastClick"}, +{ 0x130009, "LNextCell"}, +{ 0x13000a, "LSearch"}, +{ 0x13000c, "LSetDrawingMode"}, +{ 0x13000d, "LScroll"}, +{ 0x13000e, "LAutoScroll"}, +{ 0x13000f, "LUpdate"}, +{ 0x130010, "LActivate"}, +{ 0x130012, "LClick"}, +{ 0x130013, "LAddToCell"}, +{ 0x130014, "LClrCell"}, +{ 0x130015, "LGetCell"}, +{ 0x130016, "LRect"}, +{ 0x130017, "LSetCell"}, +{ 0x130018, "LSetSelect"}, +{ 0x130019, "LDraw"}, +{ 0x13001a, "LGetCellDataLocation"}, +{ 0x13001c, "LSetNotificationCallback"}, +{ 0x13001d, "LSetLDEF"}, +{ 0x13001e, "GetListVisibleBounds"}, +{ 0x210001, "InfoScrap"}, +{ 0x210002, "UnloadScrap"}, +{ 0x210003, "LoadScrap"}, +{ 0x210004, "GetScrap"}, +{ 0x210005, "ZeroScrap"}, +{ 0x210006, "PutScrap"}, +{ 0x14000b, "LMGetTheZone"}, +{ 0x140019, "LMGetTicks"}, +{ 0x14004b, "LMGetMemErr"}, +{ 0x14005d, "LMGetSysZone"}, +{ 0x14006b, "LMGetDoubleTime"}, +{ 0x14008d, "LMGetScrnBase"}, +{ 0x14008f, "LMGetMainDevice"}, +{ 0x140091, "LMGetDeviceList"}, +{ 0x1400bf, "LMGetWindowList"}, +{ 0x1400c2, "LMGetPaintWhite"}, +{ 0x1400c3, "LMSetPaintWhite"}, +{ 0x1400c6, "LMGetGrayRgn"}, +{ 0x1400f5, "LMGetResLoad"}, +{ 0x1400f7, "LMGetResErr"}, +{ 0x140137, "LMGetTheGDevice"}, +{ 0x240001, "SPBVersion"}, +{ 0x240006, "SPBGetIndexedDevice"}, +{ 0x240007, "SPBOpenDevice"}, +{ 0x240008, "SPBCloseDevice"}, +{ 0x240009, "SPBRecord"}, +{ 0x24000b, "SPBMillisecondsToBytes"}, +{ 0x24000c, "SPBBytesToMilliseconds"}, +{ 0x24000d, "SetupSndHeader"}, +{ 0x24000e, "SetupAIFFHeader"}, +{ 0x24000f, "ParseAIFFHeader"}, +{ 0x240010, "ParseSndHeader"}, +{ 0x240011, "SPBPauseRecording"}, +{ 0x240012, "SPBStopRecording"}, +{ 0x240013, "SPBGetDeviceInfo"}, +{ 0x240014, "SPBSetDeviceInfo"}, +{ 0x240015, "SPBResumeRecording"}, +{ 0x240016, "SPBGetRecordingStatus"}, +{ 0x1b0003, "PrOpen"}, +{ 0x1b0004, "PrClose"}, +{ 0x1b0005, "PrintDefault"}, +{ 0x1b0006, "PrValidate"}, +{ 0x1b0007, "PrStlDialog"}, +{ 0x1b0008, "PrJobDialog"}, +{ 0x1b0009, "PrStlInit"}, +{ 0x1b000a, "PrJobInit"}, +{ 0x1b000b, "PrJobMerge"}, +{ 0x1b000c, "PrDlgMain"}, +{ 0x1b000d, "PrOpenDoc"}, +{ 0x1b000e, "PrCloseDoc"}, +{ 0x1b000f, "PrOpenPage"}, +{ 0x1b0010, "PrClosePage"}, +{ 0x1b0011, "PrPicFile"}, +{ 0x1b0012, "PrError"}, +{ 0x1b0013, "PrSetError"}, +{ 0x1b0014, "PrGeneral"}, +{ 0x270002, "TENew"}, +{ 0x270003, "TEDispose"}, +{ 0x270004, "TESetText"}, +{ 0x270005, "TEGetText"}, +{ 0x270006, "TEIdle"}, +{ 0x270007, "TESetSelect"}, +{ 0x270008, "TEActivate"}, +{ 0x270009, "TEDeactivate"}, +{ 0x27000e, "TEDelete"}, +{ 0x27000f, "TEInsert"}, +{ 0x270010, "TESetAlignment"}, +{ 0x270011, "TEUpdate"}, +{ 0x270012, "TETextBox"}, +{ 0x270013, "TEScroll"}, +{ 0x270014, "TESelView"}, +{ 0x270015, "TEPinScroll"}, +{ 0x270016, "TEAutoView"}, +{ 0x270017, "TECalText"}, +{ 0x270018, "TEGetOffset"}, +{ 0x270019, "TEGetPoint"}, +{ 0x27001b, "TEStyleNew"}, +{ 0x27001c, "TESetStyleHandle"}, +{ 0x27001d, "TEGetStyleHandle"}, +{ 0x27001e, "TEGetStyle"}, +{ 0x27001f, "TEStylePaste"}, +{ 0x270020, "TESetStyle"}, +{ 0x270021, "TEReplaceStyle"}, +{ 0x270022, "TEGetStyleScrapHandle"}, +{ 0x270023, "TEStyleInsert"}, +{ 0x270024, "TEGetHeight"}, +{ 0x270025, "TEContinuousStyle"}, +{ 0x270026, "TEUseStyleScrap"}, +{ 0x270028, "TENumStyles"}, +{ 0x270029, "TEFeatureFlag"}, +{ 0,NULL } }; diff --git a/loader/wrapper.S b/loader/wrapper.S new file mode 100644 index 0000000000..60028e670d --- /dev/null +++ b/loader/wrapper.S @@ -0,0 +1,83 @@ +.section .data +.globl caller_return +caller_return: + .long 0 +.globl report_entry +report_entry: + .long null_call +.globl report_ret +report_ret: + .long null_call +.global wrapper_target +wrapper_target: + .long null_call + +.section .text +.globl null_call + .type null_call, @function + .align 16,0x90 +null_call: + ret +.globl wrapper + .type wrapper, @function + .align 16,0x90 +wrapper: + pusha # store registers (EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI) + pushf # store flags + + push %ebp # set up a stack frame + movl %esp, %ebp + + leal 4(%ebp), %eax # push flags addr + push %eax + leal 8(%ebp), %eax # push registers addr + push %eax + + leal 40(%ebp), %edx + movl (%ebp), %eax + subl %edx, %eax + push %eax + push %edx + + call *report_entry # report entry + + test %eax, %eax + jnz .Ldone + + leave # restore %esp, %ebp + popf # restore flags + popa # restore registers + + popl caller_return # switch return addresses + pushl $.Lwrapper_return + + jmp *wrapper_target # wrapper_target should return at .Lwrapper_return + + .align 16, 0x90 +.Lwrapper_return: + pushl caller_return # restore the original return address + pusha # more for reference sake here + pushf + + push %ebp # set up a stack frame + movl %esp, %ebp + + leal 4(%ebp), %eax # push flags addr + push %eax + leal 8(%ebp), %eax # push registers addr + push %eax + + leal 40(%ebp), %edx # push stack top address (relative to our entry) + movl (%ebp), %eax + subl %edx, %eax # calculate difference between entry and previous frame + push %eax + push %edx + + call *report_ret # report the return information (same args) +.Ldone: + + leave + popf + popa + ret + \ No newline at end of file diff --git a/loader/wrapper.h b/loader/wrapper.h new file mode 100644 index 0000000000..e307c0e654 --- /dev/null +++ b/loader/wrapper.h @@ -0,0 +1,20 @@ +#ifndef _WRAPPER_H +#define _WRAPPER_H + +#include + +typedef struct { + u_int32_t edi, esi, ebp, esp, ebx, edx, ecx, eax; +} reg386_t; + +typedef int (*wrapper_func_t)(void *stack_base, int stack_size, reg386_t *reg, u_int32_t *flags); + +extern wrapper_func_t report_entry, report_ret; + +extern void (*wrapper_target)(void); + +extern int wrapper(void); +extern int null_call(void); + +#endif /* _WRAPPER_H */ +