int FscRead::ReadFont() { iInputFile.seekg(0,ios::end); iFileBufLen=iInputFile.tellg(); iInputFile.seekg(0); iFileBufPos=0; iFileBuf=new char[iFileBufLen]; iInputFile.read(iFileBuf,iFileBufLen); int ret=Pass1(); if(ret) return(ret); return(Pass2()); }
static void PreprocessLine (void) /* Translate one line. */ { /* Trim whitespace and remove comments. The function returns the number of * identifiers found. If there were any, we will have to check for macros. */ SB_Clear (MLine); if (Pass1 (Line, MLine) > 0) { MLine = InitLine (MLine); SB_Reset (Line); SB_Clear (MLine); MacroReplacement (Line, MLine); } /* Read from the new line */ SB_Reset (MLine); MLine = InitLine (MLine); }
int main( int argc, char * argv[] ) #endif /***************************************/ { bool noerror; #ifndef DLL_COMPILE RcMemInit(); Layer0InitStatics(); #if !defined(__UNIX__) && !defined(__OSI__) /* _grow_handles doesn't work yet */ _grow_handles(100); #endif #endif if( !InitRcMsgs( argv[0] ) ) return( 1 ); noerror = ScanParams( argc, argv ); if (!CmdLineParms.Quiet) { RcIoPrintBanner(); } if (CmdLineParms.PrintHelp) { RcIoPrintHelp( argv[0] ); } if (noerror && !CmdLineParms.Pass2Only) { noerror = Pass1(); } if (noerror && !CmdLineParms.Pass1Only && !CmdLineParms.PreprocessOnly ) { noerror = Pass2(); } FiniTable(); #ifndef DLL_COMPILE ScanParamShutdown(); FiniRcMsgs(); RcMemShutdown(); #endif if (noerror) { return( 0 ); } else { return( 1 ); } } /* main */
static void DoPragma (void) /* Handle a #pragma line by converting the #pragma preprocessor directive into * the _Pragma() compiler operator. */ { /* Skip blanks following the #pragma directive */ SkipWhitespace (0); /* Copy the remainder of the line into MLine removing comments and ws */ SB_Clear (MLine); Pass1 (Line, MLine); /* Convert the directive into the operator */ SB_CopyStr (Line, "_Pragma ("); SB_Reset (MLine); Stringize (MLine, Line); SB_AppendChar (Line, ')'); /* Initialize reading from line */ SB_Reset (Line); InitLine (Line); }
int main() { int Pass1(MNT mnt[50], MDT mdt[50], int mntc, int mdtc, Pass1table table1[50]); int Pass2(MNT mnt[50], MDT mdt[50], int mntc, Pass1table table1[50], int tp, Pass2table table2[50]); int putinbuffer(FILE *fin, char buffer[20]); int displayPass1tables(MNT mnt[50], int mntc, MDT mdt[50], int mdtc, FPPL fppl[5], int fptr); int print_IC(Pass1table table1[50], int tp); int o=0; MNT mnt[50]; MDT mdt[50]; Pass1table table1[50]; int mdtc=0, tp=0, tp2=0, mntc=0; printf("\nPrinting the IC File"); tp=Pass1(mnt,mdt,mntc,mdtc,table1); return 0; }
int main(int argc, char *argv[]) { progname = argv[0]; /* save program name */ argv++, argc--; /* and skip it */ /* Set the default output and debug streams */ OutputFile = stdout; DebugFile = stdout; /* Get command line options */ { int nop = do_options(progname, optlist, argc, argv); argc -= nop, argv += nop; /* skip them */ } /* Treat the value options */ if (minrunstring) { MinRunSize = strtoul(minrunstring, NULL, 10); if (MinRunSize == 0) fatal("bad or zero run size; form is: -r N"); } if (pagewidthstring) { PageWidth = atoi(pagewidthstring); if (PageWidth == 0) fatal("bad or zero page width; form is: -w N"); } if (outputname) { OutputFile = fopen(outputname, "w"); if (OutputFile == 0) { char msg[500]; sprintf(msg, "cannot open output file %s", outputname); fatal(msg); /*NOTREACHED*/ } } if (option_set('-')) { /* it is the lexical scan only */ while (argv[0]) { print_stream(argv[0]); argv++; } return 0; } /* Start processing */ InitLanguage(); /* Read the input files */ Pass1(argc, argv); /* Set up the forward reference table */ MakeForwardReferences(); /* Compare the input files to find runs */ Compare(); /* Delete forward reference table */ FreeForwardReferences(); /* Find positions of the runs found */ Pass2(); /* Print the similarities */ Pass3(); return 0; }
static void DefineMacro (void) /* Handle a macro definition. */ { ident Ident; Macro* M; Macro* Existing; int C89; /* Read the macro name */ SkipWhitespace (0); if (!MacName (Ident)) { return; } /* Remember if we're in C89 mode */ C89 = (IS_Get (&Standard) == STD_C89); /* Get an existing macro definition with this name */ Existing = FindMacro (Ident); /* Create a new macro definition */ M = NewMacro (Ident); /* Check if this is a function like macro */ if (CurC == '(') { /* Skip the left paren */ NextChar (); /* Set the marker that this is a function like macro */ M->ArgCount = 0; /* Read the formal parameter list */ while (1) { /* Skip white space and check for end of parameter list */ SkipWhitespace (0); if (CurC == ')') { break; } /* The next token must be either an identifier, or - if not in * C89 mode - the ellipsis. */ if (!C89 && CurC == '.') { /* Ellipsis */ NextChar (); if (CurC != '.' || NextC != '.') { PPError ("`...' expected"); ClearLine (); return; } NextChar (); NextChar (); /* Remember that the macro is variadic and use __VA_ARGS__ as * the argument name. */ AddMacroArg (M, "__VA_ARGS__"); M->Variadic = 1; } else { /* Must be macro argument name */ if (MacName (Ident) == 0) { return; } /* __VA_ARGS__ is only allowed in C89 mode */ if (!C89 && strcmp (Ident, "__VA_ARGS__") == 0) { PPWarning ("`__VA_ARGS__' can only appear in the expansion " "of a C99 variadic macro"); } /* Add the macro argument */ AddMacroArg (M, Ident); } /* If we had an ellipsis, or the next char is not a comma, we've * reached the end of the macro argument list. */ SkipWhitespace (0); if (M->Variadic || CurC != ',') { break; } NextChar (); } /* Check for a right paren and eat it if we find one */ if (CurC != ')') { PPError ("`)' expected"); ClearLine (); return; } NextChar (); } /* Skip whitespace before the macro replacement */ SkipWhitespace (0); /* Insert the macro into the macro table and allocate the ActualArgs array */ InsertMacro (M); /* Remove whitespace and comments from the line, store the preprocessed * line into the macro replacement buffer. */ Pass1 (Line, &M->Replacement); /* Remove whitespace from the end of the line */ while (IsSpace (SB_LookAtLast (&M->Replacement))) { SB_Drop (&M->Replacement, 1); } #if 0 printf ("%s: <%.*s>\n", M->Name, SB_GetLen (&M->Replacement), SB_GetConstBuf (&M->Replacement)); #endif /* If we have an existing macro, check if the redefinition is identical. * Print a diagnostic if not. */ if (Existing && MacroCmp (M, Existing) != 0) { PPError ("Macro redefinition is not identical"); } }
/****************************************************************************** Description : Parameters : Returns : Comments : ******************************************************************************/ int main(int argc, char *argv[]) { char optch; char *outputext = "ptp"; int exitvalue = EXIT_SUCCESS; /****** * Set up globals. ******/ if (argv[0] != NULL) ProgName = argv[0]; /****** * Check parameters. ******/ opterr = 0; while ((optch = getopt(argc, argv, "l:")) != -1) { switch (optch) { case 'l': ListFileName = optarg; break; default: usage(); } } if (optind + 1 != argc) usage(); InFileName = argv[optind]; InFile = fopen(InFileName, "r"); if (InFile == NULL) Error("Can't open '%s' for first pass read: %s", InFileName, strerror(errno)); if (strlen(InFileName) > 3 && STREQ(InFileName + strlen(InFileName) - 4, ".asm")) { char *newname = CopyStr(InFileName); char *chptr = newname + strlen(newname) - 4; *chptr = '\0'; sprintf(OutFileName, "%s.%s", newname, outputext); free(newname); } else sprintf(OutFileName, "%s.%s", InFileName, outputext); OutFile = fopen(OutFileName, "w"); if (OutFile == NULL) Error("Can't open '%s' for output: %s", OutFileName, strerror(errno)); if (ListFileName != NULL) { ListFile = fopen(ListFileName, "w"); if (ListFile == NULL) Error("Can't open '%s' for list output: %s", ListFileName, strerror(errno)); } /****** * Assemble the input file. ******/ if (Pass1()) { fclose(InFile); InFile = fopen(InFileName, "r"); if (InFile == NULL) Error("Can't open '%s' for second pass read: %s", InFileName, strerror(errno)); if (!Pass2()) exitvalue = PASS2_FAIL; } else exitvalue = PASS1_FAIL; /****** * Close the files. ******/ if (InFile != NULL) fclose(InFile); if (OutFile != NULL) fclose(OutFile); exit(exitvalue); }