Home | History | Annotate | Download | only in compiler 
      1 /*
      2 //
      3 // Copyright (c) 2002-2010 The ANGLE Project Authors. All rights reserved.
      4 // Use of this source code is governed by a BSD-style license that can be
      5 // found in the LICENSE file.
      6 //
      7 
      8 This file contains the Lex specification for GLSL ES.
      9 Based on ANSI C grammar, Lex specification:
     10 http://www.lysator.liu.se/c/ANSI-C-grammar-l.html
     11 
     12 IF YOU MODIFY THIS FILE YOU ALSO NEED TO RUN generate_glslang_lexer.sh,
     13 WHICH GENERATES THE GLSL ES LEXER (glslang_lex.cpp).
     14 */
     15 
     16 %top{
     17 //
     18 // Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
     19 // Use of this source code is governed by a BSD-style license that can be
     20 // found in the LICENSE file.
     21 //
     22 
     23 // This file is auto-generated by generate_glslang_lexer.sh. DO NOT EDIT!
     24 }
     25 
     26 %{
     27 #include "compiler/glslang.h"
     28 #include "compiler/ParseHelper.h"
     29 #include "compiler/util.h"
     30 #include "glslang_tab.h"
     31 
     32 /* windows only pragma */
     33 #ifdef _MSC_VER
     34 #pragma warning(disable : 4102)
     35 #endif
     36 
     37 #define YY_USER_ACTION yylval->lex.line = yylineno;
     38 #define YY_INPUT(buf, result, max_size) \
     39     result = string_input(buf, max_size, yyscanner);
     40 
     41 static int string_input(char* buf, int max_size, yyscan_t yyscanner);
     42 static int check_type(yyscan_t yyscanner);
     43 static int reserved_word(yyscan_t yyscanner);
     44 %}
     45 
     46 %option noyywrap nounput never-interactive
     47 %option yylineno reentrant bison-bridge
     48 %option stack
     49 %option extra-type="TParseContext*"
     50 %x COMMENT FIELDS
     51 
     52 D           [0-9]
     53 L           [a-zA-Z_]
     54 H           [a-fA-F0-9]
     55 E           [Ee][+-]?{D}+
     56 O           [0-7]
     57 
     58 %%
     59 
     60 %{
     61     TParseContext* context = yyextra;
     62 %}
     63 
     64     /* Single-line comments */
     65 "//"[^\n]* ;
     66 
     67     /* Multi-line comments */
     68 "/*"           { yy_push_state(COMMENT, yyscanner); }
     69 <COMMENT>. |
     70 <COMMENT>\n ;
     71 <COMMENT>"*/"  { yy_pop_state(yyscanner); }
     72 
     73 "invariant"    { return(INVARIANT); }
     74 "highp"        { return(HIGH_PRECISION); }
     75 "mediump"      { return(MEDIUM_PRECISION); }
     76 "lowp"         { return(LOW_PRECISION); }
     77 "precision"    { return(PRECISION); }
     78 
     79 "attribute"    { return(ATTRIBUTE); }
     80 "const"        { return(CONST_QUAL); }
     81 "uniform"      { return(UNIFORM); }
     82 "varying"      { return(VARYING); }
     83 
     84 "break"        { return(BREAK); }
     85 "continue"     { return(CONTINUE); }
     86 "do"           { return(DO); }
     87 "for"          { return(FOR); }
     88 "while"        { return(WHILE); }
     89 
     90 "if"           { return(IF); }
     91 "else"         { return(ELSE); }
     92 
     93 "in"           { return(IN_QUAL); }
     94 "out"          { return(OUT_QUAL); }
     95 "inout"        { return(INOUT_QUAL); }
     96 
     97 "float"        { context->lexAfterType = true; return(FLOAT_TYPE); }
     98 "int"          { context->lexAfterType = true; return(INT_TYPE); }
     99 "void"         { context->lexAfterType = true; return(VOID_TYPE); }
    100 "bool"         { context->lexAfterType = true; return(BOOL_TYPE); }
    101 "true"         { yylval->lex.b = true;  return(BOOLCONSTANT); }
    102 "false"        { yylval->lex.b = false; return(BOOLCONSTANT); }
    103 
    104 "discard"      { return(DISCARD); }
    105 "return"       { return(RETURN); }
    106 
    107 "mat2"         { context->lexAfterType = true; return(MATRIX2); }
    108 "mat3"         { context->lexAfterType = true; return(MATRIX3); }
    109 "mat4"         { context->lexAfterType = true; return(MATRIX4); }
    110 
    111 "vec2"         { context->lexAfterType = true; return (VEC2); }
    112 "vec3"         { context->lexAfterType = true; return (VEC3); }
    113 "vec4"         { context->lexAfterType = true; return (VEC4); }
    114 "ivec2"        { context->lexAfterType = true; return (IVEC2); }
    115 "ivec3"        { context->lexAfterType = true; return (IVEC3); }
    116 "ivec4"        { context->lexAfterType = true; return (IVEC4); }
    117 "bvec2"        { context->lexAfterType = true; return (BVEC2); }
    118 "bvec3"        { context->lexAfterType = true; return (BVEC3); }
    119 "bvec4"        { context->lexAfterType = true; return (BVEC4); }
    120 
    121 "sampler2D"       { context->lexAfterType = true; return SAMPLER2D; }
    122 "samplerCube"     { context->lexAfterType = true; return SAMPLERCUBE; }
    123 
    124 "struct"       { context->lexAfterType = true; return(STRUCT); }
    125 
    126 "asm"          { return reserved_word(yyscanner); }
    127 
    128 "class"        { return reserved_word(yyscanner); }
    129 "union"        { return reserved_word(yyscanner); }
    130 "enum"         { return reserved_word(yyscanner); }
    131 "typedef"      { return reserved_word(yyscanner); }
    132 "template"     { return reserved_word(yyscanner); }
    133 "this"         { return reserved_word(yyscanner); }
    134 "packed"       { return reserved_word(yyscanner); }
    135 
    136 "goto"         { return reserved_word(yyscanner); }
    137 "switch"       { return reserved_word(yyscanner); }
    138 "default"      { return reserved_word(yyscanner); }
    139 
    140 "inline"       { return reserved_word(yyscanner); }
    141 "noinline"     { return reserved_word(yyscanner); }
    142 "volatile"     { return reserved_word(yyscanner); }
    143 "public"       { return reserved_word(yyscanner); }
    144 "static"       { return reserved_word(yyscanner); }
    145 "extern"       { return reserved_word(yyscanner); }
    146 "external"     { return reserved_word(yyscanner); }
    147 "interface"    { return reserved_word(yyscanner); }
    148 
    149 "long"         { return reserved_word(yyscanner); }
    150 "short"        { return reserved_word(yyscanner); }
    151 "double"       { return reserved_word(yyscanner); }
    152 "half"         { return reserved_word(yyscanner); }
    153 "fixed"        { return reserved_word(yyscanner); }
    154 "unsigned"     { return reserved_word(yyscanner); }
    155 
    156 "input"        { return reserved_word(yyscanner); }
    157 "output"       { return reserved_word(yyscanner); }
    158 
    159 "hvec2"        { return reserved_word(yyscanner); }
    160 "hvec3"        { return reserved_word(yyscanner); }
    161 "hvec4"        { return reserved_word(yyscanner); }
    162 "fvec2"        { return reserved_word(yyscanner); }
    163 "fvec3"        { return reserved_word(yyscanner); }
    164 "fvec4"        { return reserved_word(yyscanner); }
    165 "dvec2"        { return reserved_word(yyscanner); }
    166 "dvec3"        { return reserved_word(yyscanner); }
    167 "dvec4"        { return reserved_word(yyscanner); }
    168 
    169 "sizeof"       { return reserved_word(yyscanner); }
    170 "cast"         { return reserved_word(yyscanner); }
    171 
    172 "namespace"    { return reserved_word(yyscanner); }
    173 "using"        { return reserved_word(yyscanner); }
    174 
    175 {L}({L}|{D})*       {
    176    yylval->lex.string = NewPoolTString(yytext);
    177    return check_type(yyscanner);
    178 }
    179 
    180 0[xX]{H}+         { yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
    181 0{O}+             { yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
    182 0{D}+             { context->error(yylineno, "Invalid Octal number.", yytext, "", ""); context->recover(); return 0;}
    183 {D}+              { yylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
    184 
    185 {D}+{E}           { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
    186 {D}+"."{D}*({E})? { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
    187 "."{D}+({E})?     { yylval->lex.f = static_cast<float>(atof_dot(yytext)); return(FLOATCONSTANT); }
    188 
    189 "+="            {  return(ADD_ASSIGN); }
    190 "-="            {  return(SUB_ASSIGN); }
    191 "*="            {  return(MUL_ASSIGN); }
    192 "/="            {  return(DIV_ASSIGN); }
    193 "%="            {  return(MOD_ASSIGN); }
    194 "<<="           {  return(LEFT_ASSIGN); }
    195 ">>="           {  return(RIGHT_ASSIGN); }
    196 "&="            {  return(AND_ASSIGN); }
    197 "^="            {  return(XOR_ASSIGN); }
    198 "|="            {  return(OR_ASSIGN); }
    199 
    200 "++"            {  return(INC_OP); }
    201 "--"            {  return(DEC_OP); }
    202 "&&"            {  return(AND_OP); }
    203 "||"            {  return(OR_OP); }
    204 "^^"            {  return(XOR_OP); }
    205 "<="            {  return(LE_OP); }
    206 ">="            {  return(GE_OP); }
    207 "=="            {  return(EQ_OP); }
    208 "!="            {  return(NE_OP); }
    209 "<<"            {  return(LEFT_OP); }
    210 ">>"            {  return(RIGHT_OP); }
    211 ";"             { context->lexAfterType = false; return(SEMICOLON); }
    212 ("{"|"<%")      { context->lexAfterType = false; return(LEFT_BRACE); }
    213 ("}"|"%>")      { return(RIGHT_BRACE); }
    214 ","         { if (context->inTypeParen) context->lexAfterType = false; return(COMMA); }
    215 ":"         { return(COLON); }
    216 "="         { context->lexAfterType = false; return(EQUAL); }
    217 "("         { context->lexAfterType = false; context->inTypeParen = true; return(LEFT_PAREN); }
    218 ")"         { context->inTypeParen = false; return(RIGHT_PAREN); }
    219 ("["|"<:")      { return(LEFT_BRACKET); }
    220 ("]"|":>")      { return(RIGHT_BRACKET); }
    221 "."         { BEGIN(FIELDS);  return(DOT); }
    222 "!"         { return(BANG); }
    223 "-"         { return(DASH); }
    224 "~"         { return(TILDE); }
    225 "+"         { return(PLUS); }
    226 "*"         { return(STAR); }
    227 "/"         { return(SLASH); }
    228 "%"         { return(PERCENT); }
    229 "<"         { return(LEFT_ANGLE); }
    230 ">"         { return(RIGHT_ANGLE); }
    231 "|"         { return(VERTICAL_BAR); }
    232 "^"         { return(CARET); }
    233 "&"         { return(AMPERSAND); }
    234 "?"         { return(QUESTION); }
    235 
    236 <FIELDS>{L}({L}|{D})* {
    237     BEGIN(INITIAL);
    238     yylval->lex.string = NewPoolTString(yytext);
    239     return FIELD_SELECTION;
    240 }
    241 <FIELDS>[ \t\v\f\r] {}
    242 
    243 [ \t\v\n\f\r]   {  }
    244 <*><<EOF>>      { context->AfterEOF = true; yyterminate(); }
    245 <*>.            { context->warning(yylineno, "Unknown char", yytext, ""); return 0; }
    246 
    247 %%
    248 
    249 extern "C" {
    250 // Preprocessor interface.
    251 #include "compiler/preprocessor/preprocess.h"
    252 
    253 #define SETUP_CONTEXT(pp) \
    254     TParseContext* context = (TParseContext*) pp->pC; \
    255     struct yyguts_t* yyg = (struct yyguts_t*) context->scanner;
    256 
    257 // Preprocessor callbacks.
    258 void CPPDebugLogMsg(const char *msg)
    259 {
    260     SETUP_CONTEXT(cpp);
    261     context->infoSink.debug.message(EPrefixNone, msg);
    262 }
    263 
    264 void CPPWarningToInfoLog(const char *msg)
    265 {
    266     SETUP_CONTEXT(cpp);
    267     context->warning(yylineno, msg, "", "");
    268 }
    269 
    270 void CPPShInfoLogMsg(const char *msg)
    271 {
    272     SETUP_CONTEXT(cpp);
    273     context->error(yylineno, msg, "", "");
    274     context->recover();
    275 }
    276 
    277 void CPPErrorToInfoLog(char *msg)
    278 {
    279     SETUP_CONTEXT(cpp);
    280     context->error(yylineno, msg, "", "");
    281     context->recover();
    282 }
    283 
    284 void SetLineNumber(int line)
    285 {
    286     SETUP_CONTEXT(cpp);
    287     int string = 0;
    288     DecodeSourceLoc(yylineno, &string, NULL);
    289     yylineno = EncodeSourceLoc(string, line);
    290 }
    291 
    292 void SetStringNumber(int string)
    293 {
    294     SETUP_CONTEXT(cpp);
    295     int line = 0;
    296     DecodeSourceLoc(yylineno, NULL, &line);
    297     yylineno = EncodeSourceLoc(string, line);
    298 }
    299 
    300 int GetStringNumber()
    301 {
    302     SETUP_CONTEXT(cpp);
    303     int string = 0;
    304     DecodeSourceLoc(yylineno, &string, NULL);
    305     return string;
    306 }
    307 
    308 int GetLineNumber()
    309 {
    310     SETUP_CONTEXT(cpp);
    311     int line = 0;
    312     DecodeSourceLoc(yylineno, NULL, &line);
    313     return line;
    314 }
    315 
    316 void IncLineNumber()
    317 {
    318     SETUP_CONTEXT(cpp);
    319     int string = 0, line = 0;
    320     DecodeSourceLoc(yylineno, &string, &line);
    321     yylineno = EncodeSourceLoc(string, ++line);
    322 }
    323 
    324 void DecLineNumber()
    325 {
    326     SETUP_CONTEXT(cpp);
    327     int string = 0, line = 0;
    328     DecodeSourceLoc(yylineno, &string, &line);
    329     yylineno = EncodeSourceLoc(string, --line);
    330 }
    331 
    332 void HandlePragma(const char **tokens, int numTokens)
    333 {
    334     SETUP_CONTEXT(cpp);
    335     if (!strcmp(tokens[0], "optimize")) {
    336         if (numTokens != 4) {
    337             CPPShInfoLogMsg("optimize pragma syntax is incorrect");
    338             return;
    339         }
    340 
    341         if (strcmp(tokens[1], "(")) {
    342             CPPShInfoLogMsg("\"(\" expected after 'optimize' keyword");
    343             return;
    344         }
    345 
    346         if (!strcmp(tokens[2], "on"))
    347             context->contextPragma.optimize = true;
    348         else if (!strcmp(tokens[2], "off"))
    349             context->contextPragma.optimize = false;
    350         else {
    351             CPPShInfoLogMsg("\"on\" or \"off\" expected after '(' for 'optimize' pragma");
    352             return;
    353         }
    354 
    355         if (strcmp(tokens[3], ")")) {
    356             CPPShInfoLogMsg("\")\" expected to end 'optimize' pragma");
    357             return;
    358         }
    359     } else if (!strcmp(tokens[0], "debug")) {
    360         if (numTokens != 4) {
    361             CPPShInfoLogMsg("debug pragma syntax is incorrect");
    362             return;
    363         }
    364 
    365         if (strcmp(tokens[1], "(")) {
    366             CPPShInfoLogMsg("\"(\" expected after 'debug' keyword");
    367             return;
    368         }
    369 
    370         if (!strcmp(tokens[2], "on"))
    371             context->contextPragma.debug = true;
    372         else if (!strcmp(tokens[2], "off"))
    373             context->contextPragma.debug = false;
    374         else {
    375             CPPShInfoLogMsg("\"on\" or \"off\" expected after '(' for 'debug' pragma");
    376             return;
    377         }
    378 
    379         if (strcmp(tokens[3], ")")) {
    380             CPPShInfoLogMsg("\")\" expected to end 'debug' pragma");
    381             return;
    382         }
    383     } else {
    384 #ifdef PRAGMA_TABLE
    385         //
    386         // implementation specific pragma
    387         // use ((TParseContext *)cpp->pC)->contextPragma.pragmaTable to store the information about pragma
    388         // For now, just ignore the pragma that the implementation cannot recognize
    389         // An Example of one such implementation for a pragma that has a syntax like
    390         // #pragma pragmaname(pragmavalue)
    391         // This implementation stores the current pragmavalue against the pragma name in pragmaTable.
    392         //
    393         if (numTokens == 4 && !strcmp(tokens[1], "(") && !strcmp(tokens[3], ")")) {
    394             TPragmaTable& pragmaTable = ((TParseContext *)cpp->pC)->contextPragma.pragmaTable;
    395             TPragmaTable::iterator iter;
    396             iter = pragmaTable.find(TString(tokens[0]));
    397             if (iter != pragmaTable.end()) {
    398                 iter->second = tokens[2];
    399             } else {
    400                 pragmaTable[ tokens[0] ] = tokens[2];
    401             }
    402         } else if (numTokens >= 2) {
    403             TPragmaTable& pragmaTable = ((TParseContext *)cpp->pC)->contextPragma.pragmaTable;
    404             TPragmaTable::iterator iter;
    405             iter = pragmaTable.find(TString(tokens[0]));
    406             if (iter != pragmaTable.end()) {
    407                 iter->second = tokens[1];
    408             } else {
    409                 pragmaTable[ tokens[0] ] = tokens[1];
    410             }
    411         }
    412 #endif // PRAGMA_TABLE
    413     }
    414 }
    415 
    416 void StoreStr(char *string)
    417 {
    418     SETUP_CONTEXT(cpp);
    419     TString strSrc;
    420     strSrc = TString(string);
    421 
    422     context->HashErrMsg = context->HashErrMsg + " " + strSrc;
    423 }
    424 
    425 const char* GetStrfromTStr(void)
    426 {
    427     SETUP_CONTEXT(cpp);
    428     cpp->ErrMsg = context->HashErrMsg.c_str();
    429     return cpp->ErrMsg;
    430 }
    431 
    432 void ResetTString(void)
    433 {
    434     SETUP_CONTEXT(cpp);
    435     context->HashErrMsg = "";
    436 }
    437 
    438 TBehavior GetBehavior(const char* behavior)
    439 {
    440     if (!strcmp("require", behavior))
    441         return EBhRequire;
    442     else if (!strcmp("enable", behavior))
    443         return EBhEnable;
    444     else if (!strcmp("disable", behavior))
    445         return EBhDisable;
    446     else if (!strcmp("warn", behavior))
    447         return EBhWarn;
    448     else {
    449         CPPShInfoLogMsg((TString("behavior '") + behavior + "' is not supported").c_str());
    450         return EBhDisable;
    451     }
    452 }
    453 
    454 void updateExtensionBehavior(const char* extName, const char* behavior)
    455 {
    456     SETUP_CONTEXT(cpp);
    457     TBehavior behaviorVal = GetBehavior(behavior);
    458     TMap<TString, TBehavior>:: iterator iter;
    459     TString msg;
    460 
    461     // special cased for all extension
    462     if (!strcmp(extName, "all")) {
    463         if (behaviorVal == EBhRequire || behaviorVal == EBhEnable) {
    464             CPPShInfoLogMsg("extension 'all' cannot have 'require' or 'enable' behavior");
    465             return;
    466         } else {
    467             for (iter = context->extensionBehavior.begin(); iter != context->extensionBehavior.end(); ++iter)
    468                 iter->second = behaviorVal;
    469         }
    470     } else {
    471         iter = context->extensionBehavior.find(TString(extName));
    472         if (iter == context->extensionBehavior.end()) {
    473             switch (behaviorVal) {
    474             case EBhRequire:
    475                 CPPShInfoLogMsg((TString("extension '") + extName + "' is not supported").c_str());
    476                 break;
    477             case EBhEnable:
    478             case EBhWarn:
    479             case EBhDisable:
    480                 msg = TString("extension '") + extName + "' is not supported";
    481                 context->infoSink.info.message(EPrefixWarning, msg.c_str(), yylineno);
    482                 break;
    483             }
    484             return;
    485         } else
    486             iter->second = behaviorVal;
    487     }
    488 }
    489 }  // extern "C"
    490 
    491 int string_input(char* buf, int max_size, yyscan_t yyscanner) {
    492     int len;
    493 
    494     if ((len = yylex_CPP(buf, max_size)) == 0)
    495         return 0;
    496     if (len >= max_size)
    497         YY_FATAL_ERROR("input buffer overflow, can't enlarge buffer because scanner uses REJECT");
    498 
    499     buf[len] = ' ';
    500     return len+1;
    501 }
    502 
    503 int check_type(yyscan_t yyscanner) {
    504     struct yyguts_t* yyg = (struct yyguts_t*) yyscanner;
    505 
    506     int token = IDENTIFIER;
    507     TSymbol* symbol = yyextra->symbolTable.find(yytext);
    508     if (yyextra->lexAfterType == false && symbol && symbol->isVariable()) {
    509         TVariable* variable = static_cast<TVariable*>(symbol);
    510         if (variable->isUserType()) {
    511             yyextra->lexAfterType = true;
    512             token = TYPE_NAME;
    513         }
    514     }
    515     yylval->lex.symbol = symbol;
    516     return token;
    517 }
    518 
    519 int reserved_word(yyscan_t yyscanner) {
    520     struct yyguts_t* yyg = (struct yyguts_t*) yyscanner;
    521 
    522     yyextra->error(yylineno, "Illegal use of reserved word", yytext, "");
    523     yyextra->recover();
    524     return 0;
    525 }
    526 
    527 void yyerror(TParseContext* context, const char* reason) {
    528     struct yyguts_t* yyg = (struct yyguts_t*) context->scanner;
    529 
    530     if (context->AfterEOF) {
    531         context->error(yylineno, reason, "unexpected EOF", "");
    532     } else {
    533         context->error(yylineno, reason, yytext, "");
    534     }
    535     context->recover();
    536 }
    537 
    538 int glslang_initialize(TParseContext* context) {
    539     yyscan_t scanner = NULL;
    540     if (yylex_init_extra(context, &scanner))
    541         return 1;
    542 
    543     context->scanner = scanner;
    544     return 0;
    545 }
    546 
    547 int glslang_finalize(TParseContext* context) {
    548     yyscan_t scanner = context->scanner;
    549     if (scanner == NULL) return 0;
    550 
    551     context->scanner = NULL;
    552     return yylex_destroy(scanner);
    553 }
    554 
    555 void glslang_scan(int count, const char* const string[], const int length[],
    556                   TParseContext* context) {
    557     yyrestart(NULL, context->scanner);
    558     yyset_lineno(EncodeSourceLoc(0, 1), context->scanner);
    559     context->AfterEOF = false;
    560 
    561     // Init preprocessor.
    562     cpp->pC = context;
    563     cpp->PaWhichStr = 0;
    564     cpp->PaArgv     = string;
    565     cpp->PaArgc     = count;
    566     cpp->PaStrLen   = length;
    567     cpp->pastFirstStatement = 0;
    568     ScanFromString(string[0]);
    569 }
    570 
    571