Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. %{
  2. /*
  3.  * Copyright © 2008, 2009 Intel Corporation
  4.  *
  5.  * Permission is hereby granted, free of charge, to any person obtaining a
  6.  * copy of this software and associated documentation files (the "Software"),
  7.  * to deal in the Software without restriction, including without limitation
  8.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9.  * and/or sell copies of the Software, and to permit persons to whom the
  10.  * Software is furnished to do so, subject to the following conditions:
  11.  *
  12.  * The above copyright notice and this permission notice (including the next
  13.  * paragraph) shall be included in all copies or substantial portions of the
  14.  * Software.
  15.  *
  16.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22.  * DEALINGS IN THE SOFTWARE.
  23.  */
  24. #include <ctype.h>
  25. #include "strtod.h"
  26. #include "ast.h"
  27. #include "glsl_parser_extras.h"
  28. #include "glsl_parser.h"
  29.  
  30. static int classify_identifier(struct _mesa_glsl_parse_state *, const char *);
  31.  
  32. #define YY_USER_ACTION                                          \
  33.    do {                                                         \
  34.       yylloc->source = 0;                                       \
  35.       yylloc->first_column = yycolumn + 1;                      \
  36.       yylloc->first_line = yylineno + 1;                        \
  37.       yycolumn += yyleng;                                       \
  38.    } while(0);
  39.  
  40. #define YY_USER_INIT yylineno = 0; yycolumn = 0;
  41.  
  42. #define IS_UINT (yytext[yyleng - 1] == 'u' || yytext[yyleng - 1] == 'U')
  43.  
  44. /* A macro for handling reserved words and keywords across language versions.
  45.  *
  46.  * Certain words start out as identifiers, become reserved words in
  47.  * later language revisions, and finally become language keywords.
  48.  *
  49.  * For example, consider the following lexer rule:
  50.  * samplerBuffer       KEYWORD(130, 140, SAMPLERBUFFER)
  51.  *
  52.  * This means that "samplerBuffer" will be treated as:
  53.  * - a keyword (SAMPLERBUFFER token)         ...in GLSL >= 1.40
  54.  * - a reserved word - error                 ...in GLSL >= 1.30
  55.  * - an identifier                           ...in GLSL <  1.30
  56.  */
  57. #define KEYWORD(reserved_version, allowed_version, token)               \
  58.    do {                                                                 \
  59.       if (yyextra->language_version >= allowed_version) {               \
  60.          return token;                                                  \
  61.       } else if (yyextra->language_version >= reserved_version) {       \
  62.          _mesa_glsl_error(yylloc, yyextra,                              \
  63.                           "Illegal use of reserved word `%s'", yytext); \
  64.          return ERROR_TOK;                                              \
  65.       } else {                                                          \
  66.          yylval->identifier = strdup(yytext);                           \
  67.          return classify_identifier(yyextra, yytext);                   \
  68.       }                                                                 \
  69.    } while (0)
  70.  
  71. /* The ES macro can be used in KEYWORD checks:
  72.  *
  73.  *    word      KEYWORD(110 || ES, 400, TOKEN)
  74.  * ...means the word is reserved in GLSL ES 1.00, while
  75.  *
  76.  *    word      KEYWORD(110, 130 || ES, TOKEN)
  77.  * ...means the word is a legal keyword in GLSL ES 1.00.
  78.  */
  79. #define ES yyextra->es_shader
  80. %}
  81.  
  82. %option bison-bridge bison-locations reentrant noyywrap
  83. %option nounput noyy_top_state
  84. %option never-interactive
  85. %option prefix="_mesa_glsl_"
  86. %option extra-type="struct _mesa_glsl_parse_state *"
  87.  
  88. %x PP PRAGMA
  89.  
  90. DEC_INT         [1-9][0-9]*
  91. HEX_INT         0[xX][0-9a-fA-F]+
  92. OCT_INT         0[0-7]*
  93. INT             ({DEC_INT}|{HEX_INT}|{OCT_INT})
  94. SPC             [ \t]*
  95. SPCP            [ \t]+
  96. HASH            ^{SPC}#{SPC}
  97. %%
  98.  
  99. [ \r\t]+                ;
  100.  
  101.     /* Preprocessor tokens. */
  102. ^[ \t]*#[ \t]*$                 ;
  103. ^[ \t]*#[ \t]*version           { BEGIN PP; return VERSION; }
  104. ^[ \t]*#[ \t]*extension         { BEGIN PP; return EXTENSION; }
  105. {HASH}line{SPCP}{INT}{SPCP}{INT}{SPC}$ {
  106.                                    /* Eat characters until the first digit is
  107.                                     * encountered
  108.                                     */
  109.                                    char *ptr = yytext;
  110.                                    while (!isdigit(*ptr))
  111.                                       ptr++;
  112.  
  113.                                    /* Subtract one from the line number because
  114.                                     * yylineno is zero-based instead of
  115.                                     * one-based.
  116.                                     */
  117.                                    yylineno = strtol(ptr, &ptr, 0) - 1;
  118.                                    yylloc->source = strtol(ptr, NULL, 0);
  119.                                 }
  120. {HASH}line{SPCP}{INT}{SPC}$     {
  121.                                    /* Eat characters until the first digit is
  122.                                     * encountered
  123.                                     */
  124.                                    char *ptr = yytext;
  125.                                    while (!isdigit(*ptr))
  126.                                       ptr++;
  127.  
  128.                                    /* Subtract one from the line number because
  129.                                     * yylineno is zero-based instead of
  130.                                     * one-based.
  131.                                     */
  132.                                    yylineno = strtol(ptr, &ptr, 0) - 1;
  133.                                 }
  134. ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}on{SPC}\) {
  135.                                   BEGIN PP;
  136.                                   return PRAGMA_DEBUG_ON;
  137.                                 }
  138. ^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}off{SPC}\) {
  139.                                   BEGIN PP;
  140.                                   return PRAGMA_DEBUG_OFF;
  141.                                 }
  142. ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}on{SPC}\) {
  143.                                   BEGIN PP;
  144.                                   return PRAGMA_OPTIMIZE_ON;
  145.                                 }
  146. ^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}off{SPC}\) {
  147.                                   BEGIN PP;
  148.                                   return PRAGMA_OPTIMIZE_OFF;
  149.                                 }
  150. ^{SPC}#{SPC}pragma{SPCP}STDGL{SPCP}invariant{SPC}\({SPC}all{SPC}\) {
  151.                                   BEGIN PP;
  152.                                   return PRAGMA_INVARIANT_ALL;
  153.                                 }
  154. ^{SPC}#{SPC}pragma{SPCP}        { BEGIN PRAGMA; }
  155.  
  156. <PRAGMA>\n                      { BEGIN 0; yylineno++; yycolumn = 0; }
  157. <PRAGMA>.                       { }
  158.  
  159. <PP>\/\/[^\n]*                  { }
  160. <PP>[ \t\r]*                    { }
  161. <PP>:                           return COLON;
  162. <PP>[_a-zA-Z][_a-zA-Z0-9]*      {
  163.                                    yylval->identifier = strdup(yytext);
  164.                                    return IDENTIFIER;
  165.                                 }
  166. <PP>[1-9][0-9]*                 {
  167.                                     yylval->n = strtol(yytext, NULL, 10);
  168.                                     return INTCONSTANT;
  169.                                 }
  170. <PP>\n                          { BEGIN 0; yylineno++; yycolumn = 0; return EOL; }
  171.  
  172. \n              { yylineno++; yycolumn = 0; }
  173.  
  174. attribute       return ATTRIBUTE;
  175. const           return CONST_TOK;
  176. bool            return BOOL_TOK;
  177. float           return FLOAT_TOK;
  178. int             return INT_TOK;
  179. uint            KEYWORD(130, 130, UINT_TOK);
  180.  
  181. break           return BREAK;
  182. continue        return CONTINUE;
  183. do              return DO;
  184. while           return WHILE;
  185. else            return ELSE;
  186. for             return FOR;
  187. if              return IF;
  188. discard         return DISCARD;
  189. return          return RETURN;
  190.  
  191. bvec2           return BVEC2;
  192. bvec3           return BVEC3;
  193. bvec4           return BVEC4;
  194. ivec2           return IVEC2;
  195. ivec3           return IVEC3;
  196. ivec4           return IVEC4;
  197. uvec2           KEYWORD(130, 130, UVEC2);
  198. uvec3           KEYWORD(130, 130, UVEC3);
  199. uvec4           KEYWORD(130, 130, UVEC4);
  200. vec2            return VEC2;
  201. vec3            return VEC3;
  202. vec4            return VEC4;
  203. mat2            return MAT2X2;
  204. mat3            return MAT3X3;
  205. mat4            return MAT4X4;
  206. mat2x2          KEYWORD(120, 120, MAT2X2);
  207. mat2x3          KEYWORD(120, 120, MAT2X3);
  208. mat2x4          KEYWORD(120, 120, MAT2X4);
  209. mat3x2          KEYWORD(120, 120, MAT3X2);
  210. mat3x3          KEYWORD(120, 120, MAT3X3);
  211. mat3x4          KEYWORD(120, 120, MAT3X4);
  212. mat4x2          KEYWORD(120, 120, MAT4X2);
  213. mat4x3          KEYWORD(120, 120, MAT4X3);
  214. mat4x4          KEYWORD(120, 120, MAT4X4);
  215.  
  216. in              return IN_TOK;
  217. out             return OUT_TOK;
  218. inout           return INOUT_TOK;
  219. uniform         return UNIFORM;
  220. varying         return VARYING;
  221. centroid        KEYWORD(120, 120, CENTROID);
  222. invariant       KEYWORD(120 || ES, 120 || ES, INVARIANT);
  223. flat            KEYWORD(130 || ES, 130, FLAT);
  224. smooth          KEYWORD(130, 130, SMOOTH);
  225. noperspective   KEYWORD(130, 130, NOPERSPECTIVE);
  226.  
  227. sampler1D       return SAMPLER1D;
  228. sampler2D       return SAMPLER2D;
  229. sampler3D       return SAMPLER3D;
  230. samplerCube     return SAMPLERCUBE;
  231. sampler1DArray  KEYWORD(130, 130, SAMPLER1DARRAY);
  232. sampler2DArray  KEYWORD(130, 130, SAMPLER2DARRAY);
  233. sampler1DShadow return SAMPLER1DSHADOW;
  234. sampler2DShadow return SAMPLER2DSHADOW;
  235. samplerCubeShadow       KEYWORD(130, 130, SAMPLERCUBESHADOW);
  236. sampler1DArrayShadow    KEYWORD(130, 130, SAMPLER1DARRAYSHADOW);
  237. sampler2DArrayShadow    KEYWORD(130, 130, SAMPLER2DARRAYSHADOW);
  238. isampler1D              KEYWORD(130, 130, ISAMPLER1D);
  239. isampler2D              KEYWORD(130, 130, ISAMPLER2D);
  240. isampler3D              KEYWORD(130, 130, ISAMPLER3D);
  241. isamplerCube            KEYWORD(130, 130, ISAMPLERCUBE);
  242. isampler1DArray         KEYWORD(130, 130, ISAMPLER1DARRAY);
  243. isampler2DArray         KEYWORD(130, 130, ISAMPLER2DARRAY);
  244. usampler1D              KEYWORD(130, 130, USAMPLER1D);
  245. usampler2D              KEYWORD(130, 130, USAMPLER2D);
  246. usampler3D              KEYWORD(130, 130, USAMPLER3D);
  247. usamplerCube            KEYWORD(130, 130, USAMPLERCUBE);
  248. usampler1DArray         KEYWORD(130, 130, USAMPLER1DARRAY);
  249. usampler2DArray         KEYWORD(130, 130, USAMPLER2DARRAY);
  250.  
  251.  
  252. struct          return STRUCT;
  253. void            return VOID_TOK;
  254.  
  255. layout          {
  256.                   if ((yyextra->language_version >= 140)
  257.                       || yyextra->ARB_explicit_attrib_location_enable
  258.                       || (yyextra->ARB_fragment_coord_conventions_enable)){
  259.                       return LAYOUT_TOK;
  260.                    } else {
  261.                       yylval->identifier = strdup(yytext);
  262.                       return IDENTIFIER;
  263.                    }
  264.                 }
  265.  
  266. \+\+            return INC_OP;
  267. --              return DEC_OP;
  268. \<=             return LE_OP;
  269. >=              return GE_OP;
  270. ==              return EQ_OP;
  271. !=              return NE_OP;
  272. &&              return AND_OP;
  273. \|\|            return OR_OP;
  274. "^^"            return XOR_OP;
  275. "<<"            return LEFT_OP;
  276. ">>"            return RIGHT_OP;
  277.  
  278. \*=             return MUL_ASSIGN;
  279. \/=             return DIV_ASSIGN;
  280. \+=             return ADD_ASSIGN;
  281. \%=             return MOD_ASSIGN;
  282. \<\<=           return LEFT_ASSIGN;
  283. >>=             return RIGHT_ASSIGN;
  284. &=              return AND_ASSIGN;
  285. "^="            return XOR_ASSIGN;
  286. \|=             return OR_ASSIGN;
  287. -=              return SUB_ASSIGN;
  288.  
  289. [1-9][0-9]*[uU]?        {
  290.                             yylval->n = strtol(yytext, NULL, 10);
  291.                             return IS_UINT ? UINTCONSTANT : INTCONSTANT;
  292.                         }
  293. 0[xX][0-9a-fA-F]+[uU]?  {
  294.                             yylval->n = strtol(yytext + 2, NULL, 16);
  295.                             return IS_UINT ? UINTCONSTANT : INTCONSTANT;
  296.                         }
  297. 0[0-7]*[uU]?            {
  298.                             yylval->n = strtol(yytext, NULL, 8);
  299.                             return IS_UINT ? UINTCONSTANT : INTCONSTANT;
  300.                         }
  301.  
  302. [0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?   {
  303.                             yylval->real = glsl_strtod(yytext, NULL);
  304.                             return FLOATCONSTANT;
  305.                         }
  306. \.[0-9]+([eE][+-]?[0-9]+)?[fF]?         {
  307.                             yylval->real = glsl_strtod(yytext, NULL);
  308.                             return FLOATCONSTANT;
  309.                         }
  310. [0-9]+\.([eE][+-]?[0-9]+)?[fF]?         {
  311.                             yylval->real = glsl_strtod(yytext, NULL);
  312.                             return FLOATCONSTANT;
  313.                         }
  314. [0-9]+[eE][+-]?[0-9]+[fF]?              {
  315.                             yylval->real = glsl_strtod(yytext, NULL);
  316.                             return FLOATCONSTANT;
  317.                         }
  318. [0-9]+[fF]              {
  319.                             yylval->real = glsl_strtod(yytext, NULL);
  320.                             return FLOATCONSTANT;
  321.                         }
  322.  
  323. true                    {
  324.                             yylval->n = 1;
  325.                             return BOOLCONSTANT;
  326.                         }
  327. false                   {
  328.                             yylval->n = 0;
  329.                             return BOOLCONSTANT;
  330.                         }
  331.  
  332.  
  333.     /* Reserved words in GLSL 1.10. */
  334. asm             KEYWORD(110 || ES, 999, ASM);
  335. class           KEYWORD(110 || ES, 999, CLASS);
  336. union           KEYWORD(110 || ES, 999, UNION);
  337. enum            KEYWORD(110 || ES, 999, ENUM);
  338. typedef         KEYWORD(110 || ES, 999, TYPEDEF);
  339. template        KEYWORD(110 || ES, 999, TEMPLATE);
  340. this            KEYWORD(110 || ES, 999, THIS);
  341. packed          KEYWORD(110 || ES, 999, PACKED_TOK);
  342. goto            KEYWORD(110 || ES, 999, GOTO);
  343. switch          KEYWORD(110 || ES, 130, SWITCH);
  344. default         KEYWORD(110 || ES, 130, DEFAULT);
  345. inline          KEYWORD(110 || ES, 999, INLINE_TOK);
  346. noinline        KEYWORD(110 || ES, 999, NOINLINE);
  347. volatile        KEYWORD(110 || ES, 999, VOLATILE);
  348. public          KEYWORD(110 || ES, 999, PUBLIC_TOK);
  349. static          KEYWORD(110 || ES, 999, STATIC);
  350. extern          KEYWORD(110 || ES, 999, EXTERN);
  351. external        KEYWORD(110 || ES, 999, EXTERNAL);
  352. interface       KEYWORD(110 || ES, 999, INTERFACE);
  353. long            KEYWORD(110 || ES, 999, LONG_TOK);
  354. short           KEYWORD(110 || ES, 999, SHORT_TOK);
  355. double          KEYWORD(110 || ES, 400, DOUBLE_TOK);
  356. half            KEYWORD(110 || ES, 999, HALF);
  357. fixed           KEYWORD(110 || ES, 999, FIXED_TOK);
  358. unsigned        KEYWORD(110 || ES, 999, UNSIGNED);
  359. input           KEYWORD(110 || ES, 999, INPUT_TOK);
  360. output          KEYWORD(110 || ES, 999, OUTPUT);
  361. hvec2           KEYWORD(110 || ES, 999, HVEC2);
  362. hvec3           KEYWORD(110 || ES, 999, HVEC3);
  363. hvec4           KEYWORD(110 || ES, 999, HVEC4);
  364. dvec2           KEYWORD(110 || ES, 400, DVEC2);
  365. dvec3           KEYWORD(110 || ES, 400, DVEC3);
  366. dvec4           KEYWORD(110 || ES, 400, DVEC4);
  367. fvec2           KEYWORD(110 || ES, 999, FVEC2);
  368. fvec3           KEYWORD(110 || ES, 999, FVEC3);
  369. fvec4           KEYWORD(110 || ES, 999, FVEC4);
  370. sampler2DRect           return SAMPLER2DRECT;
  371. sampler3DRect           KEYWORD(110 || ES, 999, SAMPLER3DRECT);
  372. sampler2DRectShadow     return SAMPLER2DRECTSHADOW;
  373. sizeof          KEYWORD(110 || ES, 999, SIZEOF);
  374. cast            KEYWORD(110 || ES, 999, CAST);
  375. namespace       KEYWORD(110 || ES, 999, NAMESPACE);
  376. using           KEYWORD(110 || ES, 999, USING);
  377.  
  378.     /* Additional reserved words in GLSL 1.20. */
  379. lowp            KEYWORD(120, 130 || ES, LOWP);
  380. mediump         KEYWORD(120, 130 || ES, MEDIUMP);
  381. highp           KEYWORD(120, 130 || ES, HIGHP);
  382. precision       KEYWORD(120, 130 || ES, PRECISION);
  383.  
  384.     /* Additional reserved words in GLSL 1.30. */
  385. case            KEYWORD(130, 130, CASE);
  386. common          KEYWORD(130, 999, COMMON);
  387. partition       KEYWORD(130, 999, PARTITION);
  388. active          KEYWORD(130, 999, ACTIVE);
  389. superp          KEYWORD(130 || ES, 999, SUPERP);
  390. samplerBuffer   KEYWORD(130, 140, SAMPLERBUFFER);
  391. filter          KEYWORD(130, 999, FILTER);
  392. image1D         KEYWORD(130, 999, IMAGE1D);
  393. image2D         KEYWORD(130, 999, IMAGE2D);
  394. image3D         KEYWORD(130, 999, IMAGE3D);
  395. imageCube       KEYWORD(130, 999, IMAGECUBE);
  396. iimage1D        KEYWORD(130, 999, IIMAGE1D);
  397. iimage2D        KEYWORD(130, 999, IIMAGE2D);
  398. iimage3D        KEYWORD(130, 999, IIMAGE3D);
  399. iimageCube      KEYWORD(130, 999, IIMAGECUBE);
  400. uimage1D        KEYWORD(130, 999, UIMAGE1D);
  401. uimage2D        KEYWORD(130, 999, UIMAGE2D);
  402. uimage3D        KEYWORD(130, 999, UIMAGE3D);
  403. uimageCube      KEYWORD(130, 999, UIMAGECUBE);
  404. image1DArray    KEYWORD(130, 999, IMAGE1DARRAY);
  405. image2DArray    KEYWORD(130, 999, IMAGE2DARRAY);
  406. iimage1DArray   KEYWORD(130, 999, IIMAGE1DARRAY);
  407. iimage2DArray   KEYWORD(130, 999, IIMAGE2DARRAY);
  408. uimage1DArray   KEYWORD(130, 999, UIMAGE1DARRAY);
  409. uimage2DArray   KEYWORD(130, 999, UIMAGE2DARRAY);
  410. image1DShadow   KEYWORD(130, 999, IMAGE1DSHADOW);
  411. image2DShadow   KEYWORD(130, 999, IMAGE2DSHADOW);
  412. image1DArrayShadow KEYWORD(130, 999, IMAGE1DARRAYSHADOW);
  413. image2DArrayShadow KEYWORD(130, 999, IMAGE2DARRAYSHADOW);
  414. imageBuffer     KEYWORD(130, 999, IMAGEBUFFER);
  415. iimageBuffer    KEYWORD(130, 999, IIMAGEBUFFER);
  416. uimageBuffer    KEYWORD(130, 999, UIMAGEBUFFER);
  417. row_major       KEYWORD(130, 999, ROW_MAJOR);
  418.  
  419. [_a-zA-Z][_a-zA-Z0-9]*  {
  420.                             struct _mesa_glsl_parse_state *state = yyextra;
  421.                             void *ctx = state; 
  422.                             yylval->identifier = ralloc_strdup(ctx, yytext);
  423.                             return classify_identifier(state, yytext);
  424.                         }
  425.  
  426. .                       { return yytext[0]; }
  427.  
  428. %%
  429.  
  430. int
  431. classify_identifier(struct _mesa_glsl_parse_state *state, const char *name)
  432. {
  433.    if (state->symbols->get_variable(name) || state->symbols->get_function(name))
  434.       return IDENTIFIER;
  435.    else if (state->symbols->get_type(name))
  436.       return TYPE_IDENTIFIER;
  437.    else
  438.       return NEW_IDENTIFIER;
  439. }
  440.  
  441. void
  442. _mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, const char *string)
  443. {
  444.    yylex_init_extra(state, & state->scanner);
  445.    yy_scan_string(string, state->scanner);
  446. }
  447.  
  448. void
  449. _mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state)
  450. {
  451.    yylex_destroy(state->scanner);
  452. }
  453.