int main( int argc, char *argv[] ) { int c; dumpheap(); if( argc < 2 ) { printf( "Usage: testpp filename\n" ); exit( 1 ); } if( argv[2] != NULL ) { PreProcChar = argv[2][0]; } if( PP_Init( argv[1], PPFLAG_EMIT_LINE, NULL ) != 0 ) { printf( "Unable to open '%s'\n", argv[1] ); exit( 1 ); } for( ;; ) { c = PP_Char(); if( c == EOF ) break; putchar( c ); } dumpheap(); PP_Fini(); dumpheap(); return( 0 ); }
static int Pass1( void ) /**********************/ { int noerror; noerror = RcPass1IoInit(); if( noerror ) { if( !CmdLineParms.PreprocessOnly ) { SetDefLang(); if( CmdLineParms.TargetOS == RC_TARGET_OS_OS2 ) { ParseInitOS2(); ParseOS2(); } else { ParseInit(); Parse(); } WriteDependencyRes(); } else { CreatePreprocFile(); } PP_Fini(); RcPass1IoShutdown(); noerror = !ErrorHasOccured; } return( noerror ); } /* Pass1 */
extern void RcFatalError( unsigned int errornum, ... ) /****************************************************/ { va_list arglist; va_start( arglist, errornum ); errornum = checkForTmpFiles( errornum, arglist ); va_end( arglist ); va_start( arglist, errornum ); RcMsgV( errornum, SEV_FATAL_ERR, arglist ); va_end( arglist ); if( IsTmpFile( CurrResFile.filename ) ) { ResCloseFile( CurrResFile.handle ); remove( CurrResFile.filename ); UnregisterTmpFile( CurrResFile.filename ); } CloseAllFiles(); PP_Fini(); #ifdef WR_COMPILED longjmp( RC_Dead_env, 1 ); #elif defined DLL_COMPILE longjmp( DLL_JumpPt, 1 ); #else exit( -1 ); #endif }
extern int RcPass1IoInit( void ) /******************************/ /* Open the two files for input and output. The input stream starts at the */ /* top infilename and continues as the directives in the file indicate */ /* Returns false if there is a problem opening one of the files. */ { int error; char *includepath = NULL; if( !CmdLineParms.IgnoreINCLUDE ) { if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN16 ) { includepath = RcGetEnv( "WINDOWS_INCLUDE" ); } else if( CmdLineParms.TargetOS == RC_TARGET_OS_WIN32 ) { includepath = RcGetEnv( "NT_INCLUDE" ); } else if( CmdLineParms.TargetOS == RC_TARGET_OS_OS2 ) { includepath = RcGetEnv( "OS2_INCLUDE" ); } if( includepath != NULL ) { PP_AddIncludePath( includepath ); } includepath = RcGetEnv( "INCLUDE" ); if( includepath != NULL ) { PP_AddIncludePath( includepath ); } } if( !CmdLineParms.NoPreprocess ) { if( PreprocessInputFile() ) { return( FALSE ); } } RcIoTextInputInit(); error = RcIoPushInputFile( CmdLineParms.InFileName ); if( error ) return( FALSE ); if( !CmdLineParms.PreprocessOnly ) { error = Pass1InitRes(); } if( error ) { PP_Fini(); RcIoTextInputShutdown(); return( FALSE ); } return( TRUE ); }
int main( int argc, char *argv[] ) { if( argc < 2 ) { cprintf( "Usage: mkmk filename\r\n" ); exit( 1 ); } if( argv[2] != NULL ) { PreProcChar = argv[2][0]; } if( PP_Init( argv[1], PPFLAG_DEPENDENCIES, NULL ) != 0 ) { cprintf( "Unable to open '%s'\r\n", argv[1] ); exit( 1 ); } // call PP_Define here to predefine any desired macros PP_Dependency_List( MkMkDependency ); PP_Fini(); return( 0 ); }
extern void RcFatalError( unsigned int errornum, ... ) /****************************************************/ { va_list arglist; va_start( arglist, errornum ); errornum = checkForTmpFiles( errornum, arglist ); va_end( arglist ); va_start( arglist, errornum ); RcMsgV( errornum, SEV_FATAL_ERR, arglist ); va_end( arglist ); if( IsTmpFile( CurrResFile.filename ) ) { ResCloseFile( CurrResFile.handle ); remove( CurrResFile.filename ); UnregisterTmpFile( CurrResFile.filename ); } #if !defined( WRDLL ) CloseAllFiles(); #endif PP_Fini(); RCSuicide( -1 ); }
static char *WRELoadSymbols( WRHashTable **table, char *file_name, bool prompt ) { char *name; int c; unsigned flags; char *inc_path; WREGetFileStruct gf; unsigned pp_count; unsigned busy_count; char busy_str[2]; bool ret; bool ok; name = NULL; ok = (table != NULL); if( ok ) { WRESetStatusText( NULL, "", FALSE ); WRESetStatusByID( WRE_LOADINGSYMBOLS, -1 ); } if( ok ) { if( file_name == NULL || prompt ) { gf.file_name = file_name; gf.title = WRESymLoadTitle; gf.filter = WRESymSaveFilter; gf.save_ext = FALSE; name = WREGetOpenFileName( &gf ); } else { name = WREStrDup( file_name ); } ok = (name != NULL); } WRESetWaitCursor( TRUE ); if( ok ) { flags = PPFLAG_IGNORE_INCLUDE | PPFLAG_EMIT_LINE; inc_path = NULL; ret = setjmp( SymEnv ); if( ret ) { PP_Fini(); WREDisplayErrorMsg( WRE_SYMOUTOFMEM ); ok = false; } } if( ok ) { ok = !PP_Init( name, flags, inc_path ); if( !ok ) { WREDisplayErrorMsg( WRE_NOLOADHEADERFILE ); } } if( ok ) { pp_count = 0; busy_count = 0; busy_str[1] = '\0'; do { pp_count++; c = PP_Char(); if( pp_count == MAX_PP_CHARS ) { busy_count++; busy_str[0] = WREBusyChars[busy_count % 4]; WRESetStatusText( NULL, busy_str, TRUE ); pp_count = 0; } } while( c != EOF ); if( *table == NULL ) { *table = WRInitHashTable(); } WREAddSymbols( *table ); WRMakeHashTableClean( *table ); PP_Fini(); WRESetStatusText( NULL, " ", TRUE ); } if( !ok ) { if( name != NULL ) { WRMemFree( name ); name = NULL; } } WRESetWaitCursor( FALSE ); WRESetStatusReadyText(); return( name ); }
int main( int argc, char **argv ) //******************************* { static char *fname; #ifndef __WATCOMC__ _argv = argv; _argc = argc; #endif MemInit(); if( !AsMsgInit() ) { return( EXIT_FAILURE ); } if( argc == 1 ) { Banner(); Usage(); } else if( OptionsInit( --argc, ++argv ) ) { Banner(); if( _IsOption( PRINT_HELP ) ) { Usage(); *argv = NULL; } else if( !*argv ) { AsOutMessage( stderr, AS_MSG_ERROR ); AsOutMessage( stderr, NO_FILENAME_SPECIFIED ); fputc( '\n', stderr ); } while( *argv ) { fname = MakeAsmFilename( *argv ); if( PP_Init( fname, PPFLAG_ASM_COMMENT | PPFLAG_EMIT_LINE, NULL ) != 0 ) { AsOutMessage( stderr, UNABLE_TO_OPEN, fname ); fputc( '\n', stderr ); } else { OptionsPPDefine(); SymInit(); InsInit(); DirInit(); if( ObjInit( fname ) ) { if( setjmp( AsmParse ) == 0 ) { ErrorCountsReset(); DoReport = TRUE; if( !yyparse() ) { CurrLineno--; // This is the total # of lines ObjRelocsFini(); // Must be done before ErrorReport // and other finis } else { DoReport = FALSE; } } else { // AbortParse() was invoked DoReport = FALSE; } ErrorReport(); AsLexerFini(); ObjFini(); } DirFini(); InsFini(); SymFini(); } PP_Fini(); ++argv; } } OptionsFini(); AsMsgFini(); MemFini(); return( ExitStatus ); }
char *WLoadSymbols( WRHashTable **table, char *file_name, HWND parent, bool prompt ) { char *name; int c; unsigned flags; char *inc_path; WGetFileStruct gf; bool ret; bool ok; name = NULL; ok = (table != NULL); if( ok ) { if( file_name == NULL || prompt ) { gf.file_name = file_name; gf.title = AllocRCString( W_LOADSYMTITLE ); gf.filter = AllocRCString( W_SYMFILTER ); WMassageFilter( gf.filter ); name = WGetOpenFileName( parent, &gf ); if( gf.title != NULL ) { FreeRCString( gf.title ); } if( gf.filter != NULL ) { FreeRCString( gf.filter ); } } else { name = WStrDup( file_name ); } ok = (name != NULL); } WSetWaitCursor( parent, TRUE ); if( ok ) { flags = PPFLAG_IGNORE_INCLUDE | PPFLAG_EMIT_LINE; inc_path = NULL; ret = setjmp( SymEnv ) != 0; if( ret ) { PP_Fini(); WDisplayErrorMsg( W_SYMOUTOFMEM ); ok = false; } } if( ok ) { ok = !PP_Init( name, flags, inc_path ); if( !ok ) { WDisplayErrorMsg( W_NOOPENSYMFILE ); } } if( ok ) { do { c = PP_Char(); } while( c != EOF ); if( *table == NULL ) { *table = WRInitHashTable(); } addSymbols( *table ); WRMakeHashTableClean( *table ); PP_Fini(); } if( !ok ) { if( name != NULL ) { WRMemFree( name ); name = NULL; } } WSetWaitCursor( parent, FALSE ); return( name ); }
static bool scanEnvVarOrFile( const char *name ) /**********************************************/ { /* * Pass nofilenames and analysis of getenv(name) into argc and argv * to doScanParams. Return view on usability of data. (true is usable.) * * Recursion is supported but circularity is rejected. */ typedef struct VarInfo { struct VarInfo *next; char *name; char **argv; /* points into buf */ char buf[1]; /* dynamic array */ } VarInfo; int argc; VarInfo *info; static VarInfo *stack = NULL; // Needed to detect recursion. size_t argvsize; size_t argbufsize; const char *optstring; size_t varlen; // size to hold name copy. bool result; // doScanParams Result. char fbuf[512]; optstring = PP_GetEnv( name ); if( optstring == NULL ) { FILE *fh; fh = fopen( name, "rt" ); if( fh == NULL ) { // RcWarning( ERR_ENV_VAR_NOT_FOUND, name ); return( true ); } fgets( fbuf, sizeof( fbuf ), fh ); fclose( fh ); optstring = fbuf; } // This used to cause stack overflow: set foo=@foo && wrc @foo. for( info = stack; info != NULL; info = info->next ) { #if defined( __UNIX__ ) if( strcmp( name, info->name ) == 0 ) { // Case-sensitive #else if( stricmp( name, info->name ) == 0 ) { // Case-insensitive #endif // RcFatalError( ERR_RCVARIABLE_RECURSIVE, name ); } } argc = ParseVariable( optstring, NULL, NULL ); // count parameters. argbufsize = strlen( optstring ) + 1 + argc; // inter-parameter spaces map to 0 argvsize = argc * sizeof( char * ); // sizeof argv[argc+1] varlen = strlen( name ) + 1; // Copy taken to detect recursion. info = malloc( sizeof( *info ) + argbufsize + argvsize + varlen ); info->next = stack; stack = info; // push info on stack info->argv = (char **)info->buf; ParseVariable( optstring, info->argv, info->buf + argvsize ); info->name = info->buf + argvsize + argbufsize; strcpy( info->name, name ); result = doScanParams( argc, info->argv ); stack = info->next; // pop stack free( info ); return( result ); } static bool doScanParams( int argc, char *argv[] ) /************************************************/ { const char *arg; int switchchar; bool contok; /* continue with main execution */ int currarg; contok = true; switchchar = _dos_switch_char(); for( currarg = 0; currarg < argc && contok; currarg++ ) { arg = argv[currarg]; if( *arg == switchchar || *arg == '-' ) { contok = ScanOptionsArg( arg + 1 ) && contok; } else if( *arg == '@' ) { contok = scanEnvVarOrFile( arg + 1 ) && contok; } else if( *arg == '?' ) { wcpp_quit( usageMsg, NULL ); // contok = false; } else { filenames = realloc( (void *)filenames, ( nofilenames + 1 ) * sizeof( char * ) ); filenames[nofilenames++] = my_strdup( arg ); } } return( contok ); } int main( int argc, char *argv[] ) { int ch; int i; int j; int rc; FILE *fo; if( argc < 2 ) { wcpp_quit( usageMsg, "No filename specified\n" ); } else if( argc == 2 ) { if( !strcmp( argv[1], "?" ) ) { wcpp_quit( usageMsg, NULL ); } } PP_IncludePathInit(); rc = EXIT_FAILURE; if( doScanParams( argc - 1, argv + 1 ) && nofilenames != 0 ) { PP_Init( '#' ); fo = stdout; if( out_filename != NULL ) { fo = fopen( out_filename, "wb" ); } rc = EXIT_SUCCESS; for( i = 0; i < nofilenames; ++i ) { if( PP_FileInit( filenames[i], flags, NULL ) != 0 ) { fprintf( stderr, "Unable to open '%s'\n", filenames[i] ); rc = EXIT_FAILURE; break; } for( j = 0; j < numdefs; j++ ) { PP_Define( defines[j] ); } for( ;; ) { ch = PP_Char(); if( ch == EOF ) break; #ifndef __UNIX__ if( ch == '\n' ) fputc( '\r', fo ); #endif fputc( ch, fo ); } PP_FileFini(); } if( fo == stdout ) { fflush( fo ); } else if( fo != NULL ) { fclose( fo ); } PP_Fini(); } if( out_filename != NULL ) { free( out_filename ); } for( i = 0; i < nofilenames; ++i ) { free( filenames[i] ); } free( (void *)filenames ); for( i = 0; i < numdefs; i++ ) { free( defines[i] ); } free( (void *)defines ); PP_IncludePathFini(); if( rc == EXIT_FAILURE && nofilenames == 0 ) { wcpp_quit( usageMsg, "No filename specified\n" ); } return( rc ); }