home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 March / Gamestar_82_2006-03_dvd.iso / DVDStar / Editace / quake4_sdkv10.exe / source / idlib / Lexer.cpp < prev    next >
C/C++ Source or Header  |  2005-11-14  |  86KB  |  3,945 lines
  1.  
  2. #include "precompiled.h"
  3. #pragma hdrstop
  4.  
  5. #ifdef LEXER_READ_AHEAD
  6.  
  7. namespace {
  8.  
  9.     #define IO_BUFFER_CHUNK_SIZE (1024 * 64)
  10.  
  11.     enum {
  12.         IOJobPending = 0,
  13.         IOJobQuit,
  14.         IOJobComplete,
  15.         IOJobCount
  16.     };
  17.     static HANDLE mIOJobs[IOJobCount];
  18.  
  19.     static DWORD mThreadId = 0;
  20.     static HANDLE mThreadHandle = 0;
  21.  
  22.  
  23.     struct IOJobData {
  24.         idFile *mFile;
  25.         int mAmtToRead;
  26.         byte mBuffer[IO_BUFFER_CHUNK_SIZE];
  27.     };
  28.  
  29.     IOJobData gIOJobData;
  30.  
  31.     void SetPendingJob(idFile *f, int size) {
  32.         gIOJobData.mFile = f;
  33.         gIOJobData.mAmtToRead = size;
  34.         
  35.         if ( mThreadHandle ) {
  36.             SetEvent( mIOJobs[IOJobPending] );
  37.         }
  38.     }
  39.  
  40.     IOJobData *GetPendingJob() {
  41.         return &gIOJobData;
  42.     }
  43.  
  44.     void GetPendingJobResults(byte *dest, int &size) {
  45.         if ( mThreadHandle ) {        
  46.             if ( WAIT_OBJECT_0 == WaitForSingleObject( mIOJobs[IOJobComplete], INFINITE ) ) {
  47.                 //ResetEvent( mIOJobs[IOJobComplete] );
  48.                 size = gIOJobData.mAmtToRead;
  49.                 memcpy(dest, gIOJobData.mBuffer, size );
  50.             } else {
  51.                 assert( 0 );
  52.             }
  53.         } else {
  54.             gIOJobData.mFile->Read( dest, gIOJobData.mAmtToRead );
  55.             size = gIOJobData.mAmtToRead;
  56.         }
  57.     }
  58.  
  59.     static LONG IOThread( void * ) {
  60.         while ( 1 ) {
  61.             DWORD res = WaitForMultipleObjects( 2, mIOJobs, FALSE, INFINITE );        
  62.             if ( res == WAIT_OBJECT_0 ) {
  63.                 //ResetEvent( mIOJobs[IOJobPending] );
  64.                 IOJobData *j = GetPendingJob();
  65.                 j->mFile->Read( j->mBuffer, j->mAmtToRead );
  66.                 SetEvent( mIOJobs[IOJobComplete] );
  67.             } else if ( res == (WAIT_OBJECT_0 + 1) ) {
  68.                 ExitThread(0);
  69.             } else { 
  70.                 assert( 0 );
  71.             }
  72.         }
  73.         ExitThread(0);
  74.     }
  75.  
  76.     void InitIO() {
  77.         for ( int i = 0; i < IOJobCount; ++i ) {
  78.             //mIOJobs[i] = CreateEvent( 0, TRUE, FALSE, 0 );
  79.             mIOJobs[i] = CreateEvent( 0, FALSE, FALSE, 0 );
  80.         }
  81.         mThreadHandle = CreateThread( NULL, 1024 * 512, ( LPTHREAD_START_ROUTINE )IOThread, 0, CREATE_SUSPENDED, &mThreadId );
  82.         ResumeThread( mThreadHandle );
  83.     }
  84.  
  85.     void ShutdownIO() {
  86.         
  87.         SetEvent( mIOJobs[IOJobQuit] );
  88.         
  89.         DWORD ecode = 0;
  90.         while ( !GetExitCodeThread( mThreadHandle, &ecode ) ) {
  91.             Sleep( 1 );
  92.         }
  93.         CloseHandle( mThreadHandle );
  94.  
  95.         for ( int i = 0; i < IOJobCount; ++i ) {
  96.             CloseHandle( mIOJobs[i] );
  97.         }
  98.         
  99.         mThreadHandle = 0;
  100.     }
  101.  
  102. }
  103.  
  104. namespace ChunkBuffer {
  105.  
  106.     idFile *mFile;
  107.     int mFileSize;
  108.     int mBytesRead;
  109.     
  110.     int mFileBytesRead;
  111.     
  112.     byte mChunkMem[IO_BUFFER_CHUNK_SIZE];
  113.     int mCurrentChunkBytes;
  114.     int mCurrentChunkBytesRead = 0;
  115.     
  116.     /*
  117.     ================
  118.     ChunkBuffer::Length
  119.     ================
  120.     */
  121.     int Length() {
  122.         return mFileSize;
  123.     }
  124.     
  125.     /*
  126.     ================
  127.     ChunkBuffer::BytesRead
  128.     ================
  129.     */
  130.     int BytesRead() {
  131.         return mBytesRead;
  132.     }
  133.     
  134.     /*
  135.     ================
  136.     ChunkBuffer::Begin
  137.     ================
  138.     */
  139.     void Begin( idFile *f ) {
  140.         mFile = f;
  141.         mFileSize = f->Length();
  142.         mBytesRead = 0;
  143.         
  144.         int initialRead = (mFileSize < IO_BUFFER_CHUNK_SIZE) ? mFileSize : IO_BUFFER_CHUNK_SIZE;
  145.         mFile->Read( mChunkMem, initialRead );
  146.         mFileBytesRead = initialRead;
  147.         mCurrentChunkBytesRead = 0;
  148.         mCurrentChunkBytes = initialRead;
  149.         
  150.         int bytesRemaining = mFileSize - mFileBytesRead;
  151.         if ( bytesRemaining > 0 ) {
  152.             SetPendingJob( mFile, (bytesRemaining > IO_BUFFER_CHUNK_SIZE) ? IO_BUFFER_CHUNK_SIZE : bytesRemaining );
  153.         }
  154.     }
  155.     
  156.     /*
  157.     ================
  158.     ChunkBuffer::End
  159.     ================
  160.     */
  161.     void End() { 
  162.     }
  163.     
  164.     /*
  165.     ================
  166.     ChunkBuffer::Advance
  167.     ================
  168.     */
  169.     int Advance( byte *chunkMem ) {
  170.         int readAmt = 0;
  171.         GetPendingJobResults( chunkMem, readAmt );
  172.         mFileBytesRead+=readAmt;
  173.         
  174.         int bytesRemaining = mFileSize - mFileBytesRead;
  175.         if ( bytesRemaining > 0 ) {
  176.             SetPendingJob( mFile, (bytesRemaining > IO_BUFFER_CHUNK_SIZE) ? IO_BUFFER_CHUNK_SIZE : bytesRemaining );
  177.         }
  178.         
  179.         return readAmt;
  180.     }
  181.     
  182.     /*
  183.     ================
  184.     ChunkBuffer::Read
  185.     ================
  186.     */
  187.     int Read( byte *dest, int size ) {
  188.         int bytesRem = mFileSize - mBytesRead;
  189.         
  190.         if ( size > bytesRem ) {
  191.             size = bytesRem;
  192.         }
  193.         
  194.         if ( !size ) {
  195.             return 0;
  196.         }
  197.  
  198.         byte *writePos = dest;
  199.         int cnt = size;
  200.         
  201.         while ( cnt ) {
  202.             if ( mCurrentChunkBytesRead >= mCurrentChunkBytes ) {
  203.                 mCurrentChunkBytes = Advance( mChunkMem );
  204.                 mCurrentChunkBytesRead = 0;
  205.             }
  206.             
  207.             int chunkBytesRemaining = mCurrentChunkBytes - mCurrentChunkBytesRead;
  208.             int toRead = (cnt > chunkBytesRemaining) ? chunkBytesRemaining : cnt;
  209.             
  210.             byte *readPos = &mChunkMem[mCurrentChunkBytesRead];
  211.             
  212.             memcpy( writePos, readPos, toRead );
  213.             
  214.             cnt-=toRead;
  215.             mCurrentChunkBytesRead+=toRead;
  216.             writePos+=toRead;
  217.         }
  218.         
  219.         mBytesRead+=size;        
  220.         return size;
  221.     }
  222. }
  223.  
  224. /*
  225. ================
  226. LexerIOWrapper::LexerIOWrapper
  227. ================
  228. */
  229. LexerIOWrapper::LexerIOWrapper() {
  230.     file = 0;    
  231.     offset = 0;
  232.     size = 0;
  233.     memory = 0;
  234. }
  235.  
  236. /*
  237. ================
  238. LexerIOWrapper::InitFromMemory
  239. ================
  240. */
  241. void LexerIOWrapper::InitFromMemory(char const * const ptr, int length) {
  242.     file = 0;    
  243.     offset = 0;
  244.     size = length;
  245.     memory = (char *)ptr;
  246. }
  247.  
  248. /*
  249. ================
  250. LexerIOWrapper::OpenFile
  251. ================
  252. */
  253. bool LexerIOWrapper::OpenFile(char const *filename, bool OSPath) {
  254.     if ( OSPath ) {
  255.         file = idLib::fileSystem->OpenExplicitFileRead( filename );
  256.     } else {
  257.         file = idLib::fileSystem->OpenFileRead( filename );
  258.     }
  259.     
  260.     if ( !file ) {
  261.         return false;
  262.     }
  263.     
  264.     ChunkBuffer::Begin( file );
  265.     
  266.     return true;
  267. }
  268.  
  269. /*
  270. ================
  271. LexerIOWrapper::Length
  272. ================
  273. */
  274. int LexerIOWrapper::Length() {
  275.     if ( file ) {
  276.         return ChunkBuffer::Length();
  277.     }
  278.     return size;
  279. }
  280.  
  281. /*
  282. ================
  283. LexerIOWrapper::Tell
  284. ================
  285. */
  286. int LexerIOWrapper::Tell() {
  287.     if ( file ) {
  288.         return ChunkBuffer::BytesRead();
  289.     }
  290.     return offset;
  291. }
  292.  
  293. /*
  294. ================
  295. LexerIOWrapper::Seek
  296. ================
  297. */
  298. void LexerIOWrapper::Seek( int loc, int mode ) { 
  299.     if ( file ) {
  300.         if ( loc != 0 || mode != FS_SEEK_SET ) {
  301.             common->Error( "lol\n" );
  302.         }
  303.         file->Seek( 0, FS_SEEK_SET );
  304.         ChunkBuffer::Begin( file );
  305.         return;
  306.     }
  307.     if ( mode == FS_SEEK_SET ) {
  308.         offset = loc;
  309.     } else {
  310.         common->Error( "lol" );
  311.     }
  312. }
  313.  
  314. /*
  315. ================
  316. LexerIOWrapper::Read
  317. ================
  318. */
  319. void LexerIOWrapper::Read( void *dest, int s ) {
  320.     if ( file ) {
  321.         ChunkBuffer::Read( (byte*)dest, s );
  322.         return;
  323.     }
  324.     char *d = (char *)dest;
  325.     char *dEnd = d + (((s + offset) > size) ? (size - offset) : (s));
  326.     while ( d < dEnd ) {
  327.         *d = memory[offset];
  328.         ++d;
  329.         ++offset;
  330.     }
  331. }
  332.  
  333. /*
  334. ================
  335. LexerIOWrapper::Close
  336. ================
  337. */
  338. void LexerIOWrapper::Close() {
  339.     if ( file ) {
  340.         ChunkBuffer::End();
  341.         idLib::fileSystem->CloseFile(file);
  342.         return;
  343.     }
  344. }
  345.  
  346. /*
  347. ================
  348. LexerIOWrapper::IsLoaded
  349. ================
  350. */
  351. int LexerIOWrapper::IsLoaded() {
  352.     if ( file || memory ) {
  353.         return 1;
  354.     }
  355.     return 0;
  356. }
  357.  
  358. /*
  359. ================
  360. Lexer::BeginLevelLoad
  361. ================
  362. */
  363. void Lexer::BeginLevelLoad() {
  364.     InitIO();
  365. }
  366.  
  367. /*
  368. ================
  369. Lexer::EndLevelLoad
  370. ================
  371. */
  372. void Lexer::EndLevelLoad() {
  373.     ShutdownIO();
  374. }
  375.  
  376. /*
  377. ================
  378. ReadValue
  379. ================
  380. */
  381. template <typename type> inline type ReadValue(LexerIOWrapper *in) 
  382. { 
  383.     type ret; 
  384.     
  385.     in->Read(&ret, sizeof(type));
  386.     return ret;
  387. }
  388.  
  389. /*
  390. ================
  391. ReadValue
  392. specialization read for idStr's
  393. ================
  394. */
  395. template <> inline idStr ReadValue(LexerIOWrapper *in) 
  396. { 
  397.     char c;
  398.     idStr str;
  399.  
  400.     in->Read(&c, 1);
  401.     while(c != '\0')
  402.     {
  403.         str.Append(c);
  404.         in->Read(&c, 1);
  405.     }
  406.  
  407.     str.Append(c);
  408.  
  409.     return str;
  410. }
  411.  
  412. #endif
  413.  
  414. #define PUNCTABLE
  415.  
  416. //longer punctuations first
  417. punctuation_t default_punctuations[] = {
  418.     //binary operators
  419.     {">>=",P_RSHIFT_ASSIGN},
  420.     {"<<=",P_LSHIFT_ASSIGN},
  421.     //
  422.     {"...",P_PARMS},
  423.     //define merge operator
  424.     {"##",P_PRECOMPMERGE},                // pre-compiler
  425.     //logic operators
  426.     {"&&",P_LOGIC_AND},                    // pre-compiler
  427.     {"||",P_LOGIC_OR},                    // pre-compiler
  428.     {">=",P_LOGIC_GEQ},                    // pre-compiler
  429.     {"<=",P_LOGIC_LEQ},                    // pre-compiler
  430.     {"==",P_LOGIC_EQ},                    // pre-compiler
  431.     {"!=",P_LOGIC_UNEQ},                // pre-compiler
  432.     //arithmatic operators
  433.     {"*=",P_MUL_ASSIGN},
  434.     {"/=",P_DIV_ASSIGN},
  435.     {"%=",P_MOD_ASSIGN},
  436.     {"+=",P_ADD_ASSIGN},
  437.     {"-=",P_SUB_ASSIGN},
  438.     {"++",P_INC},
  439.     {"--",P_DEC},
  440.     //binary operators
  441.     {"&=",P_BIN_AND_ASSIGN},
  442.     {"|=",P_BIN_OR_ASSIGN},
  443.     {"^=",P_BIN_XOR_ASSIGN},
  444.     {">>",P_RSHIFT},                    // pre-compiler
  445.     {"<<",P_LSHIFT},                    // pre-compiler
  446.     //reference operators
  447.     {"->",P_POINTERREF},
  448.     //C++
  449.     {"::",P_CPP1},
  450.     {".*",P_CPP2},
  451.     //arithmatic operators
  452.     {"*",P_MUL},                        // pre-compiler
  453.     {"/",P_DIV},                        // pre-compiler
  454.     {"%",P_MOD},                        // pre-compiler
  455.     {"+",P_ADD},                        // pre-compiler
  456.     {"-",P_SUB},                        // pre-compiler
  457.     {"=",P_ASSIGN},
  458.     //binary operators
  459.     {"&",P_BIN_AND},                    // pre-compiler
  460.     {"|",P_BIN_OR},                        // pre-compiler
  461.     {"^",P_BIN_XOR},                    // pre-compiler
  462.     {"~",P_BIN_NOT},                    // pre-compiler
  463.     //logic operators
  464.     {"!",P_LOGIC_NOT},                    // pre-compiler
  465.     {">",P_LOGIC_GREATER},                // pre-compiler
  466.     {"<",P_LOGIC_LESS},                    // pre-compiler
  467.     //reference operator
  468.     {".",P_REF},
  469.     //seperators
  470.     {",",P_COMMA},                        // pre-compiler
  471.     {";",P_SEMICOLON},
  472.     //label indication
  473.     {":",P_COLON},                        // pre-compiler
  474.     //if statement
  475.     {"?",P_QUESTIONMARK},                // pre-compiler
  476.     //embracements
  477.     {"(",P_PARENTHESESOPEN},            // pre-compiler
  478.     {")",P_PARENTHESESCLOSE},            // pre-compiler
  479.     {"{",P_BRACEOPEN},                    // pre-compiler
  480.     {"}",P_BRACECLOSE},                    // pre-compiler
  481.     {"[",P_SQBRACKETOPEN},
  482.     {"]",P_SQBRACKETCLOSE},
  483.     //
  484.     {"\\",P_BACKSLASH},
  485.     //precompiler operator
  486.     {"#",P_PRECOMP},                    // pre-compiler
  487.     {"$",P_DOLLAR},
  488. // RAVEN BEGIN
  489.     {"í",P_INVERTED_PLING},
  490.     {"┐",P_INVERTED_QUERY},
  491. // RAVEN END
  492.     {NULL, 0}
  493. };
  494.  
  495. int default_punctuationtable[256];
  496. int default_nextpunctuation[sizeof(default_punctuations) / sizeof(punctuation_t)];
  497. int default_setup;
  498.  
  499. // RAVEN BEGIN
  500. // jsinger: changed to be Lexer instead of idLexer so that we have the ability to read binary files
  501. char Lexer::baseFolder[ 256 ];
  502.  
  503. // Added this to allow easy changing of the suffix that signifies a binary file
  504. idStr const        Lexer::sCompiledFileSuffix("c");
  505. // RAVEN END
  506.  
  507. /*
  508. ================
  509. idLexer::CreatePunctuationTable
  510. ================
  511. */
  512. void idLexer::CreatePunctuationTable( const punctuation_t *punctuations ) {
  513.     int i, n, lastp;
  514.     const punctuation_t *p, *newp;
  515.  
  516.     //get memory for the table
  517.     if ( punctuations == default_punctuations ) {
  518.         idLexer::punctuationtable = default_punctuationtable;
  519.         idLexer::nextpunctuation = default_nextpunctuation;
  520.         if ( default_setup ) {
  521.             return;
  522.         }
  523.         default_setup = true;
  524.         i = sizeof(default_punctuations) / sizeof(punctuation_t);
  525.     }
  526.     else {
  527.         if ( !idLexer::punctuationtable || idLexer::punctuationtable == default_punctuationtable ) {
  528. //RAVEN BEGIN
  529. //amccarthy: Added memory allocation tag
  530.             idLexer::punctuationtable = (int *) Mem_Alloc(256 * sizeof(int),MA_LEXER);
  531. //RAVEN END
  532.         }
  533.         if ( idLexer::nextpunctuation && idLexer::nextpunctuation != default_nextpunctuation ) {
  534.             Mem_Free( idLexer::nextpunctuation );
  535.         }
  536.         for (i = 0; punctuations[i].p; i++) {
  537.         }
  538. //RAVEN BEGIN
  539. //amccarthy: Added memory allocation tag
  540.         idLexer::nextpunctuation = (int *) Mem_Alloc(i * sizeof(int),MA_LEXER);
  541. //RAVEN END
  542.     }
  543.     memset(idLexer::punctuationtable, 0xFF, 256 * sizeof(int));
  544.     memset(idLexer::nextpunctuation, 0xFF, i * sizeof(int));
  545.     //add the punctuations in the list to the punctuation table
  546.     for (i = 0; punctuations[i].p; i++) {
  547.         newp = &punctuations[i];
  548.         lastp = -1;
  549.         //sort the punctuations in this table entry on length (longer punctuations first)
  550.         for (n = idLexer::punctuationtable[(unsigned int) newp->p[0]]; n >= 0; n = idLexer::nextpunctuation[n] ) {
  551.             p = &punctuations[n];
  552.             if (strlen(p->p) < strlen(newp->p)) {
  553.                 idLexer::nextpunctuation[i] = n;
  554.                 if (lastp >= 0) {
  555.                     idLexer::nextpunctuation[lastp] = i;
  556.                 }
  557.                 else {
  558.                     idLexer::punctuationtable[(unsigned int) newp->p[0]] = i;
  559.                 }
  560.                 break;
  561.             }
  562.             lastp = n;
  563.         }
  564.         if (n < 0) {
  565.             idLexer::nextpunctuation[i] = -1;
  566.             if (lastp >= 0) {
  567.                 idLexer::nextpunctuation[lastp] = i;
  568.             }
  569.             else {
  570.                 idLexer::punctuationtable[(unsigned int) newp->p[0]] = i;
  571.             }
  572.         }
  573.     }
  574. }
  575.  
  576. /*
  577. ================
  578. idLexer::GetPunctuationFromId
  579. ================
  580. */
  581. const char *idLexer::GetPunctuationFromId( int id ) {
  582.     int i;
  583.  
  584.     for (i = 0; idLexer::punctuations[i].p; i++) {
  585.         if ( idLexer::punctuations[i].n == id ) {
  586.             return idLexer::punctuations[i].p;
  587.         }
  588.     }
  589.     return "unkown punctuation";
  590. }
  591.  
  592. /*
  593. ================
  594. idLexer::GetPunctuationId
  595. ================
  596. */
  597. int idLexer::GetPunctuationId( const char *p ) {
  598.     int i;
  599.  
  600.     for (i = 0; idLexer::punctuations[i].p; i++) {
  601.         if ( !idStr::Cmp(idLexer::punctuations[i].p, p) ) {
  602.             return idLexer::punctuations[i].n;
  603.         }
  604.     }
  605.     return 0;
  606. }
  607.  
  608. /*
  609. ================
  610. idLexer::Error
  611. ================
  612. */
  613.  
  614. void idLexer::Error( const char *str, ... ) {
  615.     char text[MAX_STRING_CHARS];
  616.     va_list ap;
  617.  
  618.     hadError = true;
  619.  
  620.     if ( idLexer::flags & LEXFL_NOERRORS ) {
  621.         return;
  622.     }
  623.  
  624.     va_start(ap, str);
  625.     vsprintf(text, str, ap);
  626.     va_end(ap);
  627.  
  628.     if ( idLexer::flags & LEXFL_NOFATALERRORS ) {
  629.         idLib::common->Warning( "file %s, line %d: %s", idLexer::filename.c_str(), idLexer::line, text );
  630.     } else {
  631.         idLib::common->Error( "file %s, line %d: %s", idLexer::filename.c_str(), idLexer::line, text );
  632.     }
  633. }
  634.  
  635. /*
  636. ================
  637. idLexer::Warning
  638. ================
  639. */
  640. void idLexer::Warning( const char *str, ... ) {
  641.     char text[MAX_STRING_CHARS];
  642.     va_list ap;
  643.  
  644.     if ( idLexer::flags & LEXFL_NOWARNINGS ) {
  645.         return;
  646.     }
  647.  
  648.     va_start( ap, str );
  649.     vsprintf( text, str, ap );
  650.     va_end( ap );
  651.     idLib::common->Warning( "file %s, line %d: %s", idLexer::filename.c_str(), idLexer::line, text );
  652. }
  653.  
  654. /*
  655. ================
  656. idLexer::SetPunctuations
  657. ================
  658. */
  659. void idLexer::SetPunctuations( const punctuation_t *p ) {
  660. #ifdef PUNCTABLE
  661.     if (p) {
  662.         idLexer::CreatePunctuationTable( p );
  663.     }
  664.     else {
  665.         idLexer::CreatePunctuationTable( default_punctuations );
  666.     }
  667. #endif //PUNCTABLE
  668.     if (p) {
  669.         idLexer::punctuations = p;
  670.     }
  671.     else {
  672.         idLexer::punctuations = default_punctuations;
  673.     }
  674. }
  675.  
  676. /*
  677. ================
  678. idLexer::ReadWhiteSpace
  679.  
  680. Reads spaces, tabs, C-like comments etc.
  681. When a newline character is found the scripts line counter is increased.
  682. ================
  683. */
  684. int idLexer::ReadWhiteSpace( void ) {
  685.     while(1) {
  686.         // skip white space
  687. // RAVEN BEGIN
  688.         while(( byte )*idLexer::script_p <= ' ') {
  689. // RAVEN END
  690.             if (!*idLexer::script_p) {
  691.                 return 0;
  692.             }
  693.             if (*idLexer::script_p == '\n') {
  694.                 idLexer::line++;
  695.             }
  696.             idLexer::script_p++;
  697.         }
  698.         // skip comments
  699.         if (*idLexer::script_p == '/') {
  700.             // comments //
  701.             if (*(idLexer::script_p+1) == '/') {
  702.                 idLexer::script_p++;
  703.                 do {
  704.                     idLexer::script_p++;
  705.                     if ( !*idLexer::script_p ) {
  706.                         return 0;
  707.                     }
  708.                 }
  709.                 while( *idLexer::script_p != '\n' );
  710.                 idLexer::line++;
  711.                 idLexer::script_p++;
  712.                 if ( !*idLexer::script_p ) {
  713.                     return 0;
  714.                 }
  715.                 continue;
  716.             }
  717.             // comments /* */
  718.             else if (*(idLexer::script_p+1) == '*') {
  719.                 idLexer::script_p++;
  720.                 while( 1 ) {
  721.                     idLexer::script_p++;
  722.                     if ( !*idLexer::script_p ) {
  723.                         return 0;
  724.                     }
  725.                     if ( *idLexer::script_p == '\n' ) {
  726.                         idLexer::line++;
  727.                     }
  728.                     else if ( *idLexer::script_p == '/' ) {
  729.                         if ( *(idLexer::script_p-1) == '*' ) {
  730.                             break;
  731.                         }
  732.                         if ( *(idLexer::script_p+1) == '*' ) {
  733.                             idLexer::Warning( "nested comment" );
  734.                         }
  735.                     }
  736.                 }
  737.                 idLexer::script_p++;
  738.                 if ( !*idLexer::script_p ) {
  739.                     return 0;
  740.                 }
  741.                 idLexer::script_p++;
  742.                 if ( !*idLexer::script_p ) {
  743.                     return 0;
  744.                 }
  745.                 continue;
  746.             }
  747.         }
  748.         break;
  749.     }
  750.     return 1;
  751. }
  752.  
  753. /*
  754. ================
  755. idLexer::ReadEscapeCharacter
  756. ================
  757. */
  758. int idLexer::ReadEscapeCharacter( char *ch ) {
  759.     int c, val, i;
  760.  
  761.     // step over the leading '\\'
  762.     idLexer::script_p++;
  763.     // determine the escape character
  764.     switch(*idLexer::script_p) {
  765.         case '\\': c = '\\'; break;
  766.         case 'n': c = '\n'; break;
  767.         case 'r': c = '\r'; break;
  768.         case 't': c = '\t'; break;
  769.         case 'v': c = '\v'; break;
  770.         case 'b': c = '\b'; break;
  771.         case 'f': c = '\f'; break;
  772.         case 'a': c = '\a'; break;
  773.         case '\'': c = '\''; break;
  774.         case '\"': c = '\"'; break;
  775.         case '\?': c = '\?'; break;
  776.         case 'x':
  777.         {
  778.             idLexer::script_p++;
  779.             for (i = 0, val = 0; ; i++, idLexer::script_p++) {
  780.                 c = *idLexer::script_p;
  781.                 if (c >= '0' && c <= '9')
  782.                     c = c - '0';
  783.                 else if (c >= 'A' && c <= 'Z')
  784.                     c = c - 'A' + 10;
  785.                 else if (c >= 'a' && c <= 'z')
  786.                     c = c - 'a' + 10;
  787.                 else
  788.                     break;
  789.                 val = (val << 4) + c;
  790.             }
  791.             idLexer::script_p--;
  792.             if (val > 0xFF) {
  793.                 idLexer::Warning( "too large value in escape character" );
  794.                 val = 0xFF;
  795.             }
  796.             c = val;
  797.             break;
  798.         }
  799.         default: //NOTE: decimal ASCII code, NOT octal
  800.         {
  801.             if (*idLexer::script_p < '0' || *idLexer::script_p > '9') {
  802.                 idLexer::Error("unknown escape char");
  803.             }
  804.             for (i = 0, val = 0; ; i++, idLexer::script_p++) {
  805.                 c = *idLexer::script_p;
  806.                 if (c >= '0' && c <= '9')
  807.                     c = c - '0';
  808.                 else
  809.                     break;
  810.                 val = val * 10 + c;
  811.             }
  812.             idLexer::script_p--;
  813.             if (val > 0xFF) {
  814.                 idLexer::Warning( "too large value in escape character" );
  815.                 val = 0xFF;
  816.             }
  817.             c = val;
  818.             break;
  819.         }
  820.     }
  821.     // step over the escape character or the last digit of the number
  822.     idLexer::script_p++;
  823.     // store the escape character
  824.     *ch = c;
  825.     // succesfully read escape character
  826.     return 1;
  827. }
  828.  
  829. /*
  830. ================
  831. idLexer::ReadString
  832.  
  833. Escape characters are interpretted.
  834. Reads two strings with only a white space between them as one string.
  835. ================
  836. */
  837. int idLexer::ReadString( idToken *token, int quote ) {
  838.     int tmpline;
  839.     const char *tmpscript_p;
  840.     char ch;
  841.  
  842.     if ( quote == '\"' ) {
  843.         token->type = TT_STRING;
  844.     } else {
  845.         token->type = TT_LITERAL;
  846.     }
  847.  
  848.     // leading quote
  849.     idLexer::script_p++;
  850.  
  851.     while(1) {
  852.         // if there is an escape character and escape characters are allowed
  853.         if (*idLexer::script_p == '\\' && !(idLexer::flags & LEXFL_NOSTRINGESCAPECHARS)) {
  854.             if ( !idLexer::ReadEscapeCharacter( &ch ) ) {
  855.                 return 0;
  856.             }
  857.             token->AppendDirty( ch );
  858.         }
  859.         // if a trailing quote
  860.         else if (*idLexer::script_p == quote) {
  861.             // step over the quote
  862.             idLexer::script_p++;
  863.             // if consecutive strings should not be concatenated
  864.             if ( (idLexer::flags & LEXFL_NOSTRINGCONCAT) &&
  865.                     (!(idLexer::flags & LEXFL_ALLOWBACKSLASHSTRINGCONCAT) || (quote != '\"')) ) {
  866.                 break;
  867.             }
  868.  
  869.             tmpscript_p = idLexer::script_p;
  870.             tmpline = idLexer::line;
  871.             // read white space between possible two consecutive strings
  872.             if ( !idLexer::ReadWhiteSpace() ) {
  873.                 idLexer::script_p = tmpscript_p;
  874.                 idLexer::line = tmpline;
  875.                 break;
  876.             }
  877.  
  878.             if ( idLexer::flags & LEXFL_NOSTRINGCONCAT ) {
  879.                 if ( *idLexer::script_p != '\\' ) {
  880.                     idLexer::script_p = tmpscript_p;
  881.                     idLexer::line = tmpline;
  882.                     break;
  883.                 }
  884.                 // step over the '\\'
  885.                 idLexer::script_p++;
  886.                 if ( !idLexer::ReadWhiteSpace() || ( *idLexer::script_p != quote ) ) {
  887.                     idLexer::Error( "expecting string after '\' terminated line" );
  888.                     return 0;
  889.                 }
  890.             }
  891.  
  892.             // if there's no leading qoute
  893.             if ( *idLexer::script_p != quote ) {
  894.                 idLexer::script_p = tmpscript_p;
  895.                 idLexer::line = tmpline;
  896.                 break;
  897.             }
  898.             // step over the new leading quote
  899.             idLexer::script_p++;
  900.         }
  901.         else {
  902.             if (*idLexer::script_p == '\0') {
  903.                 idLexer::Error( "missing trailing quote" );
  904.                 return 0;
  905.             }
  906.             if (*idLexer::script_p == '\n') {
  907.                 idLexer::Error( "newline inside string" );
  908.                 return 0;
  909.             }
  910.             token->AppendDirty( *idLexer::script_p++ );
  911.         }
  912.     }
  913.     token->data[token->len] = '\0';
  914.  
  915.     if ( token->type == TT_LITERAL ) {
  916.         if ( !(idLexer::flags & LEXFL_ALLOWMULTICHARLITERALS) ) {
  917.             if ( token->Length() != 1 ) {
  918.                 idLexer::Warning( "literal is not one character long" );
  919.             }
  920.         }
  921.         token->subtype = (*token)[0];
  922.     }
  923.     else {
  924.         // the sub type is the length of the string
  925.         token->subtype = token->Length();
  926.     }
  927.     return 1;
  928. }
  929.  
  930. /*
  931. ================
  932. idLexer::ReadName
  933. ================
  934. */
  935. int idLexer::ReadName( idToken *token ) {
  936.     char c;
  937.  
  938.     token->type = TT_NAME;
  939.     do {
  940.         token->AppendDirty( *idLexer::script_p++ );
  941.         c = *idLexer::script_p;
  942. // RAVEN BEGIN
  943.     } while ( idStr::CharIsAlpha( c ) || idStr::CharIsNumeric( c ) || c == '_' ||
  944. // RAVEN EBD
  945.                 // if treating all tokens as strings, don't parse '-' as a seperate token
  946.                 ((idLexer::flags & LEXFL_ONLYSTRINGS) && (c == '-')) ||
  947.                 // if special path name characters are allowed
  948.                 ((idLexer::flags & LEXFL_ALLOWPATHNAMES) && (c == '/' || c == '\\' || c == ':' || c == '.')) );
  949.     token->data[token->len] = '\0';
  950.     //the sub type is the length of the name
  951.     token->subtype = token->Length();
  952.     return 1;
  953. }
  954.  
  955. /*
  956. ================
  957. idLexer::CheckString
  958. ================
  959. */
  960. ID_INLINE int idLexer::CheckString( const char *str ) const {
  961.     int i;
  962.  
  963.     for ( i = 0; str[i]; i++ ) {
  964.         if ( idLexer::script_p[i] != str[i] ) {
  965.             return false;
  966.         }
  967.     }
  968.     return true;
  969. }
  970.  
  971. /*
  972. ================
  973. idLexer::ReadNumber
  974. ================
  975. */
  976. int idLexer::ReadNumber( idToken *token ) {
  977.     int i;
  978.     int dot;
  979.     char c, c2;
  980.  
  981.     token->type = TT_NUMBER;
  982.     token->subtype = 0;
  983.     token->intvalue = 0;
  984.     token->floatvalue = 0;
  985.  
  986.     c = *idLexer::script_p;
  987.     c2 = *(idLexer::script_p + 1);
  988.  
  989.     if ( c == '0' && c2 != '.' ) {
  990.         // check for a hexadecimal number
  991.         if ( c2 == 'x' || c2 == 'X' ) {
  992.             token->AppendDirty( *idLexer::script_p++ );
  993.             token->AppendDirty( *idLexer::script_p++ );
  994.             c = *idLexer::script_p;
  995.             while((c >= '0' && c <= '9') ||
  996.                         (c >= 'a' && c <= 'f') ||
  997.                         (c >= 'A' && c <= 'F')) {
  998.                 token->AppendDirty( c );
  999.                 c = *(++idLexer::script_p);
  1000.             }
  1001.             token->subtype = TT_HEX | TT_INTEGER;
  1002.         }
  1003.         // check for a binary number
  1004.         else if ( c2 == 'b' || c2 == 'B' ) {
  1005.             token->AppendDirty( *idLexer::script_p++ );
  1006.             token->AppendDirty( *idLexer::script_p++ );
  1007.             c = *idLexer::script_p;
  1008.             while( c == '0' || c == '1' ) {
  1009.                 token->AppendDirty( c );
  1010.                 c = *(++idLexer::script_p);
  1011.             }
  1012.             token->subtype = TT_BINARY | TT_INTEGER;
  1013.         }
  1014.         // its an octal number
  1015.         else {
  1016.             token->AppendDirty( *idLexer::script_p++ );
  1017.             c = *idLexer::script_p;
  1018.             while( c >= '0' && c <= '7' ) {
  1019.                 token->AppendDirty( c );
  1020.                 c = *(++idLexer::script_p);
  1021.             }
  1022.             token->subtype = TT_OCTAL | TT_INTEGER;
  1023.         }
  1024.     }
  1025.     else {
  1026.         // decimal integer or floating point number or ip address
  1027.         dot = 0;
  1028.         while( 1 ) {
  1029.             if ( c >= '0' && c <= '9' ) {
  1030.             }
  1031.             else if ( c == '.' ) {
  1032.                 dot++;
  1033.             }
  1034.             else {
  1035.                 break;
  1036.             }
  1037.             token->AppendDirty( c );
  1038.             c = *(++idLexer::script_p);
  1039.         }
  1040.         if( c == 'e' && dot == 0) {
  1041.             //We have scientific notation without a decimal point
  1042.             dot++;
  1043.         }
  1044.         // if a floating point number
  1045.         if ( dot == 1 ) {
  1046.             token->subtype = TT_DECIMAL | TT_FLOAT;
  1047.             // check for floating point exponent
  1048.             if ( c == 'e' ) {
  1049.                 //Append the e so that GetFloatValue code works
  1050.                 token->AppendDirty( c );
  1051.                 c = *(++idLexer::script_p);
  1052.                 if ( c == '-' ) {
  1053.                     token->AppendDirty( c );
  1054.                     c = *(++idLexer::script_p);
  1055.                 }
  1056.                 else if ( c == '+' ) {
  1057.                     token->AppendDirty( c );
  1058.                     c = *(++idLexer::script_p);
  1059.                 }
  1060.                 while( c >= '0' && c <= '9' ) {
  1061.                     token->AppendDirty( c );
  1062.                     c = *(++idLexer::script_p);
  1063.                 }
  1064.             }
  1065.             // check for floating point exception infinite 1.#INF or indefinite 1.#IND or NaN
  1066.             else if ( c == '#' ) {
  1067.                 c2 = 4;
  1068.                 if ( CheckString( "INF" ) ) {
  1069.                     token->subtype |= TT_INFINITE;
  1070.                 }
  1071.                 else if ( CheckString( "IND" ) ) {
  1072.                     token->subtype |= TT_INDEFINITE;
  1073.                 }
  1074.                 else if ( CheckString( "NAN" ) ) {
  1075.                     token->subtype |= TT_NAN;
  1076.                 }
  1077.                 else if ( CheckString( "QNAN" ) ) {
  1078.                     token->subtype |= TT_NAN;
  1079.                     c2++;
  1080.                 }
  1081.                 else if ( CheckString( "SNAN" ) ) {
  1082.                     token->subtype |= TT_NAN;
  1083.                     c2++;
  1084.                 }
  1085.                 for ( i = 0; i < c2; i++ ) {
  1086.                     token->AppendDirty( c );
  1087.                     c = *(++idLexer::script_p);
  1088.                 }
  1089.                 while( c >= '0' && c <= '9' ) {
  1090.                     token->AppendDirty( c );
  1091.                     c = *(++idLexer::script_p);
  1092.                 }
  1093.                 if ( !(idLexer::flags & LEXFL_ALLOWFLOATEXCEPTIONS) ) {
  1094.                     token->AppendDirty( 0 );    // zero terminate for c_str
  1095.                     idLexer::Error( "parsed %s", token->c_str() );
  1096.                 }
  1097.             }
  1098.         }
  1099.         else if ( dot > 1 ) {
  1100.             if ( !( idLexer::flags & LEXFL_ALLOWIPADDRESSES ) ) {
  1101.                 idLexer::Error( "more than one dot in number" );
  1102.                 return 0;
  1103.             }
  1104.             if ( dot != 3 ) {
  1105.                 idLexer::Error( "ip address should have three dots" );
  1106.                 return 0;
  1107.             }
  1108.             token->subtype = TT_IPADDRESS;
  1109.         }
  1110.         else {
  1111.             token->subtype = TT_DECIMAL | TT_INTEGER;
  1112.         }
  1113.     }
  1114.  
  1115.     if ( token->subtype & TT_FLOAT ) {
  1116.         if ( c > ' ' ) {
  1117.             // single-precision: float
  1118.             if ( c == 'f' || c == 'F' ) {
  1119.                 token->subtype |= TT_SINGLE_PRECISION;
  1120.                 idLexer::script_p++;
  1121.             }
  1122.             // extended-precision: long double
  1123.             else if ( c == 'l' || c == 'L' ) {
  1124.                 token->subtype |= TT_EXTENDED_PRECISION;
  1125.                 idLexer::script_p++;
  1126.             }
  1127.             // default is double-precision: double
  1128.             else {
  1129.                 token->subtype |= TT_DOUBLE_PRECISION;
  1130.             }
  1131.         }
  1132.         else {
  1133.             token->subtype |= TT_DOUBLE_PRECISION;
  1134.         }
  1135.     }
  1136.     else if ( token->subtype & TT_INTEGER ) {
  1137.         if ( c > ' ' ) {
  1138.             // default: signed long
  1139.             for ( i = 0; i < 2; i++ ) {
  1140.                 // long integer
  1141.                 if ( c == 'l' || c == 'L' ) {
  1142.                     token->subtype |= TT_LONG;
  1143.                 }
  1144.                 // unsigned integer
  1145.                 else if ( c == 'u' || c == 'U' ) {
  1146.                     token->subtype |= TT_UNSIGNED;
  1147.                 }
  1148.                 else {
  1149.                     break;
  1150.                 }
  1151.                 c = *(++idLexer::script_p);
  1152.             }
  1153.         }
  1154.     }
  1155.     else if ( token->subtype & TT_IPADDRESS ) {
  1156.         if ( c == ':' ) {
  1157.             token->AppendDirty( c );
  1158.             c = *(++idLexer::script_p);
  1159.             while( c >= '0' && c <= '9' ) {
  1160.                 token->AppendDirty( c );
  1161.                 c = *(++idLexer::script_p);
  1162.             }
  1163.             token->subtype |= TT_IPPORT;
  1164.         }
  1165.     }
  1166.     token->data[token->len] = '\0';
  1167.     return 1;
  1168. }
  1169.  
  1170. /*
  1171. ================
  1172. idLexer::ReadPunctuation
  1173. ================
  1174. */
  1175. int idLexer::ReadPunctuation( idToken *token ) {
  1176.     int l, n, i;
  1177.     char *p;
  1178.     const punctuation_t *punc;
  1179.  
  1180. #ifdef PUNCTABLE
  1181.     for (n = idLexer::punctuationtable[(unsigned int)*(idLexer::script_p)]; n >= 0; n = idLexer::nextpunctuation[n])
  1182.     {
  1183.         punc = &(idLexer::punctuations[n]);
  1184. #else
  1185.     int i;
  1186.  
  1187.     for (i = 0; idLexer::punctuations[i].p; i++) {
  1188.         punc = &idLexer::punctuations[i];
  1189. #endif
  1190.         p = punc->p;
  1191.         // check for this punctuation in the script
  1192.         for ( l = 0; p[l] && idLexer::script_p[l]; l++ ) {
  1193.             if ( idLexer::script_p[l] != p[l] ) {
  1194.                 break;
  1195.             }
  1196.         }
  1197.         if ( !p[l] ) {
  1198.             //
  1199.             token->EnsureAlloced( l+1, false );
  1200.             for ( i = 0; i <= l; i++ ) {
  1201.                 token->data[i] = p[i];
  1202.             }
  1203.             token->len = l;
  1204.             //
  1205.             idLexer::script_p += l;
  1206.             token->type = TT_PUNCTUATION;
  1207.             // sub type is the punctuation id
  1208.             token->subtype = punc->n;
  1209.             return 1;
  1210.         }
  1211.     }
  1212.     return 0;
  1213. }
  1214.  
  1215. /*
  1216. ================
  1217. idLexer::ReadToken
  1218. ================
  1219. */
  1220. int idLexer::ReadToken( idToken *token ) {
  1221.     int c;
  1222.  
  1223.     if ( !loaded ) {
  1224. // RAVEN BEGIN
  1225. #ifndef _XENON
  1226. // nrausch: should not be an error on xenon since it prevents the precache stuff from working
  1227.         idLib::common->Error( "idLexer::ReadToken: no file loaded" );
  1228. #else
  1229.         idLib::common->Warning( "idLexer::ReadToken: no file loaded" );
  1230. #endif
  1231. // RAVEN END
  1232.         return 0;
  1233.     }
  1234.  
  1235.     // if there is a token available (from unreadToken)
  1236.     if ( tokenavailable ) {
  1237.         tokenavailable = 0;
  1238.         *token = idLexer::token;
  1239.         return 1;
  1240.     }
  1241.     // save script pointer
  1242.     lastScript_p = script_p;
  1243.     // save line counter
  1244.     lastline = line;
  1245.     // clear the token stuff
  1246.     token->data[0] = '\0';
  1247.     token->len = 0;
  1248.     // start of the white space
  1249.     whiteSpaceStart_p = script_p;
  1250.     token->whiteSpaceStart_p = script_p;
  1251.     // read white space before token
  1252.     if ( !ReadWhiteSpace() ) {
  1253.         return 0;
  1254.     }
  1255.     // end of the white space
  1256.     idLexer::whiteSpaceEnd_p = script_p;
  1257.     token->whiteSpaceEnd_p = script_p;
  1258.     // line the token is on
  1259.     token->line = line;
  1260.     // number of lines crossed before token
  1261.     token->linesCrossed = line - lastline;
  1262.     // clear token flags
  1263.     token->flags = 0;
  1264.  
  1265.     c = *idLexer::script_p;
  1266.  
  1267.     // if we're keeping everything as whitespace deliminated strings
  1268.     if ( idLexer::flags & LEXFL_ONLYSTRINGS ) {
  1269.         // if there is a leading quote
  1270.         if ( c == '\"' || c == '\'' ) {
  1271.             if (!idLexer::ReadString( token, c )) {
  1272.                 return 0;
  1273.             }
  1274.         } else if ( !idLexer::ReadName( token ) ) {
  1275.             return 0;
  1276.         }
  1277.     }
  1278.     // if there is a number
  1279.     else if ( (c >= '0' && c <= '9') ||
  1280.             (c == '.' && (*(idLexer::script_p + 1) >= '0' && *(idLexer::script_p + 1) <= '9')) ) {
  1281.         if ( !idLexer::ReadNumber( token ) ) {
  1282.             return 0;
  1283.         }
  1284.         // if names are allowed to start with a number
  1285.         if ( idLexer::flags & LEXFL_ALLOWNUMBERNAMES ) {
  1286.             c = *idLexer::script_p;
  1287.             if ( idStr::CharIsAlpha( c ) || idStr::CharIsNumeric( c ) || c == '_' ) {
  1288.                 if ( !idLexer::ReadName( token ) ) {
  1289.                     return 0;
  1290.                 }
  1291.             }
  1292.         }
  1293.     }
  1294.     // if there is a leading quote
  1295.     else if ( c == '\"' || c == '\'' ) {
  1296.         if (!idLexer::ReadString( token, c )) {
  1297.             return 0;
  1298.         }
  1299.     }
  1300.     // if there is a name
  1301. // RAVEN BEGIN
  1302.     else if ( idStr::CharIsAlpha( c ) || idStr::CharIsNumeric( c ) || c == '_' ) {
  1303. // RAVEN END
  1304.         if ( !idLexer::ReadName( token ) ) {
  1305.             return 0;
  1306.         }
  1307.     }
  1308.     // names may also start with a slash when pathnames are allowed
  1309.     else if ( ( idLexer::flags & LEXFL_ALLOWPATHNAMES ) && ( (c == '/' || c == '\\') || c == '.' ) ) {
  1310.         if ( !idLexer::ReadName( token ) ) {
  1311.             return 0;
  1312.         }
  1313.     }
  1314.     // check for punctuations
  1315.     else if ( !idLexer::ReadPunctuation( token ) ) {
  1316.         idLexer::Error( "unknown punctuation %c", c );
  1317.         return 0;
  1318.     }
  1319. // RAVEN BEGIN
  1320. // jsinger: added to write out the binary version of this token when binary writes have been turned on
  1321.     WriteBinaryToken(token);
  1322.  
  1323. // RAVEN END
  1324.     // succesfully read a token
  1325.     return 1;
  1326. }
  1327.  
  1328. /*
  1329. ================
  1330. idLexer::ExpectTokenString
  1331. ================
  1332. */
  1333. int idLexer::ExpectTokenString( const char *string ) {
  1334.     idToken token;
  1335.  
  1336.     if (!idLexer::ReadToken( &token )) {
  1337.         idLexer::Error( "couldn't find expected '%s'", string );
  1338.         return 0;
  1339.     }
  1340.     if ( token != string ) {
  1341.         idLexer::Error( "expected '%s' but found '%s'", string, token.c_str() );
  1342.         return 0;
  1343.     }
  1344.     return 1;
  1345. }
  1346.  
  1347. /*
  1348. ================
  1349. idLexer::ExpectTokenType
  1350. ================
  1351. */
  1352. int idLexer::ExpectTokenType( int type, int subtype, idToken *token ) {
  1353.     idStr str;
  1354.  
  1355.     if ( !idLexer::ReadToken( token ) ) {
  1356.         idLexer::Error( "couldn't read expected token" );
  1357.         return 0;
  1358.     }
  1359.  
  1360.     if ( token->type != type ) {
  1361.         switch( type ) {
  1362.             case TT_STRING: str = "string"; break;
  1363.             case TT_LITERAL: str = "literal"; break;
  1364.             case TT_NUMBER: str = "number"; break;
  1365.             case TT_NAME: str = "name"; break;
  1366.             case TT_PUNCTUATION: str = "punctuation"; break;
  1367.             default: str = "unknown type"; break;
  1368.         }
  1369.         idLexer::Error( "expected a %s but found '%s'", str.c_str(), token->c_str() );
  1370.         return 0;
  1371.     }
  1372.     if ( token->type == TT_NUMBER ) {
  1373.         if ( (token->subtype & subtype) != subtype ) {
  1374.             str.Clear();
  1375.             if ( subtype & TT_DECIMAL ) str = "decimal ";
  1376.             if ( subtype & TT_HEX ) str = "hex ";
  1377.             if ( subtype & TT_OCTAL ) str = "octal ";
  1378.             if ( subtype & TT_BINARY ) str = "binary ";
  1379.             if ( subtype & TT_UNSIGNED ) str += "unsigned ";
  1380.             if ( subtype & TT_LONG ) str += "long ";
  1381.             if ( subtype & TT_FLOAT ) str += "float ";
  1382.             if ( subtype & TT_INTEGER ) str += "integer ";
  1383.             str.StripTrailing( ' ' );
  1384.             idLexer::Error( "expected %s but found '%s'", str.c_str(), token->c_str() );
  1385.             return 0;
  1386.         }
  1387.     }
  1388.     else if ( token->type == TT_PUNCTUATION ) {
  1389.         if ( subtype < 0 ) {
  1390.             idLexer::Error( "BUG: wrong punctuation subtype" );
  1391.             return 0;
  1392.         }
  1393.         if ( token->subtype != subtype ) {
  1394.             idLexer::Error( "expected '%s' but found '%s'", GetPunctuationFromId( subtype ), token->c_str() );
  1395.             return 0;
  1396.         }
  1397.     }
  1398.     return 1;
  1399. }
  1400.  
  1401. /*
  1402. ================
  1403. idLexer::ExpectAnyToken
  1404. ================
  1405. */
  1406. int idLexer::ExpectAnyToken( idToken *token ) {
  1407.     if (!idLexer::ReadToken( token )) {
  1408.         idLexer::Error( "couldn't read expected token" );
  1409.         return 0;
  1410.     }
  1411.     else {
  1412.         return 1;
  1413.     }
  1414. }
  1415.  
  1416. /*
  1417. ================
  1418. idLexer::CheckTokenString
  1419. ================
  1420. */
  1421. int idLexer::CheckTokenString( const char *string ) {
  1422.     idToken tok;
  1423.  
  1424.     if (!idLexer::ReadToken( &tok )) {
  1425.         return 0;
  1426.     }
  1427.  
  1428.     // if the token is available
  1429.     if ( tok == string ) {
  1430.         return 1;
  1431.     }
  1432.     // token not available
  1433.     UnreadToken( &tok );
  1434.     return 0;
  1435. }
  1436.  
  1437. /*
  1438. ================
  1439. idLexer::CheckTokenType
  1440. ================
  1441. */
  1442. int idLexer::CheckTokenType( int type, int subtype, idToken *token ) {
  1443.     idToken tok;
  1444.  
  1445.     if (!idLexer::ReadToken( &tok )) {
  1446.         return 0;
  1447.     }
  1448.     // if the type matches
  1449.     if (tok.type == type && (tok.subtype & subtype) == subtype) {
  1450.         *token = tok;
  1451.         return 1;
  1452.     }
  1453.     // token is not available
  1454.     idLexer::script_p = lastScript_p;
  1455.     idLexer::line = lastline;
  1456.     return 0;
  1457. }
  1458.  
  1459. /*
  1460. ================
  1461. idLexer::SkipUntilString
  1462. ================
  1463. */
  1464. int idLexer::SkipUntilString( const char *string ) {
  1465.     idToken token;
  1466.  
  1467.     while(idLexer::ReadToken( &token )) {
  1468.         if ( token == string ) {
  1469.             return 1;
  1470.         }
  1471.     }
  1472.     return 0;
  1473. }
  1474.  
  1475. /*
  1476. ================
  1477. idLexer::SkipRestOfLine
  1478. ================
  1479. */
  1480. int idLexer::SkipRestOfLine( void ) {
  1481.     idToken token;
  1482.  
  1483.     while(idLexer::ReadToken( &token )) {
  1484.         if ( token.linesCrossed ) {
  1485.             idLexer::script_p = lastScript_p;
  1486.             idLexer::line = lastline;
  1487.             return 1;
  1488.         }
  1489.     }
  1490.     return 0;
  1491. }
  1492.  
  1493. /*
  1494. =================
  1495. idLexer::SkipBracedSection
  1496.  
  1497. Skips until a matching close brace is found.
  1498. Internal brace depths are properly skipped.
  1499. =================
  1500. */
  1501. int idLexer::SkipBracedSection( bool parseFirstBrace ) {
  1502.     idToken token;
  1503.     int depth;
  1504.  
  1505.     depth = parseFirstBrace ? 0 : 1;
  1506.     do {
  1507.         if ( !ReadToken( &token ) ) {
  1508.             return false;
  1509.         }
  1510.         if ( token.type == TT_PUNCTUATION ) {
  1511.             if ( token == "{" ) {
  1512.                 depth++;
  1513.             } else if ( token == "}" ) {
  1514.                 depth--;
  1515.             }
  1516.         }
  1517.     } while( depth );
  1518.     return true;
  1519. }
  1520.  
  1521. /*
  1522. ================
  1523. idLexer::UnreadToken
  1524. ================
  1525. */
  1526. void idLexer::UnreadToken( const idToken *token ) {
  1527.     if ( idLexer::tokenavailable ) {
  1528.         idLib::common->FatalError( "idLexer::unreadToken, unread token twice\n" );
  1529.     }
  1530.     idLexer::token = *token;
  1531.     idLexer::tokenavailable = 1;
  1532. }
  1533.  
  1534. /*
  1535. ================
  1536. idLexer::ReadTokenOnLine
  1537. ================
  1538. */
  1539. int idLexer::ReadTokenOnLine( idToken *token ) {
  1540.     idToken tok;
  1541.  
  1542.     if (!idLexer::ReadToken( &tok )) {
  1543.         idLexer::script_p = lastScript_p;
  1544.         idLexer::line = lastline;
  1545.         return false;
  1546.     }
  1547.     // if no lines were crossed before this token
  1548.     if ( !tok.linesCrossed ) {
  1549.         *token = tok;
  1550.         return true;
  1551.     }
  1552.     // restore our position
  1553.     idLexer::script_p = lastScript_p;
  1554.     idLexer::line = lastline;
  1555.     token->Clear();
  1556.     return false;
  1557. }
  1558.  
  1559. /*
  1560. ================
  1561. idLexer::ReadRestOfLine
  1562. ================
  1563. */
  1564. const char*    idLexer::ReadRestOfLine(idStr& out) {
  1565.     while(1) {
  1566.  
  1567.         if(*idLexer::script_p == '\n') {
  1568.             idLexer::line++;
  1569.             break;
  1570.         }
  1571.  
  1572.         if(!*idLexer::script_p) {
  1573.             break;
  1574.         }
  1575.  
  1576.         if(*idLexer::script_p <= ' ') {
  1577.             out += " ";
  1578.         } else {
  1579.             out += *idLexer::script_p;
  1580.         }
  1581.         idLexer::script_p++;
  1582.  
  1583.     }
  1584.  
  1585.     out.Strip(' ');
  1586.     return out.c_str();
  1587. }
  1588.  
  1589. /*
  1590. ================
  1591. idLexer::ParseInt
  1592. ================
  1593. */
  1594. int idLexer::ParseInt( void ) {
  1595.     idToken token;
  1596.  
  1597.     if ( !idLexer::ReadToken( &token ) ) {
  1598.         idLexer::Error( "couldn't read expected integer" );
  1599.         return 0;
  1600.     }
  1601.     if ( token.type == TT_PUNCTUATION && token == "-" ) {
  1602.         idLexer::ExpectTokenType( TT_NUMBER, TT_INTEGER, &token );
  1603.         return -((signed int) token.GetIntValue());
  1604.     }
  1605.     else if ( token.type != TT_NUMBER || token.subtype == TT_FLOAT ) {
  1606.         idLexer::Error( "expected integer value, found '%s'", token.c_str() );
  1607.     }
  1608.     return token.GetIntValue();
  1609. }
  1610.  
  1611. /*
  1612. ================
  1613. idLexer::ParseBool
  1614. ================
  1615. */
  1616. bool idLexer::ParseBool( void ) {
  1617.     idToken token;
  1618.  
  1619.     if ( !idLexer::ExpectTokenType( TT_NUMBER, 0, &token ) ) {
  1620.         idLexer::Error( "couldn't read expected boolean" );
  1621.         return false;
  1622.     }
  1623.     return ( token.GetIntValue() != 0 );
  1624. }
  1625.  
  1626. /*
  1627. ================
  1628. idLexer::ParseFloat
  1629. ================
  1630. */
  1631. float idLexer::ParseFloat( bool *errorFlag ) {
  1632.     idToken token;
  1633.  
  1634.     if ( errorFlag ) {
  1635.         *errorFlag = false;
  1636.     }
  1637.  
  1638.     if ( !idLexer::ReadToken( &token ) ) {
  1639.         if ( errorFlag ) {
  1640.             idLexer::Warning( "couldn't read expected floating point number" );
  1641.             *errorFlag = true;
  1642.         } else {
  1643.             idLexer::Error( "couldn't read expected floating point number" );
  1644.         }
  1645.         return 0;
  1646.     }
  1647.     if ( token.type == TT_PUNCTUATION && token == "-" ) {
  1648.         idLexer::ExpectTokenType( TT_NUMBER, 0, &token );
  1649.         return -token.GetFloatValue();
  1650.     }
  1651.     else if ( token.type != TT_NUMBER ) {
  1652.         if ( errorFlag ) {
  1653.             idLexer::Warning( "expected float value, found '%s'", token.c_str() );
  1654.             *errorFlag = true;
  1655.         } else {
  1656.             idLexer::Error( "expected float value, found '%s'", token.c_str() );
  1657.         }
  1658.     }
  1659.     return token.GetFloatValue();
  1660. }
  1661.  
  1662. /*
  1663. ================
  1664. idLexer::Parse1DMatrix
  1665. ================
  1666. */
  1667. int idLexer::Parse1DMatrix( int x, float *m ) {
  1668.     int i;
  1669.  
  1670.     if ( !idLexer::ExpectTokenString( "(" ) ) {
  1671.         return false;
  1672.     }
  1673.  
  1674.     for ( i = 0; i < x; i++ ) {
  1675.         m[i] = idLexer::ParseFloat();
  1676.     }
  1677.  
  1678.     if ( !idLexer::ExpectTokenString( ")" ) ) {
  1679.         return false;
  1680.     }
  1681.     return true;
  1682. }
  1683.  
  1684. // RAVEN BEGIN
  1685. // rjohnson: added vertex color support to proc files.  assume a default RGBA of 0x000000ff
  1686. /*
  1687. ================
  1688. idLexer::Parse1DMatrixOpenEnded
  1689. ================
  1690. */
  1691. int idLexer::Parse1DMatrixOpenEnded( int MaxCount, float *m ) {
  1692.     int i;
  1693.  
  1694.     if ( !idLexer::ExpectTokenString( "(" ) ) {
  1695.         return 0;
  1696.     }
  1697.  
  1698.     for ( i = 0; i < MaxCount; i++ ) {
  1699.         idToken tok;
  1700.  
  1701.         if (!idLexer::ReadToken( &tok )) {
  1702.             return 0;
  1703.         }
  1704.  
  1705.         if ( tok == ")" ) {
  1706.             return i;
  1707.         }
  1708.  
  1709.         idLexer::UnreadToken( &tok );
  1710.  
  1711.         m[i] = idLexer::ParseFloat();
  1712.     }
  1713.  
  1714.     if ( !idLexer::ExpectTokenString( ")" ) ) {
  1715.         return 0;
  1716.     }
  1717.  
  1718.     return i;
  1719. }
  1720. // RAVEN END
  1721.  
  1722. /*
  1723. ================
  1724. idLexer::Parse2DMatrix
  1725. ================
  1726. */
  1727. int idLexer::Parse2DMatrix( int y, int x, float *m ) {
  1728.     int i;
  1729.  
  1730.     if ( !idLexer::ExpectTokenString( "(" ) ) {
  1731.         return false;
  1732.     }
  1733.  
  1734.     for ( i = 0; i < y; i++ ) {
  1735.         if ( !idLexer::Parse1DMatrix( x, m + i * x ) ) {
  1736.             return false;
  1737.         }
  1738.     }
  1739.  
  1740.     if ( !idLexer::ExpectTokenString( ")" ) ) {
  1741.         return false;
  1742.     }
  1743.     return true;
  1744. }
  1745.  
  1746. /*
  1747. ================
  1748. idLexer::Parse3DMatrix
  1749. ================
  1750. */
  1751. int idLexer::Parse3DMatrix( int z, int y, int x, float *m ) {
  1752.     int i;
  1753.  
  1754.     if ( !idLexer::ExpectTokenString( "(" ) ) {
  1755.         return false;
  1756.     }
  1757.  
  1758.     for ( i = 0 ; i < z; i++ ) {
  1759.         if ( !idLexer::Parse2DMatrix( y, x, m + i * x*y ) ) {
  1760.             return false;
  1761.         }
  1762.     }
  1763.  
  1764.     if ( !idLexer::ExpectTokenString( ")" ) ) {
  1765.         return false;
  1766.     }
  1767.     return true;
  1768. }
  1769.  
  1770. /*
  1771. ================
  1772. idLexer::ParseNumericStructArray
  1773. ================
  1774. */
  1775. void idLexer::ParseNumericStructArray( int numStructElements, int tokenSubTypeStructElements[], int arrayCount, byte *arrayStorage )
  1776. {
  1777.     int arrayOffset, curElement;
  1778.  
  1779.     for ( arrayOffset = 0; arrayOffset < arrayCount; arrayOffset++ )
  1780.     {
  1781.         for ( curElement = 0; curElement < numStructElements; curElement++ )
  1782.         {
  1783.             if ( tokenSubTypeStructElements[curElement] & TT_FLOAT )
  1784.             {
  1785.                 *(float*)arrayStorage = idLexer::ParseFloat();
  1786.                 arrayStorage += sizeof(float);
  1787.             }
  1788.             else
  1789.             {
  1790.                 *(int*)arrayStorage = idLexer::ParseInt();
  1791.                 arrayStorage += sizeof(int);
  1792.             }
  1793.         }
  1794.     }
  1795. }
  1796.  
  1797. /*
  1798. =================
  1799. idParser::ParseBracedSection
  1800.  
  1801. The next token should be an open brace.
  1802. Parses until a matching close brace is found.
  1803. Maintains exact characters between braces.
  1804.  
  1805.   FIXME: this should use ReadToken and replace the token white space with correct indents and newlines
  1806. =================
  1807. */
  1808. const char *idLexer::ParseBracedSectionExact( idStr &out, int tabs ) {
  1809.     int        depth;
  1810.     bool    doTabs;
  1811.     bool    skipWhite;
  1812.  
  1813.     out.Empty();
  1814.  
  1815.     if ( !idLexer::ExpectTokenString( "{" ) ) {
  1816.         return out.c_str( );
  1817.     }
  1818.  
  1819.     out = "{";
  1820.     depth = 1;    
  1821.     skipWhite = false;
  1822.     doTabs = tabs >= 0;
  1823.  
  1824.     while( depth && *idLexer::script_p ) {
  1825.         char c = *(idLexer::script_p++);
  1826.  
  1827.         switch ( c ) {
  1828.             case '\t':
  1829.             case ' ': {
  1830.                 if ( skipWhite ) {
  1831.                     continue;
  1832.                 }
  1833.                 break;
  1834.             }
  1835.             case '\n': {
  1836. // RAVEN BEGIN
  1837. // jscott: now gives correct line number in error reports
  1838.                 line++;
  1839. // RAVEN END
  1840.                 if ( doTabs ) {
  1841.                     skipWhite = true;
  1842.                     out += c;
  1843.                     continue;
  1844.                 }
  1845.                 break;
  1846.             }
  1847.             case '{': {
  1848.                 depth++;
  1849.                 tabs++;
  1850.                 break;
  1851.             }
  1852.             case '}': {
  1853.                 depth--;
  1854.                 tabs--;
  1855.                 break;                
  1856.             }
  1857.         }
  1858.  
  1859.         if ( skipWhite ) {
  1860.             int i = tabs;
  1861.             if ( c == '{' ) {
  1862.                 i--;
  1863.             }
  1864.             skipWhite = false;
  1865.             for ( ; i > 0; i-- ) {
  1866.                 out += '\t';
  1867.             }
  1868.         }
  1869.         out += c;
  1870.     }
  1871.     return out.c_str();
  1872. }
  1873.  
  1874. /*
  1875. =================
  1876. idLexer::ParseBracedSection
  1877.  
  1878. The next token should be an open brace.
  1879. Parses until a matching close brace is found.
  1880. Internal brace depths are properly skipped.
  1881. =================
  1882. */
  1883. const char *idLexer::ParseBracedSection( idStr &out ) {
  1884.     idToken token;
  1885.     int i, depth;
  1886.  
  1887.     out.Empty();
  1888.     if ( !idLexer::ExpectTokenString( "{" ) ) {
  1889.         return out.c_str();
  1890.     }
  1891.     out = "{";
  1892.     depth = 1;
  1893.     do {
  1894.         if ( !idLexer::ReadToken( &token ) ) {
  1895.             Error( "missing closing brace" );
  1896.             return out.c_str();
  1897.         }
  1898.  
  1899.         // if the token is on a new line
  1900.         for ( i = 0; i < token.linesCrossed; i++ ) {
  1901.             out += "\r\n";
  1902.         }
  1903.  
  1904.         if ( token.type == TT_PUNCTUATION ) {
  1905.             if ( token[0] == '{' ) {
  1906.                 depth++;
  1907.             }
  1908.             else if ( token[0] == '}' ) {
  1909.                 depth--;
  1910.             }
  1911.         }
  1912.  
  1913.         if ( token.type == TT_STRING ) {
  1914.             out += "\"" + token + "\"";
  1915.         }
  1916.         else {
  1917.             out += token;
  1918.         }
  1919.         out += " ";
  1920.     } while( depth );
  1921.  
  1922.     return out.c_str();
  1923. }
  1924.  
  1925. /*
  1926. =================
  1927. idLexer::ParseRestOfLine
  1928.  
  1929.   parse the rest of the line
  1930. =================
  1931. */
  1932. const char *idLexer::ParseRestOfLine( idStr &out ) {
  1933.     idToken token;
  1934.  
  1935.     out.Empty();
  1936.     while(idLexer::ReadToken( &token )) {
  1937.         if ( token.linesCrossed ) {
  1938.             idLexer::script_p = lastScript_p;
  1939.             idLexer::line = lastline;
  1940.             break;
  1941.         }
  1942.         if ( out.Length() ) {
  1943.             out += " ";
  1944.         }
  1945.         out += token;
  1946.     }
  1947.     return out.c_str();
  1948. }
  1949.  
  1950. /*
  1951. ================
  1952. idLexer::GetLastWhiteSpace
  1953. ================
  1954. */
  1955. int idLexer::GetLastWhiteSpace( idStr &whiteSpace ) const {
  1956.     whiteSpace.Clear();
  1957.     for ( const char *p = whiteSpaceStart_p; p < whiteSpaceEnd_p; p++ ) {
  1958.         whiteSpace.Append( *p );
  1959.     }
  1960.     return whiteSpace.Length();
  1961. }
  1962.  
  1963. /*
  1964. ================
  1965. idLexer::GetLastWhiteSpaceStart
  1966. ================
  1967. */
  1968. int idLexer::GetLastWhiteSpaceStart( void ) const {
  1969.     return whiteSpaceStart_p - buffer;
  1970. }
  1971.  
  1972. /*
  1973. ================
  1974. idLexer::GetLastWhiteSpaceEnd
  1975. ================
  1976. */
  1977. int idLexer::GetLastWhiteSpaceEnd( void ) const {
  1978.     return whiteSpaceEnd_p - buffer;
  1979. }
  1980.  
  1981. /*
  1982. ================
  1983. idLexer::Reset
  1984. ================
  1985. */
  1986. void idLexer::Reset( void ) {
  1987.     // pointer in script buffer
  1988.     idLexer::script_p = idLexer::buffer;
  1989.     // pointer in script buffer before reading token
  1990.     idLexer::lastScript_p = idLexer::buffer;
  1991.     // begin of white space
  1992.     idLexer::whiteSpaceStart_p = NULL;
  1993.     // end of white space
  1994.     idLexer::whiteSpaceEnd_p = NULL;
  1995.     // set if there's a token available in idLexer::token
  1996.     idLexer::tokenavailable = 0;
  1997.  
  1998.     idLexer::line = 1;
  1999.     idLexer::lastline = 1;
  2000.     // clear the saved token
  2001.     idLexer::token = "";
  2002. }
  2003.  
  2004. /*
  2005. ================
  2006. idLexer::EndOfFile
  2007. ================
  2008. */
  2009. int idLexer::EndOfFile( void ) {
  2010.     return idLexer::script_p >= idLexer::end_p;
  2011. }
  2012.  
  2013. /*
  2014. ================
  2015. idLexer::NumLinesCrossed
  2016. ================
  2017. */
  2018. int idLexer::NumLinesCrossed( void ) {
  2019.     return idLexer::line - idLexer::lastline;
  2020. }
  2021.  
  2022. /*
  2023. ================
  2024. idLexer::LoadFile
  2025. ================
  2026. */
  2027. int idLexer::LoadFile( const char *filename, bool OSPath ) {
  2028.     idFile *fp;
  2029.     idStr pathname;
  2030.     int length;
  2031.     char *buf;
  2032.  
  2033.     if ( idLexer::loaded ) {
  2034.         idLib::common->Error("idLexer::LoadFile: another script already loaded");
  2035.         return false;
  2036.     }
  2037.     
  2038.     if ( !OSPath && ( baseFolder[0] != '\0' ) ) {
  2039.         pathname = va( "%s/%s", baseFolder, filename );
  2040.     } else {
  2041.         pathname = filename;
  2042.     }
  2043.     if ( OSPath ) {
  2044.         fp = idLib::fileSystem->OpenExplicitFileRead( pathname );
  2045.     } else {
  2046.         fp = idLib::fileSystem->OpenFileRead( pathname );
  2047.     }
  2048.     if ( !fp ) {
  2049.         return false;
  2050.     }
  2051.     length = fp->Length();
  2052. // RAVEN BEGIN
  2053. // amccarthy: Added memory allocation tag
  2054.     buf = (char *) Mem_Alloc( length + 1, MA_LEXER );
  2055.     if( !buf ) {
  2056.         common->FatalError( "Memory system failure : out of memory" );
  2057.     }
  2058. // RAVEN END
  2059.     buf[length] = '\0';
  2060.     fp->Read( buf, length );
  2061.     idLexer::fileTime = fp->Timestamp();
  2062.     idLexer::filename = fp->GetFullPath();
  2063.     idLib::fileSystem->CloseFile( fp );
  2064.  
  2065.     idLexer::buffer = buf;
  2066.     idLexer::length = length;
  2067.     // pointer in script buffer
  2068.     idLexer::script_p = idLexer::buffer;
  2069.     // pointer in script buffer before reading token
  2070.     idLexer::lastScript_p = idLexer::buffer;
  2071.     // pointer to end of script buffer
  2072.     idLexer::end_p = &(idLexer::buffer[length]);
  2073.  
  2074.     idLexer::tokenavailable = 0;
  2075.     idLexer::line = 1;
  2076.     idLexer::lastline = 1;
  2077.     idLexer::allocated = true;
  2078.     idLexer::loaded = true;
  2079.  
  2080. // RAVEN BEGIN
  2081. // jsinger: initialize compiled file
  2082.     if(flags & LEXFL_WRITEBINARY)
  2083.     {
  2084.         pathname.Append(Lexer::sCompiledFileSuffix);
  2085.         if ( OSPath ) {
  2086.             mBinaryFile = idLib::fileSystem->OpenExplicitFileWrite( pathname );
  2087.         } else {
  2088.             mBinaryFile = idLib::fileSystem->OpenFileWrite( pathname );
  2089.         }
  2090.     }
  2091. // RAVEN END
  2092.  
  2093.     return true;
  2094. }
  2095.  
  2096. /*
  2097. ================
  2098. idLexer::LoadMemory
  2099. ================
  2100. */
  2101. int idLexer::LoadMemory( const char *ptr, int length, const char *name, int startLine ) {
  2102.     if ( idLexer::loaded ) {
  2103.         idLib::common->Error("idLexer::LoadMemory: another script already loaded");
  2104.         return false;
  2105.     }
  2106.     idLexer::filename = name;
  2107.     idLexer::buffer = ptr;
  2108.     idLexer::fileTime = 0;
  2109.     idLexer::length = length;
  2110.     // pointer in script buffer
  2111.     idLexer::script_p = idLexer::buffer;
  2112.     // pointer in script buffer before reading token
  2113.     idLexer::lastScript_p = idLexer::buffer;
  2114.     // pointer to end of script buffer
  2115.     idLexer::end_p = &(idLexer::buffer[length]);
  2116.  
  2117.     idLexer::tokenavailable = 0;
  2118.     idLexer::line = startLine;
  2119.     idLexer::lastline = startLine;
  2120.     idLexer::allocated = false;
  2121.     idLexer::loaded = true;
  2122.  
  2123.     return true;
  2124. }
  2125.  
  2126. /*
  2127. ================
  2128. idLexer::FreeSource
  2129. ================
  2130. */
  2131. void idLexer::FreeSource( void ) {
  2132. #ifdef PUNCTABLE
  2133.     if ( idLexer::punctuationtable && idLexer::punctuationtable != default_punctuationtable ) {
  2134.         Mem_Free( (void *) idLexer::punctuationtable );
  2135.         idLexer::punctuationtable = NULL;
  2136.     }
  2137.     if ( idLexer::nextpunctuation && idLexer::nextpunctuation != default_nextpunctuation ) {
  2138.         Mem_Free( (void *) idLexer::nextpunctuation );
  2139.         idLexer::nextpunctuation = NULL;
  2140.     }
  2141. #endif //PUNCTABLE
  2142.     if ( idLexer::allocated ) {
  2143.         Mem_Free( (void *) idLexer::buffer );
  2144.         idLexer::buffer = NULL;
  2145.         idLexer::allocated = false;
  2146.     }
  2147.     idLexer::tokenavailable = 0;
  2148.     idLexer::token = "";
  2149.     idLexer::loaded = false;
  2150. // RAVEN BEGIN
  2151. // jsinger: close compile file if it exists
  2152.     if(flags & LEXFL_WRITEBINARY)
  2153.     {
  2154.         if(mBinaryFile)
  2155.         {
  2156.             idLib::fileSystem->CloseFile(mBinaryFile);
  2157.             mBinaryFile = NULL;
  2158.         }
  2159.     }
  2160. // RAVEN END
  2161. }
  2162.  
  2163. /*
  2164. ================
  2165. idLexer::idLexer
  2166. ================
  2167. */
  2168. idLexer::idLexer( void ) {
  2169.     idLexer::loaded = false;
  2170.     idLexer::filename = "";
  2171.     idLexer::flags = 0;
  2172.     idLexer::SetPunctuations( NULL );
  2173.     idLexer::allocated = false;
  2174.     idLexer::fileTime = 0;
  2175.     idLexer::length = 0;
  2176.     idLexer::line = 0;
  2177.     idLexer::lastline = 0;
  2178.     idLexer::tokenavailable = 0;
  2179.     idLexer::token = "";
  2180.     idLexer::next = NULL;
  2181.     idLexer::hadError = false;
  2182. // RAVEN BEGIN
  2183. // jsinger: initialize compiled file
  2184.     idLexer::mBinaryFile = NULL;
  2185. // RAVEN END
  2186. }
  2187.  
  2188. /*
  2189. ================
  2190. idLexer::idLexer
  2191. ================
  2192. */
  2193. idLexer::idLexer( int flags ) {
  2194.     idLexer::loaded = false;
  2195.     idLexer::filename = "";
  2196.     idLexer::flags = flags;
  2197.     idLexer::SetPunctuations( NULL );
  2198.     idLexer::allocated = false;
  2199.     idLexer::fileTime = 0;
  2200.     idLexer::length = 0;
  2201.     idLexer::line = 0;
  2202.     idLexer::lastline = 0;
  2203.     idLexer::tokenavailable = 0;
  2204.     idLexer::token = "";
  2205.     idLexer::next = NULL;
  2206.     idLexer::hadError = false;
  2207. // RAVEN BEGIN
  2208. // jsinger: initialize compiled file
  2209.     idLexer::mBinaryFile = NULL;
  2210. // RAVEN END
  2211. }
  2212.  
  2213. /*
  2214. ================
  2215. idLexer::idLexer
  2216. ================
  2217. */
  2218. idLexer::idLexer( const char *filename, int flags, bool OSPath ) {
  2219.     idLexer::loaded = false;
  2220.     idLexer::flags = flags;
  2221.     idLexer::SetPunctuations( NULL );
  2222.     idLexer::allocated = false;
  2223.     idLexer::token = "";
  2224.     idLexer::next = NULL;
  2225.     idLexer::hadError = false;
  2226. // RAVEN BEGIN
  2227. // jsinger: initialize compiled file
  2228.     idLexer::mBinaryFile = NULL;
  2229. // RAVEN END
  2230.     idLexer::LoadFile( filename, OSPath );
  2231. }
  2232.  
  2233. /*
  2234. ================
  2235. idLexer::idLexer
  2236. ================
  2237. */
  2238. idLexer::idLexer( const char *ptr, int length, const char *name, int flags ) {
  2239.     idLexer::loaded = false;
  2240.     idLexer::flags = flags;
  2241.     idLexer::SetPunctuations( NULL );
  2242.     idLexer::allocated = false;
  2243.     idLexer::token = "";
  2244.     idLexer::next = NULL;
  2245.     idLexer::hadError = false;
  2246. // RAVEN BEGIN
  2247. // jsinger: initialize compiled file
  2248.     idLexer::mBinaryFile = NULL;
  2249. // RAVEN END
  2250.     idLexer::LoadMemory( ptr, length, name );
  2251. }
  2252.  
  2253. /*
  2254. ================
  2255. idLexer::~idLexer
  2256. ================
  2257. */
  2258. idLexer::~idLexer( void ) {
  2259.     idLexer::FreeSource();
  2260. }
  2261.  
  2262. // RAVEN BEGIN
  2263. // jsinger: SetBaseFolder was moved to the Lexer base class to unify its functionality across all
  2264. //            derived classes
  2265. /*
  2266. ================
  2267. idLexer::SetBaseFolder
  2268. ================
  2269.  
  2270. void idLexer::SetBaseFolder( const char *path ) {
  2271.     idStr::Copynz( baseFolder, path, sizeof( baseFolder ) );
  2272. }
  2273. */
  2274. // RAVEN END
  2275. /*
  2276. ================
  2277. idLexer::HadError
  2278. ================
  2279. */
  2280. bool idLexer::HadError( void ) const {
  2281.     return hadError;
  2282. }
  2283.  
  2284.  
  2285. // RAVEN BEGIN
  2286. // jsinger: This method can write out a binary representation of a token in a format
  2287. //          suitable to be read by the Lexer
  2288. /*
  2289. ================
  2290. idLexer::WriteBinaryToken
  2291.     Writes a binary representation of the token value to the compiled file
  2292.     when compiling is turned on
  2293. ================
  2294. */
  2295. void idLexer::WriteBinaryToken(idToken *tok)
  2296. {
  2297.     bool swapBytes = (flags & LEXFL_BYTESWAP) == LEXFL_BYTESWAP;
  2298.  
  2299.     if(flags & LEXFL_WRITEBINARY)
  2300.     {
  2301.         unsigned char prefix;
  2302.  
  2303.         switch(tok->type)
  2304.         {
  2305.         case TT_NUMBER:
  2306.             if(tok->subtype & TT_INTEGER)
  2307.             {
  2308.                 if(tok->subtype & TT_UNSIGNED)
  2309.                 {
  2310.                     unsigned long val = tok->GetUnsignedLongValue();
  2311.                     unsigned char byteVal = (unsigned char)val;
  2312.                     unsigned short shortVal = (unsigned short)val;
  2313.                 
  2314.                     if(byteVal == val)
  2315.                     {
  2316.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_UNSIGNEDINT, BTT_STORED_1BYTE);
  2317.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2318.                         TextCompiler::WriteValue<unsigned char>(byteVal, mBinaryFile, swapBytes);
  2319.                     }
  2320.                     else if(shortVal == val)
  2321.                     {
  2322.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_UNSIGNEDINT, BTT_STORED_2BYTE);
  2323.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2324.                         TextCompiler::WriteValue<unsigned short>(shortVal, mBinaryFile, swapBytes);
  2325.                     }
  2326.                     else
  2327.                     {
  2328.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_UNSIGNEDINT, BTT_STORED_4BYTE);
  2329.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2330.                         TextCompiler::WriteValue<unsigned int>(val, mBinaryFile, swapBytes);
  2331.                     }
  2332.                 }
  2333.                 else
  2334.                 {
  2335.                     long val = tok->GetIntValue();
  2336.                     char byteVal = (char)val;
  2337.                     short shortVal = (short)val;
  2338.                 
  2339.                     if(byteVal == val)
  2340.                     {
  2341.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_INT, BTT_STORED_1BYTE);
  2342.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2343.                         TextCompiler::WriteValue<char>(byteVal, mBinaryFile, swapBytes);
  2344.                     }
  2345.                     else if(shortVal == val)
  2346.                     {
  2347.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_INT, BTT_STORED_2BYTE);
  2348.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2349.                         TextCompiler::WriteValue<short>(shortVal, mBinaryFile, swapBytes);
  2350.                     }
  2351.                     else
  2352.                     {
  2353.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_INT, BTT_STORED_4BYTE);
  2354.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2355.                         TextCompiler::WriteValue<int>(val, mBinaryFile, swapBytes);
  2356.                     }
  2357.                 }
  2358.             }
  2359.             else if(tok->subtype & TT_FLOAT)
  2360.             {
  2361.                 if(tok->subtype & TT_SINGLE_PRECISION)
  2362.                 {                
  2363.                     float val = tok->GetFloatValue();
  2364.                     int intval = tok->GetIntValue();
  2365.                     if(((float)intval) == val)        // integral check
  2366.                     {
  2367.                         char byteVal = (char)intval;
  2368.                         short shortVal = (short)intval;
  2369.                     
  2370.                         if(byteVal == intval)
  2371.                         {
  2372.                             prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_FLOAT, BTT_STORED_1BYTE);
  2373.                             TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2374.                             TextCompiler::WriteValue<char>(byteVal, mBinaryFile, swapBytes);
  2375.                         }
  2376.                         else if(shortVal == intval)
  2377.                         {
  2378.                             prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_FLOAT, BTT_STORED_2BYTE);
  2379.                             TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2380.                             TextCompiler::WriteValue<short>(shortVal, mBinaryFile, swapBytes);
  2381.                         }
  2382.                         else
  2383.                         {
  2384.                             prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_FLOAT, BTT_STORED_4BYTE);
  2385.                             TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2386.                             TextCompiler::WriteValue<float>(val, mBinaryFile, swapBytes);
  2387.                         }
  2388.                     }
  2389.                     else
  2390.                     {
  2391.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_FLOAT, BTT_STORED_4BYTE);
  2392.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2393.                         TextCompiler::WriteValue<float>(val, mBinaryFile, swapBytes);
  2394.                     }
  2395.                 }
  2396.                 else if(tok->subtype & TT_DOUBLE_PRECISION)
  2397.                 {
  2398.                     // we can write out doubles as floats because the text file doesn't have double precision anyway
  2399.                     float val = tok->GetDoubleValue();
  2400.                     int intval = tok->GetIntValue();
  2401.                     if(((float)intval) == val)        // integral check
  2402.                     {
  2403.                         char byteVal = (char)intval;
  2404.                         short shortVal = (short)intval;
  2405.                     
  2406.                         if(byteVal == intval)
  2407.                         {
  2408.                             prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_FLOAT, BTT_STORED_1BYTE);
  2409.                             TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2410.                             TextCompiler::WriteValue<char>(byteVal, mBinaryFile, swapBytes);
  2411.                         }
  2412.                         else if(shortVal == intval)
  2413.                         {
  2414.                             prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_FLOAT, BTT_STORED_2BYTE);
  2415.                             TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2416.                             TextCompiler::WriteValue<short>(shortVal, mBinaryFile, swapBytes);
  2417.                         }
  2418.                         else
  2419.                         {
  2420.                             prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_DOUBLE, BTT_STORED_4BYTE);
  2421.                             TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2422.                             TextCompiler::WriteValue<float>(val, mBinaryFile, swapBytes);
  2423.                         }
  2424.                     }
  2425.                     else
  2426.                     {
  2427.                         prefix = BTT_MAKENUMBER_PREFIX(BTT_NUMBER, BTT_SUBTYPE_DOUBLE, BTT_STORED_4BYTE);
  2428.                         TextCompiler::WriteValue<unsigned char>(prefix, mBinaryFile, swapBytes);
  2429.                         TextCompiler::WriteValue<float>(val, mBinaryFile, swapBytes);
  2430.                     }
  2431.                 }
  2432.             }
  2433.             break;
  2434.         case TT_STRING:
  2435.             TextCompiler::WriteValue<unsigned char>(BTT_MAKESTRING_PREFIX(BTT_STRING, tok->Length()), mBinaryFile, swapBytes);
  2436.             TextCompiler::WriteValue<idStr>(tok, mBinaryFile, swapBytes);
  2437.             break;
  2438.         case TT_LITERAL:
  2439.             TextCompiler::WriteValue<unsigned char>(BTT_MAKESTRING_PREFIX(BTT_LITERAL, tok->Length()), mBinaryFile, swapBytes);
  2440.             TextCompiler::WriteValue<idStr>(tok, mBinaryFile, swapBytes);
  2441.             break;
  2442.         case TT_NAME:
  2443.             TextCompiler::WriteValue<unsigned char>(BTT_MAKESTRING_PREFIX(BTT_NAME, tok->Length()), mBinaryFile, swapBytes);
  2444.             TextCompiler::WriteValue<idStr>(tok, mBinaryFile, swapBytes);
  2445.             break;
  2446.         case TT_PUNCTUATION:
  2447.             if(*tok == "&&")
  2448.             {
  2449.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_LOGICALAND), mBinaryFile, swapBytes);
  2450.             }
  2451.             else if (*tok == "&")
  2452.             {
  2453.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_AMPERSAND), mBinaryFile, swapBytes);
  2454.             }
  2455.             else if(*tok == "=")
  2456.             {
  2457.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_EQUAL), mBinaryFile, swapBytes);
  2458.             }
  2459.             else if(*tok == "==")
  2460.             {
  2461.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_EQUALEQUAL), mBinaryFile, swapBytes);
  2462.             }
  2463.             else if(*tok == "!=")
  2464.             {
  2465.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_NOTEQUAL), mBinaryFile, swapBytes);
  2466.             }
  2467.             else if(*tok == "!")
  2468.             {
  2469.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_EXCLAMATION), mBinaryFile, swapBytes);
  2470.             }
  2471.             else if(*tok == "<")
  2472.             {
  2473.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_LESSTHAN), mBinaryFile, swapBytes);
  2474.             }
  2475.             else if(*tok == "<=")
  2476.             {
  2477.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_LESSOREQUAL), mBinaryFile, swapBytes);
  2478.             }
  2479.             else if(*tok == "<<")
  2480.             {
  2481.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_SHIFTLEFT), mBinaryFile, swapBytes);
  2482.             }
  2483.             else if(*tok == ">")
  2484.             {
  2485.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_GREATERTHAN), mBinaryFile, swapBytes);
  2486.             }
  2487.             else if(*tok == ">=")
  2488.             {
  2489.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_GREATEROREQUAL), mBinaryFile, swapBytes);
  2490.             }
  2491.             else if(*tok == ">>")
  2492.             {
  2493.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_SHIFTRIGHT), mBinaryFile, swapBytes);
  2494.             }
  2495.             else if(*tok == "%")
  2496.             {
  2497.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_PERCENT), mBinaryFile, swapBytes);
  2498.             }
  2499.             else if(*tok == "[")
  2500.             {
  2501.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_LEFTBRACKET), mBinaryFile, swapBytes);
  2502.             }
  2503.             else if(*tok == "]")
  2504.             {
  2505.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_RIGHTBRACKET), mBinaryFile, swapBytes);
  2506.             }
  2507.             else if(*tok == "-")
  2508.             {
  2509.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_MINUS), mBinaryFile, swapBytes);
  2510.             }
  2511.             else if(*tok == "--")
  2512.             {
  2513.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_MINUSMINUS), mBinaryFile, swapBytes);
  2514.             }
  2515.             else if(*tok == "-=")
  2516.             {
  2517.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_MINUSEQUAL), mBinaryFile, swapBytes);
  2518.             }
  2519.             else if(*tok == "+")
  2520.             {
  2521.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_PLUS), mBinaryFile, swapBytes);
  2522.             }
  2523.             else if(*tok == "+=")
  2524.             {
  2525.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_PLUSEQUAL), mBinaryFile, swapBytes);
  2526.             }
  2527.             else if(*tok == "++")
  2528.             {
  2529.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_PLUSPLUS), mBinaryFile, swapBytes);
  2530.             }
  2531.             else if(*tok == "(")
  2532.             {
  2533.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_LEFTPAREN), mBinaryFile, swapBytes);
  2534.             }
  2535.             else if(*tok == ")")
  2536.             {
  2537.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_RIGHTPAREN), mBinaryFile, swapBytes);
  2538.             }
  2539.             else if(*tok == "{")
  2540.             {
  2541.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_LEFTBRACE), mBinaryFile, swapBytes);
  2542.             }
  2543.             else if(*tok == "}")
  2544.             {
  2545.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_RIGHTBRACE), mBinaryFile, swapBytes);
  2546.             }
  2547.             else if(*tok == ",")
  2548.             {
  2549.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_COMMA), mBinaryFile, swapBytes);
  2550.             }
  2551.             else if(*tok == "::")
  2552.             {
  2553.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_DOUBLECOLON), mBinaryFile, swapBytes);
  2554.             }
  2555.             else if(*tok == "#")
  2556.             {
  2557.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_HASH), mBinaryFile, swapBytes);
  2558.             }
  2559.             else if(*tok == "##")
  2560.             {
  2561.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_DOUBLEHASH), mBinaryFile, swapBytes);
  2562.             }
  2563.             else if(*tok == "/")
  2564.             {
  2565.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_FORWARDSLASH), mBinaryFile, swapBytes);
  2566.             }
  2567.             else if(*tok == "\\")
  2568.             {
  2569.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_BACKSLASH), mBinaryFile, swapBytes);
  2570.             }
  2571.             else if(*tok == ";")
  2572.             {
  2573.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_SEMICOLON), mBinaryFile, swapBytes);
  2574.             }
  2575.             else if(*tok == ".")
  2576.             {
  2577.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_PERIOD), mBinaryFile, swapBytes);
  2578.             }
  2579.             else if(*tok == "$")
  2580.             {
  2581.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_DOLLARSIGN), mBinaryFile, swapBytes);
  2582.             }
  2583.             else if(*tok == "~")
  2584.             {
  2585.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_TILDE), mBinaryFile, swapBytes);
  2586.             }
  2587.             else if(*tok == "|")
  2588.             {
  2589.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_PIPE), mBinaryFile, swapBytes);
  2590.             }
  2591.             else if(*tok == "||")
  2592.             {
  2593.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_DOUBLEPIPE), mBinaryFile, swapBytes);
  2594.             }
  2595.             else if(*tok == "*")
  2596.             {
  2597.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_ASTERISK), mBinaryFile, swapBytes);
  2598.             }
  2599.             else if(*tok == "*=")
  2600.             {
  2601.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_TIMESEQUAL), mBinaryFile, swapBytes);
  2602.             }
  2603.             else if(*tok == "í")
  2604.             {
  2605.                 TextCompiler::WriteValue<unsigned char>(BTT_PUNC_INVERTEDPLING, mBinaryFile, swapBytes);
  2606.             }
  2607.             else if(*tok == "┐")
  2608.             {
  2609.                 TextCompiler::WriteValue<unsigned char>(BTT_PUNC_INVERTEDQUERY, mBinaryFile, swapBytes);
  2610.             }
  2611.             else
  2612.             {
  2613.                 common->Warning("Unsupported punctuation: '%s'", tok->c_str());
  2614.                 
  2615.                 TextCompiler::WriteValue<unsigned char>(BTT_MAKEPUNCTUATION_PREFIX(BTT_PUNC_ASNULLTERMINATED), mBinaryFile, swapBytes);
  2616.                 TextCompiler::WriteValue<idStr>(tok, mBinaryFile, swapBytes);
  2617.             }
  2618.             break;
  2619.         default:
  2620.             // wtf?
  2621.             assert(false);
  2622.         }
  2623.     }
  2624. }
  2625.  
  2626. // jsinger: this method takes an existing file and causes a binary tokenized
  2627. //          version of the file to be generated
  2628. void idLexer::WriteBinaryFile(char const * const filename)
  2629. {
  2630.     if(!cvarSystem->GetCVarBool("com_BinaryRead"))
  2631.     {
  2632.         unsigned int swap=0;
  2633.  
  2634.         switch(cvarSystem->GetCVarInteger("com_BinaryWrite"))
  2635.         {
  2636.         case 1:
  2637.             swap = 0;
  2638.             break;
  2639.         case 2:
  2640.             swap = LEXFL_BYTESWAP;
  2641.             break;
  2642.         }
  2643.  
  2644.         idLexer src(filename, LEXFL_WRITEBINARY | swap);
  2645.         idToken token;
  2646.         if(src.IsLoaded())
  2647.         {
  2648.             while(src.ReadToken(&token))
  2649.             {
  2650.                 // we don't need to do anything, because just reading the file
  2651.                 // causes it to write a tokenized version
  2652.             }
  2653.         }
  2654.     }
  2655. }
  2656.  
  2657. // jsinger: implementation for a class that can load binary tokenized files
  2658. using namespace TextCompiler;
  2659. Lexer::Lexer(int flags)
  2660. {
  2661. #ifndef LEXER_READ_AHEAD
  2662.     mFile = NULL;
  2663. #endif
  2664.     offset = 0;
  2665.     tokenAvailable = false;
  2666.     mFlags = flags;
  2667.     if(flags & LEXFL_READBINARY)
  2668.     {
  2669.         mDelegate = NULL;
  2670.     }
  2671.     else
  2672.     {
  2673.         mDelegate = new idLexer(flags);
  2674.     }
  2675. }
  2676.  
  2677. Lexer::Lexer(char const * const ptr, int length, char const * const name, int flags)
  2678. {
  2679.     if(flags & LEXFL_READBINARY)
  2680.     {
  2681. #ifdef LEXER_READ_AHEAD
  2682.         mLexerIOWrapper.InitFromMemory(ptr, length);
  2683. #else
  2684.         assert(false);
  2685. #endif
  2686.         mDelegate = NULL;
  2687.     }
  2688.     else
  2689.     {
  2690.         mDelegate = new idLexer(ptr, length, name, flags);
  2691.     }
  2692. }
  2693.  
  2694. Lexer::Lexer(char const * const filename, int flags, bool OSPath)
  2695. {
  2696. #ifndef LEXER_READ_AHEAD
  2697.     mFile = NULL;
  2698. #endif
  2699.     offset = 0;
  2700.     tokenAvailable = false;
  2701.     mFlags = flags;
  2702.     if(flags & LEXFL_READBINARY)
  2703.     {
  2704.         mDelegate = NULL;
  2705.         LoadFile(filename, OSPath);
  2706.     }
  2707.     else
  2708.     {
  2709.         mDelegate = new idLexer(filename, flags, OSPath);
  2710.     }
  2711. }
  2712.  
  2713. Lexer::~Lexer()
  2714. {
  2715.     FreeSource();
  2716. }
  2717.  
  2718. char const * Lexer::GetFileName()
  2719. {
  2720.     if(mDelegate)
  2721.     {
  2722.         return mDelegate->GetFileName();
  2723.     }
  2724.     else
  2725.     {
  2726.         assert(false);
  2727.         return "";
  2728.     }
  2729. }
  2730.  
  2731. bool Lexer::HadError() const
  2732. {
  2733.     if(mDelegate)
  2734.     {
  2735.         return mDelegate->HadError();
  2736.     }
  2737.     else
  2738.     {
  2739.         assert(false);
  2740.         return false;
  2741.     }
  2742. }
  2743.  
  2744. void Lexer::Warning(char const *str, ...)
  2745. {
  2746.     char text[MAX_STRING_CHARS];
  2747.     va_list ap;
  2748.  
  2749.     va_start( ap, str );
  2750.     vsprintf( text, str, ap );
  2751.     va_end( ap );
  2752.     idLib::common->Warning( "Lexer: '%s'", text );
  2753. }
  2754.  
  2755. void Lexer::Error(char const *str, ...)
  2756. {
  2757.     char text[MAX_STRING_CHARS];
  2758.     va_list ap;
  2759.  
  2760.     va_start( ap, str );
  2761.     vsprintf( text, str, ap );
  2762.     va_end( ap );
  2763.  
  2764.     assert(false);
  2765.  
  2766.     idLib::common->Error( "Lexer: offset: %d '%s'", offset, text );
  2767. }
  2768.  
  2769. int const Lexer::GetLineNum()
  2770. {
  2771.     if(mDelegate)
  2772.     {
  2773.         return mDelegate->GetLineNum();
  2774.     }
  2775.     else
  2776.     {
  2777.         return 1;
  2778.     }
  2779. }
  2780.  
  2781. unsigned int const Lexer::GetFileTime()
  2782. {
  2783.     if(mDelegate)
  2784.     {
  2785.         return mDelegate->GetFileTime();
  2786.     }
  2787.     else
  2788.     {
  2789.         return 0;
  2790.     }
  2791. }
  2792.  
  2793. int const Lexer::GetFileOffset()
  2794. {
  2795.     if(mDelegate)
  2796.     {
  2797.         return mDelegate->GetFileOffset();
  2798.     }
  2799.     {
  2800.         assert(false);
  2801.         return 0;
  2802.     }
  2803. }
  2804.  
  2805. int Lexer::EndOfFile()
  2806. {
  2807.     if(mDelegate)
  2808.     {
  2809.         return mDelegate->EndOfFile();
  2810.     }
  2811.     else
  2812.     {
  2813. #ifdef LEXER_READ_AHEAD
  2814.         return mLexerIOWrapper.Tell()>= mLexerIOWrapper.Length();
  2815. #else
  2816.         return mFile->Tell()>= mFile->Length();
  2817. #endif
  2818.     }
  2819. }
  2820.  
  2821. void Lexer::Reset()
  2822. {
  2823.     if(mDelegate)
  2824.     {
  2825.         mDelegate->Reset();
  2826.     }
  2827.     else
  2828.     {
  2829. #ifdef LEXER_READ_AHEAD
  2830.         mLexerIOWrapper.Seek(0,     FS_SEEK_SET);
  2831. #else
  2832.         mFile->Seek(0,     FS_SEEK_SET);
  2833. #endif
  2834.         offset = 0;
  2835.         tokenAvailable = false;
  2836.     }
  2837. }
  2838.  
  2839. int Lexer::GetFlags()
  2840. {
  2841.     if(mDelegate)
  2842.     {
  2843.         return mDelegate->GetFlags();
  2844.     }
  2845.     else
  2846.     {
  2847.         return mFlags;
  2848.     }
  2849. }
  2850.  
  2851. void Lexer::SetFlags(int flags)
  2852. {
  2853.     if(mDelegate)
  2854.     {
  2855.         mDelegate->SetFlags(flags);
  2856.     }
  2857.     else
  2858.     {
  2859.         mFlags = flags;
  2860.     }
  2861. }
  2862.  
  2863. int Lexer::GetPunctuationId(char const *str)
  2864. {
  2865.     if(mDelegate)
  2866.     {
  2867.         return mDelegate->GetPunctuationId(str);
  2868.     }
  2869.     else
  2870.     {
  2871.         // this method is not supported
  2872.         assert(false);
  2873.         return 0;
  2874.     }
  2875. }
  2876.  
  2877. void Lexer::SetPunctuations(struct punctuation_s const *punc)
  2878. {
  2879.     if(mDelegate)
  2880.     {
  2881.         mDelegate->SetPunctuations(punc);
  2882.     }
  2883.     else
  2884.     {
  2885.         // this method is not supported
  2886.         assert(false);
  2887.     }
  2888. }
  2889.  
  2890. int Lexer::GetLastWhiteSpaceEnd() const
  2891. {
  2892.     if(mDelegate)
  2893.     {
  2894.         return mDelegate->GetLastWhiteSpaceEnd();
  2895.     }
  2896.     else
  2897.     {
  2898.         return 0;
  2899.     }
  2900. }
  2901.  
  2902. char const *Lexer::GetPunctuationFromId(int val)
  2903. {
  2904.     if(mDelegate)
  2905.     {
  2906.         return mDelegate->GetPunctuationFromId(val);
  2907.     }
  2908.     else
  2909.     {
  2910.         // this method is not supported
  2911.         assert(false);
  2912.         return "";
  2913.     }
  2914. }
  2915.  
  2916. int Lexer::GetLastWhiteSpaceStart() const
  2917. {
  2918.     if(mDelegate)
  2919.     {
  2920.         return mDelegate->GetLastWhiteSpaceStart();
  2921.     }
  2922.     else
  2923.     {
  2924.         return 0;
  2925.     }
  2926. }
  2927.  
  2928. int Lexer::GetLastWhiteSpace(idStr &str) const
  2929. {
  2930.     if(mDelegate)
  2931.     {
  2932.         return mDelegate->GetLastWhiteSpace(str);
  2933.     }
  2934.     else
  2935.     {
  2936.         return 0;
  2937.     }
  2938. }
  2939.  
  2940. char const *Lexer::ParseRestOfLine(idStr &str)
  2941. {
  2942.     if(mDelegate)
  2943.     {
  2944.         return mDelegate->ParseRestOfLine(str);
  2945.     }
  2946.     else
  2947.     {
  2948.         // this method is not supported
  2949.         assert(false);
  2950.         return "";
  2951.     }
  2952. }
  2953.  
  2954. char const *Lexer::ParseBracedSectionExact(idStr &str, int val)
  2955. {
  2956.     if(mDelegate)
  2957.     {
  2958.         return mDelegate->ParseBracedSectionExact(str, val);
  2959.     }
  2960.     else
  2961.     {
  2962.         // this method is not supported
  2963.         assert(false);
  2964.         return "";
  2965.     }
  2966. }
  2967.  
  2968. char const *Lexer::ParseBracedSection(idStr &str)
  2969. {
  2970.     if(mDelegate)
  2971.     {
  2972.         return mDelegate->ParseBracedSection(str);
  2973.     }
  2974.     else
  2975.     {
  2976.         // this method is not supported
  2977.         assert(false);
  2978.         return "";
  2979.     }
  2980. }
  2981.  
  2982. int Lexer::Parse3DMatrix(int z, int y, int x, float *m)
  2983. {
  2984.     if(mDelegate)
  2985.     {
  2986.         return mDelegate->Parse3DMatrix(z, y, x, m);
  2987.     }
  2988.     else
  2989.     {
  2990.         int i;
  2991.  
  2992.         if ( !ExpectTokenString( "(" ) ) {
  2993.             return false;
  2994.         }
  2995.  
  2996.         for ( i = 0 ; i < z; i++ ) {
  2997.             if ( !Parse2DMatrix( y, x, m + i * x*y ) ) {
  2998.                 return false;
  2999.             }
  3000.         }
  3001.  
  3002.         if ( !ExpectTokenString( ")" ) ) {
  3003.             return false;
  3004.         }
  3005.         return true;
  3006.     }
  3007. }
  3008.  
  3009. int Lexer::Parse2DMatrix(int y, int x, float *m)
  3010. {
  3011.     if(mDelegate)
  3012.     {
  3013.         return mDelegate->Parse2DMatrix(y, x, m);
  3014.     }
  3015.     else
  3016.     {
  3017.         int i;
  3018.  
  3019.         if ( !ExpectTokenString( "(" ) ) {
  3020.             return false;
  3021.         }
  3022.  
  3023.         for ( i = 0; i < y; i++ ) {
  3024.             if ( !Parse1DMatrix( x, m + i * x ) ) {
  3025.                 return false;
  3026.             }
  3027.         }
  3028.  
  3029.         if ( !ExpectTokenString( ")" ) ) {
  3030.             return false;
  3031.         }
  3032.         return true;
  3033.     }
  3034. }
  3035.  
  3036. int Lexer::Parse1DMatrixOpenEnded(int MaxCount, float *m)
  3037. {
  3038.     if(mDelegate)
  3039.     {
  3040.         return mDelegate->Parse1DMatrixOpenEnded(MaxCount, m);
  3041.     }
  3042.     else
  3043.     {
  3044.         int i;
  3045.  
  3046.         if ( !ExpectTokenString( "(" ) ) {
  3047.             return 0;
  3048.         }
  3049.  
  3050.         for ( i = 0; i < MaxCount; i++ ) {
  3051.             idToken tok;
  3052.  
  3053.             if (!ReadToken( &tok )) {
  3054.                 return 0;
  3055.             }
  3056.  
  3057.             if ( tok == ")" ) {
  3058.                 return i;
  3059.             }
  3060.  
  3061.             UnreadToken( &tok );
  3062.  
  3063.             m[i] = ParseFloat();
  3064.         }
  3065.  
  3066.         if ( !ExpectTokenString( ")" ) ) {
  3067.             return 0;
  3068.         }
  3069.  
  3070.         return i;
  3071.     }
  3072. }
  3073.  
  3074. int Lexer::Parse1DMatrix(int x, float *m)
  3075. {
  3076.     if(mDelegate)
  3077.     {
  3078.         return mDelegate->Parse1DMatrix(x, m);
  3079.     }
  3080.     else
  3081.     {
  3082.         int i;
  3083.  
  3084.         if ( !ExpectTokenString( "(" ) ) {
  3085.             return false;
  3086.         }
  3087.  
  3088.         for ( i = 0; i < x; i++ ) {
  3089.             m[i] = ParseFloat();
  3090.         }
  3091.  
  3092.         if ( !ExpectTokenString( ")" ) ) {
  3093.             return false;
  3094.         }
  3095.         return true;
  3096.     }
  3097. }
  3098.  
  3099. float Lexer::ParseFloat(bool *errorFlag)
  3100. {
  3101.     if(mDelegate)
  3102.     {
  3103.         return mDelegate->ParseFloat(errorFlag);
  3104.     }
  3105.     else
  3106.     {
  3107.         idToken token;
  3108.  
  3109.         if(EndOfFile())
  3110.         {
  3111.             return 0;
  3112.         }
  3113.  
  3114.         if ( !ReadToken( &token ) ) {
  3115.             Warning( "couldn't read expected floating point number" );
  3116.             return 0;
  3117.         }
  3118.         if ( token.type == TT_PUNCTUATION && token == "-" ) {
  3119.             ExpectTokenType( TT_NUMBER, 0, &token );
  3120.             return -token.GetFloatValue();
  3121.         }
  3122.         else if ( token.type != TT_NUMBER ) {
  3123.             Warning( "expected float value, found '%s'", token.c_str() );
  3124.             }
  3125.         return token.GetFloatValue();
  3126.     }
  3127. }
  3128.  
  3129. bool Lexer::ParseBool()
  3130. {
  3131.     if(mDelegate)
  3132.     {
  3133.         return mDelegate->ParseBool();
  3134.     }
  3135.     else
  3136.     {
  3137.         idToken token;
  3138.  
  3139.         if ( !ExpectTokenType( TT_NUMBER, 0, &token ) ) {
  3140.             Error( "couldn't read expected boolean" );
  3141.             return false;
  3142.         }
  3143.         return ( token.GetIntValue() != 0 );
  3144.     }
  3145. }
  3146.  
  3147. int Lexer::ParseInt()
  3148. {
  3149.     if(mDelegate)
  3150.     {
  3151.         return mDelegate->ParseInt();
  3152.     }
  3153.     else
  3154.     {
  3155.         idToken token;
  3156.  
  3157.         if ( !ReadToken( &token ) ) {
  3158.             Error( "couldn't read expected integer" );
  3159.             return 0;
  3160.         }
  3161.         if ( token.type == TT_PUNCTUATION && token == "-" ) {
  3162.             ExpectTokenType( TT_NUMBER, TT_INTEGER, &token );
  3163.             return -((signed int) token.GetIntValue());
  3164.         }
  3165.         else if ( token.type != TT_NUMBER || token.subtype == TT_FLOAT ) {
  3166.             Error( "expected integer value, found '%s'", token.c_str() );
  3167.         }
  3168.         return token.GetIntValue();
  3169.     }
  3170. }
  3171.  
  3172. int Lexer::ReadTokenOnLine(idToken *token)
  3173. {
  3174.     if(mDelegate)
  3175.     {
  3176.         return mDelegate->ReadTokenOnLine(token);
  3177.     }
  3178.     else
  3179.     {
  3180.         // lines are meaningless in the binary format
  3181.         return ReadToken(token);
  3182.     }
  3183. }
  3184.  
  3185. void Lexer::UnreadToken(idToken const *token)
  3186. {
  3187.     if(mDelegate)
  3188.     {
  3189.         mDelegate->UnreadToken(token);
  3190.     }
  3191.     else
  3192.     {
  3193.         if ( tokenAvailable ) 
  3194.         {
  3195.             idLib::common->FatalError( "Lexer::unreadToken, unread token twice\n" );
  3196.         }
  3197.         unreadToken = *token;
  3198.         tokenAvailable = true;
  3199.         offset -= unreadSize+1;        // the +1 is for the prefix
  3200.     }
  3201. }
  3202.  
  3203. int Lexer::SkipBracedSection(bool parseFirstBrace)
  3204. {
  3205.     if(mDelegate)
  3206.     {
  3207.         return mDelegate->SkipBracedSection(parseFirstBrace);
  3208.     }
  3209.     else
  3210.     {
  3211.         idToken token;
  3212.         int depth;
  3213.  
  3214.         depth = parseFirstBrace ? 0 : 1;
  3215.         do {
  3216.             if ( !ReadToken( &token ) ) {
  3217.                 return false;
  3218.             }
  3219.             if ( token.type == TT_PUNCTUATION ) {
  3220.                 if ( token == "{" ) {
  3221.                     depth++;
  3222.                 } else if ( token == "}" ) {
  3223.                     depth--;
  3224.                 }
  3225.             }
  3226.         } while( depth );
  3227.         return true;
  3228.     }
  3229. }
  3230.  
  3231. int Lexer::SkipRestOfLine()
  3232. {
  3233.     if(mDelegate)
  3234.     {
  3235.         return mDelegate->SkipRestOfLine();
  3236.     }
  3237.     else
  3238.     {
  3239.         // this method is not supported
  3240.         assert(false);
  3241.         return 0;
  3242.     }
  3243. }
  3244.  
  3245. int Lexer::SkipUntilString(char const *str)
  3246. {
  3247.     if(mDelegate)
  3248.     {
  3249.         return mDelegate->SkipUntilString(str);
  3250.     }
  3251.     else
  3252.     {
  3253.         // this method is not supported
  3254.         assert(false);
  3255.         return 0;
  3256.     }
  3257. }
  3258.  
  3259. int Lexer::CheckTokenType(int type, int subtype, idToken *token)
  3260. {
  3261.     if(mDelegate)
  3262.     {
  3263.         return mDelegate->CheckTokenType(type, subtype, token);
  3264.     }
  3265.     else
  3266.     {
  3267.         idToken tok;
  3268.  
  3269.         if (!ReadToken( &tok )) {
  3270.             return 0;
  3271.         }
  3272.         // if the type matches
  3273.         if (tok.type == type && (tok.subtype & subtype) == subtype) {
  3274.             *token = tok;
  3275.             return 1;
  3276.         }
  3277.         return 0;
  3278.     }
  3279. }
  3280.  
  3281. int Lexer::CheckTokenString(char const *string)
  3282. {
  3283.     if(mDelegate)
  3284.     {
  3285.         return mDelegate->CheckTokenString(string);
  3286.     }
  3287.     else
  3288.     {
  3289.         idToken tok;
  3290.  
  3291.         if (!ReadToken( &tok )) {
  3292.             return 0;
  3293.         }
  3294.  
  3295.         // if the token is available
  3296.         if ( tok == string ) {
  3297.             return 1;
  3298.         }
  3299.  
  3300.         UnreadToken( &tok );
  3301.         return 0;
  3302.     }
  3303. }
  3304.  
  3305. int Lexer::ExpectAnyToken(idToken *token)
  3306. {
  3307.     if(mDelegate)
  3308.     {
  3309.         return mDelegate->ExpectAnyToken(token);
  3310.     }
  3311.     else
  3312.     {
  3313.         if (!ReadToken( token )) {
  3314.             Error( "couldn't read expected token" );
  3315.             return 0;
  3316.         }
  3317.         else {
  3318.             return 1;
  3319.         }
  3320.     }
  3321. }
  3322.  
  3323. int Lexer::ExpectTokenType(int type, int subtype, idToken *token)
  3324. {
  3325.     if(mDelegate)
  3326.     {
  3327.         return mDelegate->ExpectTokenType(type, subtype, token);
  3328.     }
  3329.     else
  3330.     {
  3331.         idStr str;
  3332.  
  3333.         if ( !ReadToken( token ) ) {
  3334.             Error( "couldn't read expected token" );
  3335.             return 0;
  3336.         }
  3337.  
  3338.         if ( token->type != type ) {
  3339.             switch( type ) {
  3340.                 case TT_STRING: str = "string"; break;
  3341.                 case TT_LITERAL: str = "literal"; break;
  3342.                 case TT_NUMBER: str = "number"; break;
  3343.                 case TT_NAME: str = "name"; break;
  3344.                 case TT_PUNCTUATION: str = "punctuation"; break;
  3345.                 default: str = "unknown type"; break;
  3346.             }
  3347.             Error( "expected a %s but found '%s'", str.c_str(), token->c_str() );
  3348.             return 0;
  3349.         }
  3350.         if ( token->type == TT_NUMBER ) {
  3351.             if ( (token->subtype & subtype) != subtype ) {
  3352.                 str.Clear();
  3353.                 if ( subtype & TT_DECIMAL ) str = "decimal ";
  3354.                 if ( subtype & TT_HEX ) str = "hex ";
  3355.                 if ( subtype & TT_OCTAL ) str = "octal ";
  3356.                 if ( subtype & TT_BINARY ) str = "binary ";
  3357.                 if ( subtype & TT_UNSIGNED ) str += "unsigned ";
  3358.                 if ( subtype & TT_LONG ) str += "long ";
  3359.                 if ( subtype & TT_FLOAT ) str += "float ";
  3360.                 if ( subtype & TT_INTEGER ) str += "integer ";
  3361.                 str.StripTrailing( ' ' );
  3362.                 Error( "expected %s but found '%s'", str.c_str(), token->c_str() );
  3363.                 return 0;
  3364.             }
  3365.         }
  3366.         else if ( token->type == TT_PUNCTUATION ) {
  3367.             if ( subtype < 0 ) {
  3368.                 Error( "BUG: wrong punctuation subtype" );
  3369.                 return 0;
  3370.             }
  3371.             if ( token->subtype != subtype ) {
  3372.                 Error( "expected '%s' but found '%s'", GetPunctuationFromId( subtype ), token->c_str() );
  3373.                 return 0;
  3374.             }
  3375.         }
  3376.         return 1;
  3377.     }
  3378. }
  3379.  
  3380. int Lexer::ExpectTokenString(char const *string)
  3381. {
  3382.     if(mDelegate)
  3383.     {
  3384.         return mDelegate->ExpectTokenString(string);
  3385.     }
  3386.     else
  3387.     {
  3388.         idToken token;
  3389.  
  3390.         if(!ReadToken( &token ))
  3391.         {
  3392.             Error( "couldn't find expected '%s'", string );
  3393.             return 0;
  3394.         }
  3395.         if( token != string )
  3396.         {
  3397.             Error( "expected '%s' but found '%s'", string, token.c_str() );
  3398.             return 0;
  3399.         }
  3400.         return 1;
  3401.     }
  3402. }
  3403.  
  3404. int Lexer::ReadToken(idToken *token)
  3405. {
  3406.  
  3407. #ifdef LEXER_READ_AHEAD
  3408. #define OBJ &mLexerIOWrapper
  3409. #else
  3410. #define OBJ mFile
  3411. #endif
  3412.     
  3413.     if(mDelegate)
  3414.     {
  3415.         return mDelegate->ReadToken(token);
  3416.     }
  3417.     else
  3418.     {
  3419.         // if there are any unread tokens, use them first
  3420.         if(tokenAvailable)
  3421.         {
  3422.             *token = unreadToken;
  3423.             tokenAvailable = false;
  3424.         }
  3425.         else
  3426.         {
  3427. #ifndef LEXER_READ_AHEAD
  3428.             assert(mFile);
  3429. #endif
  3430.             if(EndOfFile())
  3431.                 return 0;
  3432.             unsigned char prefix = ReadValue<unsigned char>(OBJ);
  3433.             token->Clear();
  3434.  
  3435.             // BTT types are equivalent to the TT types except they are one less, so we add one to get the token type
  3436.             if(BTT_GET_TYPE(prefix) == BTT_PUNCTUATION2)
  3437.                 token->type = TT_PUNCTUATION;
  3438.             else
  3439.                 token->type = BTT_GET_TYPE(prefix)+1;
  3440.  
  3441.             // this is used only to determine if the punctuation was encoded in the prefix or came afterwards as a null terminated string
  3442.             bool encoded = true;
  3443.  
  3444.             switch(token->type)
  3445.             {
  3446.             case TT_STRING: 
  3447.             case TT_NAME:
  3448.             case TT_LITERAL:
  3449.                 if(BTT_GET_STRING_LENGTH(prefix) != 0)
  3450.                 {
  3451.                     // short string
  3452.                     int length = BTT_GET_STRING_LENGTH(prefix);
  3453.                     if ( length == 0 ) {
  3454.                         assert( false );
  3455.                     }
  3456.                     int i;
  3457.                     for( i = 0; i < length; i++ )
  3458.                     {
  3459.                         char c = ReadValue<char>(OBJ);
  3460.                         token->Append(c);
  3461.                     }
  3462.                     // short strings have no null, so we must add one
  3463.                     //token->Append('\0');
  3464.  
  3465.                     token->subtype = token->Length();
  3466.                     unreadSize = token->Length();
  3467.                 }
  3468.                 else
  3469.                 {
  3470.                     // null terminated string
  3471.                     *token = ReadValue<idStr>(OBJ);
  3472.                     token->subtype = token->Length();
  3473.                     unreadSize = token->Length()+1;
  3474.                 }
  3475.                 break;
  3476.             case TT_PUNCTUATION:
  3477.                 switch(BTT_GET_PUNCTUATION(prefix))
  3478.                 {
  3479.                 case BTT_PUNC_ASNULLTERMINATED:
  3480.                     // null terminated string
  3481.                     *token = ReadValue<idStr>(OBJ);
  3482.                     token->subtype = token->Length();
  3483.                     unreadSize = token->Length()+1;
  3484.                     encoded = false;
  3485.                     break;
  3486.                 case BTT_PUNC_RIGHTPAREN:
  3487.                     *token = ")";
  3488.                     break;
  3489.                 case BTT_PUNC_LEFTBRACE:
  3490.                     *token = "{";
  3491.                     break;
  3492.                 case BTT_PUNC_RIGHTBRACE:
  3493.                     *token = "}";
  3494.                     break;
  3495.                 case BTT_PUNC_MINUS:
  3496.                     *token = "-";
  3497.                     break;
  3498.                 case BTT_PUNC_PLUS:
  3499.                     *token = "+";
  3500.                     break;
  3501.                 case BTT_PUNC_COMMA:
  3502.                     *token = ",";
  3503.                     break;
  3504.                 case BTT_PUNC_PLUSPLUS:
  3505.                     *token = "++";
  3506.                     break;
  3507.                 case BTT_PUNC_LEFTBRACKET:
  3508.                     *token = "[";
  3509.                     break;
  3510.                 case BTT_PUNC_RIGHTBRACKET:
  3511.                     *token = "]";
  3512.                     break;
  3513.                 case BTT_PUNC_EQUAL:
  3514.                     *token = "=";
  3515.                     break;
  3516.                 case BTT_PUNC_EQUALEQUAL:
  3517.                     *token = "==";
  3518.                     break;
  3519.                 case BTT_PUNC_NOTEQUAL:
  3520.                     *token = "!=";
  3521.                     break;
  3522.                 case BTT_PUNC_PERCENT:
  3523.                     *token = "%";
  3524.                     break;
  3525.                 case BTT_PUNC_LESSTHAN:
  3526.                     *token = "<";
  3527.                     break;
  3528.                 case BTT_PUNC_GREATERTHAN:
  3529.                     *token = ">";
  3530.                     break;
  3531.                 case BTT_PUNC_LOGICALAND:
  3532.                     *token = "&&";
  3533.                     break;
  3534.                 case BTT_PUNC_AMPERSAND:
  3535.                     *token = "&";
  3536.                     break;
  3537.                 case BTT_PUNC_MINUSMINUS:
  3538.                     *token = "--";
  3539.                     break;
  3540.                 case BTT_PUNC_HASH:
  3541.                     *token = "#";
  3542.                     break;
  3543.                 case BTT_PUNC_LESSOREQUAL:
  3544.                     *token = "<=";
  3545.                     break;
  3546.                 case BTT_PUNC_GREATEROREQUAL:
  3547.                     *token = ">=";
  3548.                     break;
  3549.                 case BTT_PUNC_FORWARDSLASH:
  3550.                     *token = "/";
  3551.                     break;
  3552.                 case BTT_PUNC_SHIFTLEFT:
  3553.                     *token = "<<";
  3554.                     break;
  3555.                 case BTT_PUNC_SHIFTRIGHT:
  3556.                     *token = ">>";
  3557.                     break;
  3558.                 case BTT_PUNC_LEFTPAREN:
  3559.                     *token = "(";
  3560.                     break;
  3561.                 case BTT_PUNC_SEMICOLON:
  3562.                     *token = ";";
  3563.                     break;
  3564.                 case BTT_PUNC_ASTERISK:
  3565.                     *token = "*";
  3566.                     break;
  3567.                 case BTT_PUNC_PERIOD:
  3568.                     *token = ".";
  3569.                     break;
  3570.                 case BTT_PUNC_DOLLARSIGN:
  3571.                     *token = "$";
  3572.                     break;
  3573.                 case BTT_PUNC_PLUSEQUAL:
  3574.                     *token = "+=";
  3575.                     break;
  3576.                 case BTT_PUNC_MINUSEQUAL:
  3577.                     *token = "-=";
  3578.                     break;
  3579.                 case BTT_PUNC_TILDE:
  3580.                     *token = "~";
  3581.                     break;
  3582.                 case BTT_PUNC_EXCLAMATION:
  3583.                     *token = "!";
  3584.                     break;
  3585.                 case BTT_PUNC_PIPE:
  3586.                     *token = "|";
  3587.                     break;
  3588.                 case BTT_PUNC_BACKSLASH:
  3589.                     *token = "\\";
  3590.                     break;
  3591.                 case BTT_PUNC_DOUBLEHASH:
  3592.                     *token = "##";
  3593.                     break;
  3594.                 case BTT_PUNC_TIMESEQUAL:
  3595.                     *token = "*=";
  3596.                     break;
  3597.                 case BTT_PUNC_DOUBLEPIPE:
  3598.                     *token = "||";
  3599.                     break;
  3600.                 case BTT_PUNC_INVERTEDPLING:
  3601.                     *token = "í";
  3602.                     break;
  3603.                 case BTT_PUNC_INVERTEDQUERY:
  3604.                     *token = "┐";
  3605.                     break;
  3606.                 default:
  3607.                     assert(false);        // unrecognized punctuation
  3608.                 }
  3609.                 if(encoded)
  3610.                     unreadSize = 0;        // punctuation encoded in prefix
  3611.                 break;
  3612.             case TT_NUMBER:
  3613.                 {
  3614.                     // number of bytes actually in the stream used to represent this value
  3615.                     unsigned int size = BTT_GET_STORED_SIZE(prefix);
  3616.                     const int buffersize = 100;
  3617.                     char buffer[buffersize];    // big enough buffer for the int to string conversion routines
  3618.  
  3619.                     switch(BTT_GET_SUBTYPE(prefix))
  3620.                     {
  3621.                         case BTT_SUBTYPE_INT:
  3622.                             switch(size)
  3623.                             {
  3624.                             case BTT_STORED_1BYTE:
  3625.                                 token->intvalue = ReadValue<char>(OBJ);
  3626.                                 unreadSize = sizeof(char);
  3627.                                 break;
  3628.                             case BTT_STORED_2BYTE:
  3629.                                 token->intvalue = ReadValue<short>(OBJ);
  3630.                                 unreadSize = sizeof(short);
  3631.                                 break;
  3632.                             case BTT_STORED_4BYTE:
  3633.                                 token->intvalue = ReadValue<int>(OBJ);
  3634.                                 unreadSize = sizeof(int);
  3635.                                 break;
  3636.                             default:
  3637.                                 // invalid stored size for an integer
  3638.                                 assert(false);
  3639.                             }
  3640.  
  3641.                             token->floatvalue = token->intvalue;
  3642.                             // I hate the fact that I have to copy into the string, but there's no way
  3643.                             // of easily knowing whether it is used later or not
  3644.  
  3645.                             // This conversion to a string assumes that long and int are the same
  3646.                             assert(sizeof(long) == sizeof(int));
  3647.  
  3648.                             //ltoa(token->intvalue, buffer, 10);
  3649.                             idStr::snPrintf( buffer, buffersize, "%ld", token->intvalue );
  3650.                             assert(token->intvalue == atol(buffer));
  3651.                             *token = buffer;
  3652.                             token->subtype = TT_INTEGER | TT_DECIMAL | TT_VALUESVALID;
  3653.                         break;
  3654.                         
  3655.                         case BTT_SUBTYPE_UNSIGNEDINT:
  3656.                             switch(size)
  3657.                             {
  3658.                             case BTT_STORED_1BYTE:
  3659.                                 token->intvalue = ReadValue<unsigned char>(OBJ);
  3660.                                 unreadSize = sizeof(unsigned char);
  3661.                                 break;
  3662.                             case BTT_STORED_2BYTE:
  3663.                                 token->intvalue = ReadValue<unsigned short>(OBJ);
  3664.                                 unreadSize = sizeof(unsigned short);
  3665.                                 break;
  3666.                             case BTT_STORED_4BYTE:
  3667.                                 token->intvalue = ReadValue<unsigned int>(OBJ);
  3668.                                 unreadSize = sizeof(unsigned int);
  3669.                                 break;
  3670.                             default:
  3671.                                 // invalid stored size for an unsigned integer
  3672.                                 assert(false);
  3673.                             }
  3674.                             token->floatvalue = token->intvalue;
  3675.  
  3676.                             // I hate the fact that I have to copy into the string, but there's no way
  3677.                             // of easily knowing whether it is used later or not
  3678.  
  3679.                             // This conversion to a string assumes that long and int are the same
  3680.                             assert(sizeof(long) == sizeof(int));
  3681.  
  3682.                             //ultoa(token->intvalue, buffer, 10);
  3683.                             idStr::snPrintf( buffer, buffersize, "%lu", token->intvalue );
  3684.                             assert(token->intvalue == ((unsigned long)atol(buffer)));
  3685.                             *token = buffer;
  3686.                             token->subtype = TT_INTEGER | TT_UNSIGNED | TT_DECIMAL | TT_VALUESVALID;
  3687.                             break;
  3688.  
  3689.                         case BTT_SUBTYPE_FLOAT:
  3690.                             // invalid stored size for a float
  3691.                             assert(sizeof(float) == 4);
  3692.  
  3693.                             switch(size)
  3694.                             {
  3695.                             case BTT_STORED_4BYTE:
  3696.                                 token->floatvalue = ReadValue<float>(OBJ);
  3697.                                 token->intvalue = token->floatvalue;
  3698.                                 unreadSize = sizeof(float);
  3699.                                 break;
  3700.                             case BTT_STORED_2BYTE:        // requested a float, but it was integral, so it was saved that way
  3701.                                 token->floatvalue = ReadValue<short>(OBJ);
  3702.                                 token->intvalue = token->floatvalue;
  3703.                                 unreadSize = sizeof(short);
  3704.                                 break;
  3705.                             case BTT_STORED_1BYTE:        // requested a float, but it was integral, so it was saved that way
  3706.                                 token->floatvalue = ReadValue<char>(OBJ);
  3707.                                 token->intvalue = token->floatvalue;
  3708.                                 unreadSize = sizeof(char);
  3709.                                 break;
  3710.                             default:
  3711.                                 assert(false);
  3712.                             }
  3713.  
  3714.                             // I hate the fact that I have to copy into the string, but there's no way
  3715.                             // of easily knowing whether it is used later or not
  3716.                             idStr::snPrintf( buffer, buffersize, "%f", token->floatvalue );
  3717.                             *token = buffer;
  3718.                             token->subtype = TT_FLOAT | TT_DECIMAL | TT_SINGLE_PRECISION | TT_VALUESVALID;
  3719.  
  3720.                             unreadSize = sizeof(float);
  3721.                             break;
  3722.  
  3723.                         case BTT_SUBTYPE_DOUBLE:
  3724.                             // invalid stored size for a double
  3725.                             assert(sizeof(double) == 8);
  3726.  
  3727.                             // doubles are stored as floats since the original text file never uses full double precision anyway
  3728.                             //assert(size == BTT_STORED_4BYTE);
  3729.  
  3730.                             switch(size)
  3731.                             {
  3732.                             case BTT_STORED_4BYTE:
  3733.                                 token->floatvalue = ReadValue<float>(OBJ);
  3734.                                 token->intvalue = token->floatvalue;
  3735.                                 unreadSize = sizeof(float);
  3736.                                 break;
  3737.                             case BTT_STORED_2BYTE:        // requested a float, but it was integral, so it was saved that way
  3738.                                 token->floatvalue = ReadValue<short>(OBJ);
  3739.                                 token->intvalue = token->floatvalue;
  3740.                                 unreadSize = sizeof(short);
  3741.                                 break;
  3742.                             case BTT_STORED_1BYTE:        // requested a float, but it was integral, so it was saved that way
  3743.                                 token->floatvalue = ReadValue<char>(OBJ);
  3744.                                 token->intvalue = token->floatvalue;
  3745.                                 unreadSize = sizeof(char);
  3746.                                 break;
  3747.                             default:
  3748.                                 assert(false);
  3749.                             }
  3750.  
  3751.                             // I hate the fact that I have to copy into the string, but there's no way
  3752.                             // of easily knowing whether it is used later or not
  3753.                             idStr::snPrintf( buffer, buffersize, "%f", token->floatvalue );
  3754.                             *token = buffer;
  3755.                             token->subtype = TT_FLOAT | TT_DECIMAL | TT_DOUBLE_PRECISION | TT_VALUESVALID;
  3756.                             break;
  3757.                     }
  3758.                 }
  3759.                 break;
  3760.  
  3761.             default:
  3762.                 // unsupported binary type
  3763.                 assert(false);
  3764.             }
  3765.         }
  3766.  
  3767.         //common->Warning("Read Token: '%s    (int: %d)(float: %f)'\n", token->c_str(), token->GetIntValue(), token->GetFloatValue());
  3768.         //common->Printf("Read Token: %s\n", token->c_str());
  3769.         offset += unreadSize+1;        // the +1 is for the prefix
  3770.         return 1;
  3771.     }
  3772. }
  3773.  
  3774. int Lexer::IsLoaded()
  3775. {
  3776.     if(mDelegate)
  3777.     {
  3778.         return mDelegate->IsLoaded();
  3779.     }
  3780.     else
  3781.     {
  3782. #ifdef LEXER_READ_AHEAD
  3783.         return mLexerIOWrapper.IsLoaded();
  3784. #else
  3785.         return mFile != NULL;
  3786. #endif
  3787.     }
  3788. }
  3789.  
  3790. void Lexer::FreeSource()
  3791. {
  3792. #ifdef LEXER_READ_AHEAD
  3793.     mLexerIOWrapper.Close();
  3794. #else
  3795.     if(mFile)
  3796.     {
  3797.         idLib::fileSystem->CloseFile(mFile);
  3798.         mFile = NULL;
  3799.     }
  3800. #endif
  3801.  
  3802.     if(mDelegate)
  3803.     {
  3804.         delete mDelegate;
  3805.         mDelegate = NULL;
  3806.     }
  3807. }
  3808.  
  3809. int Lexer::LoadMemory(char const *ptr, int length, char const *name, int startLine)
  3810. {
  3811.     if(mDelegate)
  3812.     {
  3813.         return mDelegate->LoadMemory(ptr, length, name, startLine);
  3814.     }
  3815.     else
  3816.     {
  3817.         // this is essentially a no op
  3818.         return true;
  3819.     }
  3820. }
  3821.  
  3822. int Lexer::LoadFile(char const *filename, bool OSPath)
  3823. {
  3824.     if(mDelegate)
  3825.     {
  3826.         return mDelegate->LoadFile(filename, OSPath);
  3827.     }
  3828.     else
  3829.     {
  3830.         idStr fullName;
  3831.         FreeSource();
  3832.  
  3833.         fullName = filename;
  3834.         fullName.Append(sCompiledFileSuffix);
  3835.         bool binaryFound = OpenFile(fullName, OSPath);
  3836.         if(binaryFound)
  3837.         {
  3838.             return binaryFound;
  3839.         }
  3840.         else
  3841.         {
  3842.             mDelegate = new idLexer(filename, mFlags, OSPath);
  3843.             int isLoaded = mDelegate->IsLoaded();
  3844.             if(isLoaded)
  3845.             {
  3846.                 // don't do this right now until I clean up the Lexer class
  3847.                 if(mFlags & LEXFL_READBINARY)
  3848.                 {
  3849.                     Warning("%s not found, loading ascii version", fullName.c_str());
  3850.                 }
  3851.             }
  3852.             else
  3853.             {
  3854.                 // didn't find the ascii version either, make sure and clean up in case this lexer is reused
  3855.                 delete mDelegate;
  3856.                 mDelegate = NULL;
  3857.             }
  3858.  
  3859.             return isLoaded;
  3860.         }
  3861.     }
  3862. }
  3863.  
  3864. void Lexer::WriteBinaryToken(idToken *tok)
  3865. {
  3866.     if(mDelegate)
  3867.     {
  3868.         mDelegate->WriteBinaryToken(tok);
  3869.     }
  3870.     else
  3871.     {
  3872.         // can't write out an already binary file
  3873.         assert(false);
  3874.     }
  3875. }
  3876.  
  3877. bool Lexer::OpenFile(char const *filename, bool OSPath)
  3878. {
  3879.     idStr pathname;
  3880.     
  3881.     if ( !OSPath && ( baseFolder[0] != '\0' ) ) {
  3882.         pathname = va( "%s/%s", baseFolder, filename );
  3883.     } else {
  3884.         pathname = filename;
  3885.     }
  3886.     
  3887. #ifdef LEXER_READ_AHEAD
  3888.     if ( !mLexerIOWrapper.OpenFile( pathname, OSPath ) ) {
  3889.         return false;
  3890.     }
  3891. #else
  3892.     if ( OSPath ) {
  3893.         mFile = idLib::fileSystem->OpenExplicitFileRead( pathname );
  3894.     } else {
  3895.         mFile = idLib::fileSystem->OpenFileRead( pathname );
  3896.     }
  3897.     if ( !mFile ) {
  3898.         return false;
  3899.     }
  3900. #endif
  3901.  
  3902.     return true;
  3903. }
  3904.  
  3905. void Lexer::SetBaseFolder( const char *path ) {
  3906.     idStr::Copynz( baseFolder, path, sizeof( baseFolder ) );
  3907. }
  3908.  
  3909.  
  3910. // RAVEN BEGIN
  3911. // dluetscher: added method to parse a structure array that is made up of numerics (floats, ints), and stores them in the given storage
  3912. void Lexer::ParseNumericStructArray( int numStructElements, int tokenSubTypeStructElements[], int arrayCount, byte *arrayStorage )
  3913. {
  3914.     if(mDelegate)
  3915.     {
  3916.         mDelegate->ParseNumericStructArray( numStructElements, tokenSubTypeStructElements, arrayCount, arrayStorage );
  3917.     }
  3918.     else
  3919.     {
  3920.         int arrayOffset, curElement;
  3921.  
  3922.         for ( arrayOffset = 0; arrayOffset < arrayCount; arrayOffset++ )
  3923.         {
  3924.             for ( curElement = 0; curElement < numStructElements; curElement++ )
  3925.             {
  3926.                 if ( tokenSubTypeStructElements[curElement] & TT_FLOAT )
  3927.                 {
  3928.                     *(float*)arrayStorage = Lexer::ParseFloat();
  3929.                     arrayStorage += sizeof(float);
  3930.                 }
  3931.                 else
  3932.                 {
  3933.                     *(int*)arrayStorage = Lexer::ParseInt();
  3934.                     arrayStorage += sizeof(int);
  3935.                 }
  3936.             }
  3937.         }
  3938.     }
  3939. }
  3940. // RAVEN END
  3941.  
  3942.  
  3943. char idLexer::baseFolder[256];
  3944. // RAVEN END
  3945.