From 8d6f6463d21fbfc8b992df1a03c37313b67bbbbe Mon Sep 17 00:00:00 2001 From: George Rhoten Date: Fri, 15 Jun 2001 19:31:08 +0000 Subject: [PATCH] ICU-961 Useful stuff for the Mac X-SVN-Rev: 5009 --- icu4c/as_is/codewarrior/mac/Carbon.r | 18 ++ icu4c/as_is/codewarrior/mac/mac_gencnval.cpp | 265 ++++++++++++++++++ icu4c/as_is/codewarrior/mac/mac_gennames.cpp | 258 +++++++++++++++++ icu4c/as_is/codewarrior/mac/mac_genprops.cpp | 275 +++++++++++++++++++ icu4c/as_is/codewarrior/mac/mac_genrb.cpp | 226 +++++++++++++++ icu4c/as_is/codewarrior/mac/mac_gentz.cpp | 256 +++++++++++++++++ icu4c/as_is/codewarrior/mac/mac_genuca.cpp | 206 ++++++++++++++ icu4c/as_is/codewarrior/mac/mac_makeconv.cpp | 263 ++++++++++++++++++ icu4c/as_is/codewarrior/mac/mac_utils.cpp | 221 +++++++++++++++ icu4c/as_is/codewarrior/mac/mac_utils.h | 48 ++++ 10 files changed, 2036 insertions(+) create mode 100644 icu4c/as_is/codewarrior/mac/Carbon.r create mode 100644 icu4c/as_is/codewarrior/mac/mac_gencnval.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_gennames.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_genprops.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_genrb.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_gentz.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_genuca.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_makeconv.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_utils.cpp create mode 100644 icu4c/as_is/codewarrior/mac/mac_utils.h diff --git a/icu4c/as_is/codewarrior/mac/Carbon.r b/icu4c/as_is/codewarrior/mac/Carbon.r new file mode 100644 index 00000000000..c96ee4e24c0 --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/Carbon.r @@ -0,0 +1,18 @@ +/* + * Permit this Carbon application to launch on OS X + * + * (c) 1997-2000 Metrowerks Corp. + * + * Questions and comments to: + * + * + */ + + +/*----------------------------carb Carbon on OS X launch information --------------------------*/ +type 'carb' { +}; + + +resource 'carb'(0) { +}; \ No newline at end of file diff --git a/icu4c/as_is/codewarrior/mac/mac_gencnval.cpp b/icu4c/as_is/codewarrior/mac/mac_gencnval.cpp new file mode 100644 index 00000000000..42bdba9196c --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_gencnval.cpp @@ -0,0 +1,265 @@ +/** + * File: mac_gencnval.cpp + * + * Mac Codewarrior plugin version of gencnval. + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" +//#include "cmemory.h" +//#include "utypes.h" + +// Toolbox headers +#include "TextUtils.h" + +//#include + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main( int argc, char* argv[]); +//pascal OSErr FSpGetFullPath(const FSSpec *spec, short *fullPathLength, Handle *fullPath); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +// hmm don't want to associate any file extensions with this compiler +// it only works on convrtrs.txt + +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".txt", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + + *defaultMappingList = &sExtensionMapList; + return cwNoErr; +} + + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + ( kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + *targetList = &sTargetList; + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "gencnval"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if (!CWSUCCESS(err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if (!CWSUCCESS(err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if (gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory( gPluginContext, &gOutputFile); + + if (!CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if (!CWSUCCESS(err)) + return (err); + } + +/* // set the destination directory + Handle destH = 0; + short len = 0; + + OSErr theErr = FSpGetFullPath( &gOutputFile, &len, &destH ); + + char* theDestPath; + char pathBuffer[1024]; + + if( destH ) { + + ::HLock(destH); + + uprv_memcpy(pathBuffer, ((char*)(*destH)), len); + pathBuffer[len] = 0; + theDestPath = pathBuffer; + + ::DisposeHandle(destH); + destH = 0; + } + + + // get the source directory + Handle srcH = 0; + len = 0; + + theErr = FSpGetFullPath( &gSourceFile, &len, &srcH ); + + char* theSrcPath; + char srcBuffer[1024]; + + if( srcH ) { + + ::HLock(srcH); + + uprv_memcpy(srcBuffer, ((char*)(*srcH)), len); + srcBuffer[len] = 0; + theSrcPath = srcBuffer; + + ::DisposeHandle(srcH); + srcH = 0; + + // truncate file name from full path string + std::string str = theSrcPath; + str = str.substr( 0, str.find_last_of( ":" ) + 1); + std::strcpy(theSrcPath, str.c_str()); + } +*/ + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, true); + + int argc = 5; + char* argv[] = { "gencnval", "-d", theDestPath, "-s", theSrcPath }; + + if ( setjmp( exit_jump) == 0) { + + // Need to test that we can locate our file here so we don't + // have to in fopen(). That way, we won't get error messages + // from makeconv.c when .dat files (that we don't care about) + // aren't found. +// err = LocateFile(gPluginContext, gSourceFileName, gSourceFile); + + if ( main( argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if ( err == cwNoErr) { + CWObjectData objectData; + ::BlockZero( &objectData, sizeof( objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if (FSpGetFileSize( &gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } + else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete(&gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + return (err); +} + + +// main entry-point for makeconv compiler plugin +pascal short gencnval_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + // dispatch on compiler request + switch (request) + { + case reqInitCompiler: break; // compiler has just been loaded into memory + + case reqTermCompiler: break; // compiler is about to be unloaded from memory + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_gennames.cpp b/icu4c/as_is/codewarrior/mac/mac_gennames.cpp new file mode 100644 index 00000000000..3d873fa33ce --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_gennames.cpp @@ -0,0 +1,258 @@ +/** + * File: mac_gennames.cpp + * + * Mac Codewarrior plugin version of gennames. + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" +//#include "cmemory.h" +//#include "utypes.h" + +// Toolbox headers +#include "TextUtils.h" + +//#include + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main( int argc, char* argv[]); +//pascal OSErr FSpGetFullPath(const FSSpec *spec, short *fullPathLength, Handle *fullPath); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".txt", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + *defaultMappingList = &sExtensionMapList; + return cwNoErr; +} + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + (kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + + *targetList = &sTargetList; + + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "gennames"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if (!CWSUCCESS(err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if (!CWSUCCESS(err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if (gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory( gPluginContext, &gOutputFile); + + if (!CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if (!CWSUCCESS(err)) + return (err); + } + +/* // set the destination directory + Handle destH = 0; + short len = 0; + + OSErr theErr = FSpGetFullPath( &gOutputFile, &len, &destH ); + + char* theDestPath; + char pathBuffer[1024]; + + if( destH ) { + + ::HLock(destH); + + uprv_memcpy(pathBuffer, ((char*)(*destH)), len); + pathBuffer[len] = 0; + theDestPath = pathBuffer; + + ::DisposeHandle(destH); + destH = 0; + } + + // get the source directory + Handle srcH = 0; + len = 0; + + theErr = FSpGetFullPath( &gSourceFile, &len, &srcH ); + + char* theSrcPath; + char srcBuffer[1024]; + + if( srcH ) { + + ::HLock(srcH); + + uprv_memcpy(srcBuffer, ((char*)(*srcH)), len); + srcBuffer[len] = 0; + theSrcPath = srcBuffer; + + ::DisposeHandle(srcH); + srcH = 0; + } +*/ + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, false); + + int argc = 4; + char* argv[] = { "gennames", "-d", theDestPath, theSrcPath }; + + if ( setjmp(exit_jump) == 0) { + + // Need to test that we can locate our file here so we don't + // have to in fopen(). That way, we won't get error messages + // from gennames.c when .dat files (that we don't care about) + // aren't found. +// err = LocateFile(gPluginContext, gSourceFileName, gSourceFile); + + if ( main(argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if ( err == cwNoErr) { + CWObjectData objectData; + ::BlockZero( &objectData, sizeof(objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if ( FSpGetFileSize( &gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } + else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete( &gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + return (err); +} + + +// main entry-point for gennames compiler plugin +pascal short gennames_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + // dispatch on compiler request + switch (request) + { + case reqInitCompiler: break; // compiler has just been loaded into memory + + case reqTermCompiler: break; // compiler is about to be unloaded from memory + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_genprops.cpp b/icu4c/as_is/codewarrior/mac/mac_genprops.cpp new file mode 100644 index 00000000000..6bd609b9d01 --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_genprops.cpp @@ -0,0 +1,275 @@ +/** + * File: mac_genprops.cpp + * + * Mac Codewarrior plugin version of genprops. + * + * Because of the different natures of the commandline genprops and a CodeWarrior plugin compiler, + * uprops.dat will be generated multiple times (how many times depends on the number of files + * being processed by the compiler). This is because genprops has hardcoded the processing of each + * file when it is run but the compiler wrapper of genprops calls genprops for each individual + * file. Therefore, as each file is 'compiled', all of the files are processed by genprops. The + * final output isn't affected (since a new file will replace the old one), only the efficiency + * by which the files are processed. This extra time isn't noticable with only a few files. One + * workaround to this problem would be to only include one of the files in the project target. + * The downside of this approach is that the other files being processed wouldn't be directly + * accessable from the project window and it would appear to the user that only one file was + * being processed when in fact multiple files were used to produce uprops.dat. + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" +//#include "cmemory.h" +//#include "utypes.h" + +// Toolbox headers +#include "TextUtils.h" + +//#include + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main(int argc, char* argv[]); +//pascal OSErr FSpGetFullPath(const FSSpec *spec, short *fullPathLength, Handle *fullPath); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".txt", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + *defaultMappingList = &sExtensionMapList; + return cwNoErr; +} + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + (kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + + *targetList = &sTargetList; + + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "genprops"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if (!CWSUCCESS(err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if (!CWSUCCESS(err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if ( gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory( gPluginContext, &gOutputFile); + + if (!CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if (!CWSUCCESS(err)) + return (err); + } + +/* // set the destination directory + Handle destH = 0; + short len = 0; + + OSErr theErr = FSpGetFullPath( &gOutputFile, &len, &destH ); + + char* theDestPath; + char pathBuffer[1024]; + + if( destH ) { + + ::HLock(destH); + + uprv_memcpy(pathBuffer, ((char*)(*destH)), len); + pathBuffer[len] = 0; + theDestPath = pathBuffer; + + ::DisposeHandle(destH); + destH = 0; + } + + // get the source directory + Handle srcH = 0; + len = 0; + + theErr = FSpGetFullPath( &gSourceFile, &len, &srcH ); + + char* theSrcPath; + char srcBuffer[1024]; + + if( srcH ) { + + ::HLock(srcH); + + uprv_memcpy(srcBuffer, ((char*)(*srcH)), len); + srcBuffer[len] = 0; + theSrcPath = srcBuffer; + + ::DisposeHandle(srcH); + srcH = 0; + + // truncate file name from full path string + std::string str = theSrcPath; + str = str.substr( 0, str.find_last_of( ":" ) + 1); + std::strcpy(theSrcPath, str.c_str()); + } +*/ + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, true); + + int argc = 5; + char* argv[] = { "genprops", "-d", theDestPath, "-s", theSrcPath, }; + + if ( setjmp( exit_jump) == 0) { + + // Need to test that we can locate our file here so we don't + // have to in fopen(). That way, we won't get error messages + // from genprops.c when .dat files (that we don't care about) + // aren't found. +// err = LocateFile( gPluginContext, gSourceFileName, gSourceFile); + + if ( main( argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if ( err == cwNoErr) { + CWObjectData objectData; + ::BlockZero( &objectData, sizeof( objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if ( FSpGetFileSize( &gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } + else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete( &gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + return (err); +} + + +// main entry-point for genprops compiler plugin +pascal short genprops_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + // dispatch on compiler request + switch (request) + { + case reqInitCompiler: break; // compiler has just been loaded into memory + + case reqTermCompiler: break; // compiler is about to be unloaded from memory + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_genrb.cpp b/icu4c/as_is/codewarrior/mac/mac_genrb.cpp new file mode 100644 index 00000000000..21ae3cee556 --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_genrb.cpp @@ -0,0 +1,226 @@ +/** + * File: mac_genrb.cpp + * + * Mac Codewarrior plugin version of genrb. + * + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" +//#include "cmemory.h" +//#include "utypes.h" + +// Toolbox headers +#include "TextUtils.h" +#include +//#include + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main(int argc, char* argv[]); +//pascal OSErr FSpGetFullPath(const FSSpec *spec, short *fullPathLength, Handle *fullPath); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".txt", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + + *defaultMappingList = &sExtensionMapList; + + return cwNoErr; +} + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + ( kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + *targetList = &sTargetList; + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "genrb"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if ( !CWSUCCESS( err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if ( !CWSUCCESS( err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if ( gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory(gPluginContext, &gOutputFile); + + if ( !CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if ( !CWSUCCESS(err)) + return (err); + } + + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, true); + + // chop off the trailing colon + if ( theSrcPath && *theSrcPath && theSrcPath[ std::strlen( theSrcPath )-1 ] == ':' ) + theSrcPath[ strlen( theSrcPath )-1 ] = 0; + + int argc = 6; + char* argv[] = { "genrb", "-d", theDestPath, "-s", theSrcPath, gSourceFileName }; + + if ( setjmp( exit_jump) == 0) { + + // Need to test that we can locate our file here so we don't + // have to in fopen(). That way, we won't get error messages + // from genrb.c when .dat files (that we don't care about) + // aren't found. +// err = LocateFile(gPluginContext, gSourceFileName, gSourceFile); + + if ( main( argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if ( err == cwNoErr) { + CWObjectData objectData; + ::BlockZero(&objectData, sizeof(objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if ( FSpGetFileSize( &gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete(&gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + + return (err); +} + + +// main entry-point for genrb compiler plugin +pascal short genrb_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + /* dispatch on compiler request */ + switch (request) + { + case reqInitCompiler: + /* compiler has just been loaded into memory */ + break; + + case reqTermCompiler: + /* compiler is about to be unloaded from memory */ + break; + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + /* return result code */ + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_gentz.cpp b/icu4c/as_is/codewarrior/mac/mac_gentz.cpp new file mode 100644 index 00000000000..2d7e990892b --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_gentz.cpp @@ -0,0 +1,256 @@ +/** + * File: mac_gentz.cpp + * + * Mac Codewarrior plugin version of gentz. + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" +//#include "cmemory.h" +//#include "utypes.h" + +// Toolbox headers +#include "TextUtils.h" + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main( int argc, char* argv[]); +//pascal OSErr FSpGetFullPath(const FSSpec *spec, short *fullPathLength, Handle *fullPath); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".txt", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + *defaultMappingList = &sExtensionMapList; + return cwNoErr; +} + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + ( kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + + *targetList = &sTargetList; + + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "gentz"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if (!CWSUCCESS(err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if (!CWSUCCESS(err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if ( gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory( gPluginContext, &gOutputFile); + + if (!CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if (!CWSUCCESS(err)) + return (err); + } + +/* // set the destination directory + Handle destH = 0; + short len = 0; + + OSErr theErr = FSpGetFullPath( &gOutputFile, &len, &destH ); + + char* theDestPath; + char pathBuffer[1024]; + + if( destH ) { + + ::HLock(destH); + + uprv_memcpy(pathBuffer, ((char*)(*destH)), len); + pathBuffer[len] = 0; + theDestPath = pathBuffer; + + ::DisposeHandle(destH); + destH = 0; + } + + // get the source directory + Handle srcH = 0; + len = 0; + + theErr = FSpGetFullPath( &gSourceFile, &len, &srcH ); + + char* theSrcPath; + char srcBuffer[1024]; + + if( srcH ) { + + ::HLock(srcH); + + uprv_memcpy( srcBuffer, ((char*)(*srcH)), len); + srcBuffer[len] = 0; + theSrcPath = srcBuffer; + + ::DisposeHandle(srcH); + srcH = 0; + } +*/ + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, false); + + int argc = 4; + char* argv[] = { "gentz", "-d", theDestPath, theSrcPath }; + + if ( setjmp( exit_jump) == 0) { + + // Need to test that we can locate our file here so we don't + // have to in fopen(). That way, we won't get error messages + // from gentz.c when .dat files (that we don't care about) + // aren't found. +// err = LocateFile(gPluginContext, gSourceFileName, gSourceFile); + + if ( main( argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if ( err == cwNoErr) { + CWObjectData objectData; + ::BlockZero( &objectData, sizeof( objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if ( FSpGetFileSize(&gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } + else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete( &gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + return (err); +} + + +// main entry-point for gentz compiler plugin +pascal short gentz_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + // dispatch on compiler request + switch (request) + { + case reqInitCompiler: break; // compiler has just been loaded into memory + + case reqTermCompiler: break; // compiler is about to be unloaded from memory + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_genuca.cpp b/icu4c/as_is/codewarrior/mac/mac_genuca.cpp new file mode 100644 index 00000000000..ca3ad2d0bb0 --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_genuca.cpp @@ -0,0 +1,206 @@ +/** + * File: mac_genuca.cpp + * + * Mac Codewarrior plugin version of genuca. + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" + +// Toolbox headers +#include "TextUtils.h" + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main( int argc, char* argv[]); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +// hmm don't want to associate any file extensions with this compiler +// it only works on convrtrs.txt + +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".txt", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + + *defaultMappingList = &sExtensionMapList; + return cwNoErr; +} + + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + ( kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + *targetList = &sTargetList; + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "genuca"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if (!CWSUCCESS(err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if (!CWSUCCESS(err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if (gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory( gPluginContext, &gOutputFile); + + if (!CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if (!CWSUCCESS(err)) + return (err); + } + + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, true); + + int argc = 5; + char* argv[] = { "genuca", "-d", theDestPath, "-s", theSrcPath }; + + if ( setjmp( exit_jump) == 0) { + + if ( main( argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if ( err == cwNoErr) { + CWObjectData objectData; + ::BlockZero( &objectData, sizeof( objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if (FSpGetFileSize( &gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } + else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete(&gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + return (err); +} + + +// main entry-point for makeconv compiler plugin +pascal short genuca_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + // dispatch on compiler request + switch (request) + { + case reqInitCompiler: break; // compiler has just been loaded into memory + + case reqTermCompiler: break; // compiler is about to be unloaded from memory + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_makeconv.cpp b/icu4c/as_is/codewarrior/mac/mac_makeconv.cpp new file mode 100644 index 00000000000..8adb1b21aa5 --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_makeconv.cpp @@ -0,0 +1,263 @@ +/** + * File: mac_makeconv.cpp + * + * Mac Codewarrior plugin version of makeconv. + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +// local headers +#include "mac_utils.h" +//#include "cmemory.h" +//#include "utypes.h" + +// Toolbox headers +#include "TextUtils.h" + +//#include + +// global variables +CWPluginContext gPluginContext; + +extern "C" { +int main( int argc, char* argv[]); +//pascal OSErr FSpGetFullPath(const FSSpec *spec, short *fullPathLength, Handle *fullPath); +} + + +// plugin compiler exports. +#if CW_USE_PRAGMA_EXPORT +#pragma export on +#endif + +// define what file types are handled +CWPLUGIN_ENTRY( CWPlugin_GetDefaultMappingList)( const CWExtMapList** defaultMappingList) +{ + static CWExtensionMapping sExtension = { 'TEXT', ".ucm", 0 }; + static CWExtMapList sExtensionMapList = { kCurrentCWExtMapListVersion, 1, &sExtension }; + *defaultMappingList = &sExtensionMapList; + return cwNoErr; +} + +// define what operations this plugin handles +CWPLUGIN_ENTRY( CWPlugin_GetDropInFlags)( const DropInFlags** flags, long* flagsSize) +{ + static const DropInFlags sFlags = { + kCurrentDropInFlagsVersion, + CWDROPINCOMPILERTYPE, + DROPINCOMPILERLINKERAPIVERSION, + ( kGeneratescode | kCompMultiTargAware | kCompAlwaysReload), + Lang_MISC, + DROPINCOMPILERLINKERAPIVERSION + }; + + *flags = &sFlags; + *flagsSize = sizeof(sFlags); + + return cwNoErr; +} + +// define what platforms are supported by this plugin +// +// '****' - specifies any type +CWPLUGIN_ENTRY( CWPlugin_GetTargetList)( const CWTargetList** targetList) +{ + static CWDataType sCPU = '****'; + static CWDataType sOS = '****'; + static CWTargetList sTargetList = { kCurrentCWTargetListVersion, 1, &sCPU, 1, &sOS }; + + *targetList = &sTargetList; + + return cwNoErr; +} + +// define the plugin's onscreen name +CWPLUGIN_ENTRY( CWPlugin_GetDropInName)( const char** dropinName) +{ + static const char* sDropInName = "makeconv"; + *dropinName = sDropInName; + return cwNoErr; +} + +#if CW_USE_PRAGMA_EXPORT +#pragma export off +#endif + +static CWResult Compile( CWPluginContext context) +{ + // get the FileSpec of the file being processed + CWResult err = CWGetMainFileSpec( context, &gSourceFile); + if (!CWSUCCESS(err)) + return (err); + + // get the index of the file to process, from the target link order + long fileNum; + err = CWGetMainFileNumber( context, &fileNum); + if (!CWSUCCESS(err)) + return (err); + + // get the name of the source file to compile + gSourceFileName = p2c_strdup( gSourceFile.name); + + if ( gSourceFileName == NULL) + return cwErrOutOfMemory; + + // get the user specified directory from the Target Settings panel (if one exists) + err = CWGetOutputFileDirectory( gPluginContext, &gOutputFile); + + if (!CWSUCCESS(err)) { + // else generate the output file into the project target's data directory + err = CWGetSuggestedObjectFileSpec( context, fileNum, &gOutputFile); + + if (!CWSUCCESS(err)) + return (err); + } + +/* // set the destination directory + Handle destH = 0; + short len = 0; + + OSErr theErr = FSpGetFullPath( &gOutputFile, &len, &destH ); + + char* theDestPath; + char pathBuffer[1024]; + + if( destH ) { + + ::HLock(destH); + + uprv_memcpy(pathBuffer, ((char*)(*destH)), len); + pathBuffer[len] = 0; + theDestPath = pathBuffer; + + ::DisposeHandle(destH); + destH = 0; + } + + // get the source directory + Handle srcH = 0; + len = 0; + + theErr = FSpGetFullPath( &gSourceFile, &len, &srcH ); + + char* theSrcPath; + char srcBuffer[1024]; + + if( srcH ) { + + ::HLock(srcH); + + uprv_memcpy(srcBuffer, ((char*)(*srcH)), len); + srcBuffer[len] = 0; + theSrcPath = srcBuffer; + + ::DisposeHandle(srcH); + srcH = 0; + + // truncate file name from full path string +// std::string str = theSrcPath; +// str = str.substr( 0, str.find_last_of( ":" ) + 1); +// std::strcpy(theSrcPath, str.c_str()); + } +*/ + // set the destination directory + char* theDestPath = ""; + char pathBuffer[1024]; + + get_path_string( &theDestPath, pathBuffer, &gOutputFile, false); + + // set the source directory + char* theSrcPath = ""; + char srcBuffer[1024]; + + get_path_string( &theSrcPath, srcBuffer, &gSourceFile, false); + + int argc = 4; + char* argv[] = { "makeconv", "-d", theDestPath, theSrcPath }; + + if ( setjmp( exit_jump) == 0) { + + // Need to test that we can locate our file here so we don't + // have to in fopen(). That way, we won't get error messages + // from makeconv.c when .dat files (that we don't care about) + // aren't found. +// err = LocateFile(gPluginContext, gSourceFileName, gSourceFile); + + if ( main( argc, argv) != 0) + err = cwErrRequestFailed; + } + else { + // evidently the good old exit function got called. + if ( exit_status != 0) + err = cwErrRequestFailed; + } + + // if the compilation succeeded, tell CodeWarrior about the output file. + // this ensures several things: 1. if the output file is deleted by the user, + // then the IDE will know to recompile it, which is good for dirty builds, + // where the output files may be hand deleted; 2. if the user elects to remove + // objects, the output files are deleted. Thanks to robv@metrowerks.com for + // pointing this new CWPro4 API out. + if (err == cwNoErr) { + CWObjectData objectData; + ::BlockZero(&objectData, sizeof( objectData)); + + // for fun, show how large the output file is in the data area. + long dataSize, rsrcSize; + if ( FSpGetFileSize( &gOutputFile, &dataSize, &rsrcSize) == noErr) + objectData.idatasize = dataSize; + + // tell the IDE that this file was generated by the compiler. + objectData.objectfile = &gOutputFile; + + err = CWStoreObjectData( context, fileNum, &objectData); + } + else { + // an error occured, delete the output file, which might be a partial file. + if ( gOutputFile.name[0] != 0) { + ::FSpDelete( &gOutputFile); + } + } + + delete[] gSourceFileName; + gSourceFileName = NULL; + return (err); +} + + +// main entry-point for makeconv compiler plugin +pascal short makeconv_compiler( CWPluginContext context) +{ + short result = cwNoErr; + long request; + + // Get the value indicating the task the IDE is currently asking the + // plugin to perform and make sure no error was evoked. + if ( CWGetPluginRequest( context, &request) != cwNoErr) + return cwErrRequestFailed; + + gPluginContext = context; + result = cwNoErr; + + // dispatch on compiler request + switch (request) + { + case reqInitCompiler: break; // compiler has just been loaded into memory + + case reqTermCompiler: break; // compiler is about to be unloaded from memory + + case reqCompile: + /* compile a source file */ + result = Compile( context); + break; + + default: + result = cwErrRequestFailed; + break; + } + + gPluginContext = 0; + return (result); +} + diff --git a/icu4c/as_is/codewarrior/mac/mac_utils.cpp b/icu4c/as_is/codewarrior/mac/mac_utils.cpp new file mode 100644 index 00000000000..101bde62a46 --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_utils.cpp @@ -0,0 +1,221 @@ +/** + * File: mac_utils.cpp + * + * Routines + * -------- + * + * get_path_string + * FSpGetFileSize + * p2c_strdup + * exit + * + * Description + * ----------- + * + * Contains functions needed for Macintosh versions of command-line compilers + * + * Authors + * ------- + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + +#include "mac_utils.h" + +// icu headers +#include "cmemory.h" +#include "utypes.h" + +// msl headers +#include + + +extern "C" pascal OSErr FSpGetFullPath( const FSSpec *spec, short *fullPathLength, Handle *fullPath); + +CWFileSpec gOutputFile; +CWFileSpec gSourceFile; +char* gDestPath = NULL; +char* gSourceFileName = NULL; + +/** + * get_path_string + * + * Creates a string with the full path (with or without the file name) from + * a FSSpec. Command-line tools expect full paths but Macs deal with files + * via filespecs. The limitation to using full paths is that it is possible + * to have two mounted volumes with the same name on a Mac. Filespecs can + * distinguish between the two (by using volume reference numbers) but full + * paths cannot. + * + */ + +void get_path_string( char** oPath, + char oPathBuffer[], + CWFileSpec* iFileSpec, + bool doTruncate + ) +{ + Handle theHandle = 0; + short len = 0; + + OSErr theErr = FSpGetFullPath( iFileSpec, &len, &theHandle ); + + if ( theHandle && !theErr) { + + ::HLock( theHandle); + + uprv_memcpy( oPathBuffer, ( static_cast< char*>( *theHandle)), len); + oPathBuffer[ len ] = 0; + *oPath = oPathBuffer; + + ::DisposeHandle( theHandle); + theHandle = 0; + + if ( doTruncate) { + // truncate file name from full path string + std::string str = *oPath; + str = str.substr( 0, str.find_last_of( ":" ) + 1); + std::strcpy( *oPath, str.c_str()); + } + } +} + +/** + * + * FSpGetFileSize + * + * This function code was derived from code in MoreFilesExtras.h which is part + * of 'MoreFiles' (Apple Sample Code). + * + */ + +pascal OSErr FSpGetFileSize( const FSSpec* spec, long* dataSize, long* rsrcSize) +{ + HParamBlockRec pb; + + pb.fileParam.ioNamePtr = const_cast< StringPtr>( spec->name); + pb.fileParam.ioVRefNum = spec->vRefNum; + pb.fileParam.ioFVersNum = 0; + pb.fileParam.ioDirID = spec->parID; + pb.fileParam.ioFDirIndex = 0; + + OSErr error = PBHGetFInfoSync( &pb); + + if ( noErr == error ) { + *dataSize = pb.fileParam.ioFlLgLen; + *rsrcSize = pb.fileParam.ioFlRLgLen; + } + + return ( error ); +} + +/** + * p2c_strdup + * + * Creates a duplicate c string from a pascal string. + * + * NOTE: The user is responsible for calling delete[] + * when he/she is finished using the string in + * order to prevent a memory leak. + * + */ + +char* p2c_strdup( StringPtr pstr) +{ + size_t len = pstr[0]; + char* cstr = new char[1 + len]; + + if ( cstr != NULL) { + ::BlockMoveData( pstr + 1, cstr, len); + cstr[len] = '\0'; + } + return cstr; +} + +/** + * exit + * + * simply throw us out of here! + */ + +jmp_buf exit_jump; +int exit_status = 0; + +void std::exit( int status) +{ + exit_status = status; + longjmp( exit_jump, -1); +} + +/*****************************************************************************/ +/* +StringPtr c2p_strcpy( StringPtr pstr, const char* cstr) +{ + size_t len = ::strlen(cstr); + if (len > 255) len = 255; + BlockMoveData(cstr, pstr + 1, len); + pstr[0] = len; + return pstr; +} +*/ +/*****************************************************************************/ +/* +CWResult LocateFile(CWPluginContext context, const char* filename, FSSpec& file) +{ + // prefill the CWFileInfo struct + CWFileInfo fileinfo; + BlockZero(&fileinfo, sizeof(fileinfo)); + // memset(&fileinfo, 0, sizeof(fileinfo)); + fileinfo.fullsearch = true; + fileinfo.suppressload = true; + fileinfo.dependencyType = cwNormalDependency; + fileinfo.isdependentoffile = kCurrentCompiledFile; + + // locate the file name using the project's access paths + CWResult err = CWFindAndLoadFile(context, filename, &fileinfo); + if (err == cwNoErr) { + file = fileinfo.filespec; + } else if (err == cwErrFileNotFound) { + char errmsg[200]; + sprintf(errmsg, "Can't locate file \"%s\".", filename); + CWResult callbackResult = CWReportMessage(context, 0, errmsg, 0, messagetypeError, 0); + } + + return (err); +} +*/ +/** + * Substitute for standard fopen, treats certain filenames specially, + * and also considers the mode argument. If a file is being opened + * for reading, the file is assumed to be locateable using CodeWarrior's + * standard access paths. If it's for writing, the file is opened in + * the current project's output directory. + */ +/* +extern "C" FILE * FSp_fopen(ConstFSSpecPtr spec, const char * open_mode); + + +FILE* std::fopen(const char* filename, const char *mode) +{ + FSSpec filespec; + CWResult err = noErr; + do { + if (filename == gSourcePath || strcmp(filename, gSourcePath) == 0) { + // opening the main source file. + filespec = gSourceFile; + } else if (mode[0] == 'w') { + // if an output file, open it in the current compilation's output directory. + c2p_strcpy(filespec.name, filename); + filespec.vRefNum = gOutputFile.vRefNum; + filespec.parID = gOutputFile.parID; + c2p_strcpy(gOutputFile.name, filename); + } else { + // an input file, use CodeWarrior's search paths to find the named source file. +// err = LocateFile(gPluginContext, filename, filespec); + } + } while (0); + // if all went well, we have a file to open. + return (err == noErr ? FSp_fopen(&filespec, mode) : NULL); +} +*/ \ No newline at end of file diff --git a/icu4c/as_is/codewarrior/mac/mac_utils.h b/icu4c/as_is/codewarrior/mac/mac_utils.h new file mode 100644 index 00000000000..3eeb009d7bc --- /dev/null +++ b/icu4c/as_is/codewarrior/mac/mac_utils.h @@ -0,0 +1,48 @@ +/** + * File: mac_utils.h + * + * Functions needed for Macintosh versions of command-line compilers + * + * Sean K. Todd (stodd@broadjump.com) + * Marty Saxton (msaxton@broadjump.com) + */ + + +// Toolbox headers +#include +#include + +// MSL headers +#include +#include + +// CodeWarrior Plugin SDK headers +#include +#include +#include +#include + +// external variables +extern jmp_buf exit_jump; +extern int exit_status; +extern char* gSourceFileName; +extern char* gDestPath; +extern CWFileSpec gSourceFile; +extern CWFileSpec gOutputFile; + + +void get_path_string( char** oPath, + char oPathBuffer[], + CWFileSpec* iFileSpec, + bool doTruncate + ); + +pascal OSErr FSpGetFileSize( const FSSpec *spec, long *dataSize, long *rsrcSize); + +char* p2c_strdup( StringPtr pstr); + +void std::exit( int status); + + +//CWResult LocateFile(CWPluginContext context, const char* filename, FSSpec& file); +//StringPtr c2p_strcpy(StringPtr pstr, const char* cstr);