f4bfef93579aa877d65574f32348647a9415f142
[WebKit-https.git] / Source / ThirdParty / ANGLE / src / compiler / preprocessor / scanner.c
1 /****************************************************************************\
2 Copyright (c) 2002, NVIDIA Corporation.
3
4 NVIDIA Corporation("NVIDIA") supplies this software to you in
5 consideration of your agreement to the following terms, and your use,
6 installation, modification or redistribution of this NVIDIA software
7 constitutes acceptance of these terms.  If you do not agree with these
8 terms, please do not use, install, modify or redistribute this NVIDIA
9 software.
10
11 In consideration of your agreement to abide by the following terms, and
12 subject to these terms, NVIDIA grants you a personal, non-exclusive
13 license, under NVIDIA's copyrights in this original NVIDIA software (the
14 "NVIDIA Software"), to use, reproduce, modify and redistribute the
15 NVIDIA Software, with or without modifications, in source and/or binary
16 forms; provided that if you redistribute the NVIDIA Software, you must
17 retain the copyright notice of NVIDIA, this notice and the following
18 text and disclaimers in all such redistributions of the NVIDIA Software.
19 Neither the name, trademarks, service marks nor logos of NVIDIA
20 Corporation may be used to endorse or promote products derived from the
21 NVIDIA Software without specific prior written permission from NVIDIA.
22 Except as expressly stated in this notice, no other rights or licenses
23 express or implied, are granted by NVIDIA herein, including but not
24 limited to any patent rights that may be infringed by your derivative
25 works or by other works in which the NVIDIA Software may be
26 incorporated. No hardware is licensed hereunder. 
27
28 THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT
29 WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED,
30 INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE,
31 NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR
32 ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER
33 PRODUCTS.
34
35 IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT,
36 INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
37 TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
38 USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY
39 OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE
40 NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT,
41 TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF
42 NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 \****************************************************************************/
44 //
45 // scanner.c
46 //
47
48 #include <assert.h>
49 #include <stdarg.h>
50 #include <stdio.h>
51 #include <stdlib.h>
52 #include <string.h>
53
54 #if 0
55     #include <ieeefp.h>
56 #else
57     #define isinff(x) (((*(int *)&(x) & 0x7f800000L)==0x7f800000L) && \
58                        ((*(int *)&(x) & 0x007fffffL)==0000000000L))
59 #endif
60
61 #include "compiler/preprocessor/slglobals.h"
62 #include "compiler/util.h"
63
64 typedef struct StringInputSrc {
65     InputSrc base;
66     char *p;
67 } StringInputSrc;
68
69 static int eof_scan(InputSrc *is, yystypepp * yylvalpp)
70 {
71     return EOF;
72 } // eof_scan
73
74 static void noop(InputSrc *in, int ch, yystypepp * yylvalpp) {}
75
76 static InputSrc eof_inputsrc = { 0, &eof_scan, &eof_scan, &noop };
77
78 static int byte_scan(InputSrc *, yystypepp * yylvalpp);
79
80 #define EOL_SY '\n'
81
82 #if defined(_MSC_VER)
83     #define DBG_BREAKPOINT() __asm int 3
84 #elif defined(_M_AMD64)
85     #define DBG_BREAKPOINT() assert(!"Dbg_Breakpoint");
86 #else
87     #define DBG_BREAKPOINT()
88 #endif
89
90 #if defined(_MSC_VER) && !defined(_M_AMD64)
91     __int64 RDTSC ( void ) {
92
93         __int64 v;
94     
95         __asm __emit 0x0f
96         __asm __emit 0x31
97         __asm mov dword ptr v, eax
98         __asm mov dword ptr v+4, edx
99     
100         return v;
101     }
102 #endif
103
104
105 int InitScanner(CPPStruct *cpp)
106 {
107     // Add various atoms needed by the CPP line scanner:
108     if (!InitCPP())
109         return 0;
110
111     cpp->mostRecentToken = 0;
112     cpp->tokenLoc = &cpp->ltokenLoc;
113
114     cpp->ltokenLoc.file = 0;
115     cpp->ltokenLoc.line = 0;
116
117     cpp->currentInput = &eof_inputsrc;
118     cpp->previous_token = '\n';
119     cpp->pastFirstStatement = 0;
120
121     return 1;
122 } // InitScanner
123
124 int FreeScanner(void)
125 {
126     return (FreeCPP());
127 }
128
129 /*
130  * str_getch()
131  * takes care of reading from multiple strings.
132  * returns the next-char from the input stream.
133  * returns EOF when the complete shader is parsed.
134  */
135 static int str_getch(StringInputSrc *in)
136 {
137     for(;;){
138        if (*in->p){
139           if (*in->p == '\n') {
140              in->base.line++;
141              IncLineNumber();
142           }
143           return *in->p++;
144        }
145        if(++(cpp->PaWhichStr) < cpp->PaArgc){
146           free(in);
147           SetStringNumber(cpp->PaWhichStr);
148           SetLineNumber(1);
149           ScanFromString(cpp->PaArgv[cpp->PaWhichStr]);
150           in=(StringInputSrc*)cpp->currentInput;
151           continue;             
152        }
153        else{
154           cpp->currentInput = in->base.prev;
155           cpp->PaWhichStr=0;
156           free(in);
157           return EOF;
158        }  
159     }
160 } // str_getch
161
162 static void str_ungetch(StringInputSrc *in, int ch, yystypepp *type) {
163     if (in->p[-1] == ch)in->p--;
164     else {
165         *(in->p)='\0'; //this would take care of shifting to the previous string.
166         cpp->PaWhichStr--;
167     }  
168     if (ch == '\n') {
169         in->base.line--;
170         DecLineNumber();
171     }
172 } // str_ungetch
173
174 int ScanFromString(const char *s)
175 {
176     
177     StringInputSrc *in = malloc(sizeof(StringInputSrc));
178     memset(in, 0, sizeof(StringInputSrc));
179     in->p = s;
180     in->base.line = 1;
181     in->base.scan = byte_scan;
182     in->base.getch = (int (*)(InputSrc *, yystypepp *))str_getch;
183     in->base.ungetch = (void (*)(InputSrc *, int, yystypepp *))str_ungetch;
184     in->base.prev = cpp->currentInput;
185     cpp->currentInput = &in->base;
186
187     return 1;
188 } // ScanFromString;
189
190
191 ///////////////////////////////////////////////////////////////////////////////////////////////
192 /////////////////////////////////// Floating point constants: /////////////////////////////////
193 ///////////////////////////////////////////////////////////////////////////////////////////////
194
195 #define APPEND_CHAR_S(ch, str, len, max_len) \
196       if (len < max_len) { \
197           str[len++] = ch; \
198       } else if (!alreadyComplained) { \
199           CPPErrorToInfoLog("BUFFER OVERFLOW"); \
200           alreadyComplained = 1; \
201       }
202
203 /*
204  * lFloatConst() - Scan a floating point constant.  Assumes that the scanner
205  *         has seen at least one digit, followed by either a decimal '.' or the
206  *         letter 'e'.
207  * ch - '.' or 'e'
208  * len - length of string already copied into yylvalpp->symbol_name.
209  */
210
211 static int lFloatConst(int ch, int len, yystypepp * yylvalpp)
212 {
213     int alreadyComplained = 0;
214     assert((ch == '.') || (ch == 'e') || (ch == 'E'));
215
216     if (ch == '.') {
217         do {
218             APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
219             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
220         } while (ch >= '0' && ch <= '9');
221     }
222
223     // Exponent:
224     if (ch == 'e' || ch == 'E') {
225         APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
226         ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
227         if (ch == '+') {
228             APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
229             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
230         } else if (ch == '-') {
231             APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
232             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
233         }
234         if (ch >= '0' && ch <= '9') {
235             while (ch >= '0' && ch <= '9') {
236                 APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
237                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
238             }
239         } else {
240             CPPErrorToInfoLog("EXPONENT INVALID");
241         }
242     }
243     cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
244
245     assert(len <= MAX_SYMBOL_NAME_LEN);
246     yylvalpp->symbol_name[len] = '\0';
247     yylvalpp->sc_fval = (float) atof_dot(yylvalpp->symbol_name);
248     if (isinff(yylvalpp->sc_fval)) {
249         CPPErrorToInfoLog("FLOAT CONSTANT OVERFLOW");
250     }
251     return CPP_FLOATCONSTANT;
252 } // lFloatConst
253
254 ///////////////////////////////////////////////////////////////////////////////////////////////
255 ///////////////////////////////////////// Normal Scanner //////////////////////////////////////
256 ///////////////////////////////////////////////////////////////////////////////////////////////
257     
258 static int byte_scan(InputSrc *in, yystypepp * yylvalpp)
259 {
260     char string_val[MAX_STRING_LEN + 1];
261     int alreadyComplained = 0;
262     int len, ch, ii, ival = 0;
263
264     for (;;) {
265         yylvalpp->sc_int = 0;
266         ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
267  
268         while (ch == ' ' || ch == '\t' || ch == '\r') {
269             yylvalpp->sc_int = 1;
270             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
271         }
272         
273         cpp->ltokenLoc.file = cpp->currentInput->name;
274         cpp->ltokenLoc.line = cpp->currentInput->line;
275         alreadyComplained = 0;
276         len = 0;
277         switch (ch) {
278         default:
279             return ch; // Single character token
280         case EOF:
281             return -1;
282         case 'A': case 'B': case 'C': case 'D': case 'E':
283         case 'F': case 'G': case 'H': case 'I': case 'J':
284         case 'K': case 'L': case 'M': case 'N': case 'O':
285         case 'P': case 'Q': case 'R': case 'S': case 'T':
286         case 'U': case 'V': case 'W': case 'X': case 'Y':
287         case 'Z': case '_':
288         case 'a': case 'b': case 'c': case 'd': case 'e':
289         case 'f': case 'g': case 'h': case 'i': case 'j':
290         case 'k': case 'l': case 'm': case 'n': case 'o':
291         case 'p': case 'q': case 'r': case 's': case 't':
292         case 'u': case 'v': case 'w': case 'x': case 'y':
293         case 'z':            
294             do {
295                 APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
296                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
297             } while ((ch >= 'a' && ch <= 'z') ||
298                      (ch >= 'A' && ch <= 'Z') ||
299                      (ch >= '0' && ch <= '9') ||
300                      ch == '_');
301             assert(len <= MAX_SYMBOL_NAME_LEN);
302             yylvalpp->symbol_name[len] = '\0';
303             cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
304             yylvalpp->sc_ident = LookUpAddString(atable, yylvalpp->symbol_name);
305             return CPP_IDENTIFIER;
306             break;
307         case '0':
308             APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
309             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
310             if (ch == 'x' || ch == 'X') {  // hexadecimal integer constants
311                 APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
312                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
313                 if ((ch >= '0' && ch <= '9') ||
314                     (ch >= 'A' && ch <= 'F') ||
315                     (ch >= 'a' && ch <= 'f'))
316                 {
317                     ival = 0;
318                     do {
319                         if ((ival <= 0x0fffffff) && (len < MAX_SYMBOL_NAME_LEN)) {
320                             yylvalpp->symbol_name[len++] = ch;
321                             if (ch >= '0' && ch <= '9') {
322                                 ii = ch - '0';
323                             } else if (ch >= 'A' && ch <= 'F') {
324                                 ii = ch - 'A' + 10;
325                             } else {
326                                 ii = ch - 'a' + 10;
327                             }
328                             ival = (ival << 4) | ii;
329                         } else if (!alreadyComplained) {
330                             CPPErrorToInfoLog("HEX CONSTANT OVERFLOW");
331                             alreadyComplained = 1;
332                         }
333                         ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
334                     } while ((ch >= '0' && ch <= '9') ||
335                              (ch >= 'A' && ch <= 'F') ||
336                              (ch >= 'a' && ch <= 'f'));
337                 } else {
338                     CPPErrorToInfoLog("HEX CONSTANT INVALID");
339                 }
340                 assert(len <= MAX_SYMBOL_NAME_LEN);
341                 yylvalpp->symbol_name[len] = '\0';
342                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
343                 yylvalpp->sc_int = ival;
344                 return CPP_INTCONSTANT;
345             } else if (ch >= '0' && ch <= '7') { // octal integer constants
346                 ival = 0;
347                 do {
348                     if ((ival <= 0x1fffffff) && (len < MAX_SYMBOL_NAME_LEN)) {
349                         yylvalpp->symbol_name[len++] = ch;
350                         ii = ch - '0';
351                         ival = (ival << 3) | ii;
352                     } else if (!alreadyComplained) {
353                         CPPErrorToInfoLog("OCT CONSTANT OVERFLOW");
354                         alreadyComplained = 1;
355                     }
356                     ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
357                 } while (ch >= '0' && ch <= '7');
358                 if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'h' || ch == 'x'|| ch == 'E') 
359                      return lFloatConst(ch, len, yylvalpp);
360                 assert(len <= MAX_SYMBOL_NAME_LEN);
361                 yylvalpp->symbol_name[len] = '\0';
362                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
363                 yylvalpp->sc_int = ival;
364                 return CPP_INTCONSTANT;
365             } else {
366                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
367                 ch = '0';
368             }
369             // Fall through...
370         case '1': case '2': case '3': case '4':
371         case '5': case '6': case '7': case '8': case '9':
372             do {
373                 APPEND_CHAR_S(ch, yylvalpp->symbol_name, len, MAX_SYMBOL_NAME_LEN);
374                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
375             } while (ch >= '0' && ch <= '9');
376             if (ch == '.' || ch == 'e' || ch == 'f' || ch == 'h' || ch == 'x'|| ch == 'E') {
377                 return lFloatConst(ch, len, yylvalpp);
378             } else {
379                 assert(len <= MAX_SYMBOL_NAME_LEN);
380                 yylvalpp->symbol_name[len] = '\0';
381                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
382                 ival = 0;
383                 for (ii = 0; ii < len; ii++) {
384                     ch = yylvalpp->symbol_name[ii] - '0';
385                     ival = ival*10 + ch;
386                     if ((ival > 214748364) || (ival == 214748364 && ch >= 8)) {
387                         CPPErrorToInfoLog("INTEGER CONSTANT OVERFLOW");
388                         break;
389                     }
390                 }
391                 yylvalpp->sc_int = ival;
392                 if(ival==0)
393                    strcpy(yylvalpp->symbol_name,"0");
394                 return CPP_INTCONSTANT;
395             }
396             break;
397         case '-':
398             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
399             if (ch == '-') {
400                 return CPP_DEC_OP;
401             } else if (ch == '=') {
402                 return CPP_SUB_ASSIGN;
403             } else {
404                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
405                 return '-';
406             }
407         case '+':
408             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
409             if (ch == '+') {
410                 return CPP_INC_OP;
411             } else if (ch == '=') {
412                 return CPP_ADD_ASSIGN;
413             } else {
414                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
415                 return '+';
416             }
417         case '*':
418             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
419             if (ch == '=') {
420                 return CPP_MUL_ASSIGN;
421             } else {
422                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
423                 return '*';
424             }
425         case '%':
426             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
427             if (ch == '=') {
428                 return CPP_MOD_ASSIGN;
429             } else if (ch == '>'){
430                 return CPP_RIGHT_BRACE;
431             } else {
432                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
433                 return '%';
434             }
435         case ':':
436             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
437             if (ch == '>') {
438                 return CPP_RIGHT_BRACKET;
439             } else {
440                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
441                 return ':';
442             }
443         case '^':
444             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
445             if (ch == '^') {
446                 return CPP_XOR_OP;
447             } else {
448                 if (ch == '=')
449                     return CPP_XOR_ASSIGN;
450                 else{
451                   cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
452                   return '^';
453                 }
454             }
455         
456         case '=':
457             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
458             if (ch == '=') {
459                 return CPP_EQ_OP;
460             } else {
461                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
462                 return '=';
463             }
464         case '!':
465             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
466             if (ch == '=') {
467                 return CPP_NE_OP;
468             } else {
469                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
470                 return '!';
471             }
472         case '|':
473             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
474             if (ch == '|') {
475                 return CPP_OR_OP;
476             } else {
477                 if (ch == '=')
478                     return CPP_OR_ASSIGN;
479                 else{
480                   cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
481                   return '|';
482                 }
483             }
484         case '&':
485             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
486             if (ch == '&') {
487                 return CPP_AND_OP;
488             } else {
489                 if (ch == '=')
490                     return CPP_AND_ASSIGN;
491                 else{
492                   cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
493                   return '&';
494                 }
495             }
496         case '<':
497             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
498             if (ch == '<') {
499                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
500                 if(ch == '=')
501                     return CPP_LEFT_ASSIGN;
502                 else{
503                     cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
504                     return CPP_LEFT_OP;
505                 }
506             } else {
507                 if (ch == '=') {
508                     return CPP_LE_OP;
509                 } else {
510                     if (ch == '%')
511                         return CPP_LEFT_BRACE;
512                     else if (ch == ':')
513                         return CPP_LEFT_BRACKET;
514                     else{
515                         cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
516                         return '<';
517                     }
518                 }
519             }
520         case '>':
521             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
522             if (ch == '>') {
523                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
524                 if(ch == '=')
525                     return CPP_RIGHT_ASSIGN;
526                 else{
527                     cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
528                     return CPP_RIGHT_OP;
529                 }
530             } else {
531                 if (ch == '=') {
532                     return CPP_GE_OP;
533                 } else {
534                     cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
535                     return '>';
536                 }
537             }
538         case '.':
539             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
540             if (ch >= '0' && ch <= '9') {
541                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
542                 return lFloatConst('.', 0, yylvalpp);
543             } else {
544                 if (ch == '.') {
545                     return -1; // Special EOF hack
546                 } else {
547                     cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
548                     return '.';
549                 }
550             }
551         case '/':
552             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
553             if (ch == '/') {
554                 do {
555                     ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
556                 } while (ch != '\n' && ch != EOF);
557                 if (ch == EOF)
558                     return -1;
559                 return '\n';
560             } else if (ch == '*') {
561                 int nlcount = 0;
562                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
563                 do {
564                     while (ch != '*') {
565                         if (ch == '\n') nlcount++;
566                         if (ch == EOF) {
567                             CPPErrorToInfoLog("EOF IN COMMENT");
568                             return -1;
569                         }
570                         ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
571                     }
572                     ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
573                     if (ch == EOF) {
574                         CPPErrorToInfoLog("EOF IN COMMENT");
575                         return -1;
576                     }
577                 } while (ch != '/');
578                 if (nlcount) {
579                     return '\n';
580                 }
581                 // Go try it again...
582             } else if (ch == '=') {
583                 return CPP_DIV_ASSIGN;
584             } else {
585                 cpp->currentInput->ungetch(cpp->currentInput, ch, yylvalpp);
586                 return '/';
587             }
588             break;
589         case '"':
590             ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
591             while (ch != '"' && ch != '\n' && ch != EOF) {
592                 if (ch == '\\') {
593                     CPPErrorToInfoLog("The line continuation character (\\) is not part of the OpenGL ES Shading Language");
594                     return -1;
595                 }
596                 APPEND_CHAR_S(ch, string_val, len, MAX_STRING_LEN);
597                 ch = cpp->currentInput->getch(cpp->currentInput, yylvalpp);
598             };
599             assert(len <= MAX_STRING_LEN);
600             string_val[len] = '\0';
601             if (ch == '"') {
602                 yylvalpp->sc_ident = LookUpAddString(atable, string_val);
603                 return CPP_STRCONSTANT;
604             } else {
605                 CPPErrorToInfoLog("EOL IN STRING");
606                 return ERROR_SY;
607             }
608             break;
609         }
610     }
611 } // byte_scan
612
613 int yylex_CPP(char* buf, int maxSize)
614 {    
615     yystypepp yylvalpp;
616     int token = '\n';   
617
618     for(;;) {
619
620         char* tokenString = 0;
621         token = cpp->currentInput->scan(cpp->currentInput, &yylvalpp);
622         if(check_EOF(token))
623             return 0;
624         if (token == '#') {
625             if (cpp->previous_token == '\n'|| cpp->previous_token == 0) {
626                 token = readCPPline(&yylvalpp);
627                 if(check_EOF(token))
628                     return 0;
629                 continue;
630             } else {
631                 CPPErrorToInfoLog("preprocessor command must not be preceded by any other statement in that line");
632                 return 0;
633             }
634         }
635         cpp->previous_token = token;
636         // expand macros
637         if (token == CPP_IDENTIFIER && MacroExpand(yylvalpp.sc_ident, &yylvalpp)) {
638             cpp->pastFirstStatement = 1;
639             continue;
640         }
641
642         if (token == '\n')
643             continue;
644         cpp->pastFirstStatement = 1;
645
646         if (token == CPP_IDENTIFIER) {
647             tokenString = GetStringOfAtom(atable,yylvalpp.sc_ident);
648         } else if (token == CPP_FLOATCONSTANT || token == CPP_INTCONSTANT){
649             tokenString = yylvalpp.symbol_name;
650         } else {
651             tokenString = GetStringOfAtom(atable,token);
652         }
653
654         if (tokenString) {
655             int len = strlen(tokenString);
656             cpp->tokensBeforeEOF = 1;
657             if (len >= maxSize) {
658                 return maxSize;
659             } else  if (len > 0) {
660                 strcpy(buf, tokenString);
661                 return len;
662             }
663
664             return 0;
665         }
666     }
667
668     return 0;
669 } // yylex
670
671 //Checks if the token just read is EOF or not.
672 int check_EOF(int token)
673 {
674    if(token==-1){
675        if(cpp->ifdepth >0){
676         CPPErrorToInfoLog("#endif missing!! Compilation stopped");
677         cpp->CompileError=1;
678        }
679       return 1;
680    }
681    return 0;
682 }
683
684 ///////////////////////////////////////////////////////////////////////////////////////////////
685 /////////////////////////////////////// End of scanner.c //////////////////////////////////////
686 ///////////////////////////////////////////////////////////////////////////////////////////////
687