Updated to mesalib 7.9

1 files changed, 399 insertions, 0 deletions

diff --git a/mesalib/src/glsl/glsl_lexer.lpp b/mesalib/src/glsl/glsl_lexer.lpp
new file mode 100644
index 000000000..ed3cb251a
--- /dev/null
+++ b/mesalib/src/glsl/glsl_lexer.lpp
@@ -0,0 +1,399 @@
+%{
+/*
+ * Copyright © 2008, 2009 Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+#include <ctype.h>
+#include "ast.h"
+#include "glsl_parser_extras.h"
+#include "glsl_parser.h"
+
+#define YY_USER_ACTION						\
+   do {								\
+      yylloc->source = 0;					\
+      yylloc->first_column = yycolumn + 1;			\
+      yylloc->first_line = yylineno + 1;			\
+      yycolumn += yyleng;					\
+   } while(0);
+
+#define YY_USER_INIT yylineno = 0; yycolumn = 0;
+
+#define TOKEN_OR_IDENTIFIER(version, token)			 \
+   do {								 \
+      if (yyextra->language_version >= version) {		 \
+	 return token;						 \
+      } else {							 \
+	 yylval->identifier = strdup(yytext);			 \
+	 return IDENTIFIER;					 \
+      }								 \
+   } while (0)
+
+/* Handle reserved words in GLSL ES (version 100) */
+#define TOKEN_OR_IDENTIFIER_ES(version, token)			\
+   do {								\
+      if (yyextra->es_shader) {					\
+	return token;						\
+      } else {							\
+	TOKEN_OR_IDENTIFIER(version, token);			\
+      }								\
+   } while (0)
+
+#define RESERVED_WORD(version, token)					\
+   do {									\
+      if (yyextra->language_version >= version) {			\
+	 return token;							\
+      } else {								\
+	 _mesa_glsl_error(yylloc, yyextra,				\
+			  "Illegal use of reserved word `%s'", yytext);	\
+	 return ERROR_TOK;						\
+      }									\
+   } while (0)
+%}
+
+%option bison-bridge bison-locations reentrant noyywrap
+%option nounput noyy_top_state
+%option never-interactive
+%option prefix="_mesa_glsl_"
+%option extra-type="struct _mesa_glsl_parse_state *"
+
+%x PP PRAGMA
+
+DEC_INT		[1-9][0-9]*
+HEX_INT		0[xX][0-9a-fA-F]+
+OCT_INT		0[0-7]*
+INT		({DEC_INT}|{HEX_INT}|{OCT_INT})
+SPC		[ \t]*
+SPCP		[ \t]+
+HASH		^{SPC}#{SPC}
+%%
+
+[ \r\t]+		;
+
+    /* Preprocessor tokens. */ 
+^[ \t]*#[ \t]*$			;
+^[ \t]*#[ \t]*version		{ BEGIN PP; return VERSION; }
+^[ \t]*#[ \t]*extension		{ BEGIN PP; return EXTENSION; }
+{HASH}line{SPCP}{INT}{SPCP}{INT}{SPC}$ {
+				   /* Eat characters until the first digit is
+				    * encountered
+				    */
+				   char *ptr = yytext;
+				   while (!isdigit(*ptr))
+				      ptr++;
+
+				   /* Subtract one from the line number because
+				    * yylineno is zero-based instead of
+				    * one-based.
+				    */
+				   yylineno = strtol(ptr, &ptr, 0) - 1;
+				   yylloc->source = strtol(ptr, NULL, 0);
+				}
+{HASH}line{SPCP}{INT}{SPC}$	{
+				   /* Eat characters until the first digit is
+				    * encountered
+				    */
+				   char *ptr = yytext;
+				   while (!isdigit(*ptr))
+				      ptr++;
+
+				   /* Subtract one from the line number because
+				    * yylineno is zero-based instead of
+				    * one-based.
+				    */
+				   yylineno = strtol(ptr, &ptr, 0) - 1;
+				}
+^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}on{SPC}\) {
+				  BEGIN PP;
+				  return PRAGMA_DEBUG_ON;
+				}
+^{SPC}#{SPC}pragma{SPCP}debug{SPC}\({SPC}off{SPC}\) {
+				  BEGIN PP;
+				  return PRAGMA_DEBUG_OFF;
+				}
+^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}on{SPC}\) {
+				  BEGIN PP;
+				  return PRAGMA_OPTIMIZE_ON;
+				}
+^{SPC}#{SPC}pragma{SPCP}optimize{SPC}\({SPC}off{SPC}\) {
+				  BEGIN PP;
+				  return PRAGMA_OPTIMIZE_OFF;
+				}
+^{SPC}#{SPC}pragma{SPCP}	{ BEGIN PRAGMA; }
+
+<PRAGMA>\n			{ BEGIN 0; yylineno++; yycolumn = 0; }
+<PRAGMA>.			{ }
+
+<PP>\/\/[^\n]*			{ }
+<PP>[ \t\r]*			{ }
+<PP>:				return COLON;
+<PP>[_a-zA-Z][_a-zA-Z0-9]*	{
+				   yylval->identifier = strdup(yytext);
+				   return IDENTIFIER;
+				}
+<PP>[1-9][0-9]*			{
+				    yylval->n = strtol(yytext, NULL, 10);
+				    return INTCONSTANT;
+				}
+<PP>\n				{ BEGIN 0; yylineno++; yycolumn = 0; return EOL; }
+
+\n		{ yylineno++; yycolumn = 0; }
+
+attribute	return ATTRIBUTE;
+const		return CONST_TOK;
+bool		return BOOL_TOK;
+float		return FLOAT_TOK;
+int		return INT_TOK;
+
+break		return BREAK;
+continue	return CONTINUE;
+do		return DO;
+while		return WHILE;
+else		return ELSE;
+for		return FOR;
+if		return IF;
+discard		return DISCARD;
+return		return RETURN;
+
+bvec2		return BVEC2;
+bvec3		return BVEC3;
+bvec4		return BVEC4;
+ivec2		return IVEC2;
+ivec3		return IVEC3;
+ivec4		return IVEC4;
+vec2		return VEC2;
+vec3		return VEC3;
+vec4		return VEC4;
+mat2		return MAT2X2;
+mat3		return MAT3X3;
+mat4		return MAT4X4;
+mat2x2		TOKEN_OR_IDENTIFIER(120, MAT2X2);
+mat2x3		TOKEN_OR_IDENTIFIER(120, MAT2X3);
+mat2x4		TOKEN_OR_IDENTIFIER(120, MAT2X4);
+mat3x2		TOKEN_OR_IDENTIFIER(120, MAT3X2);
+mat3x3		TOKEN_OR_IDENTIFIER(120, MAT3X3);
+mat3x4		TOKEN_OR_IDENTIFIER(120, MAT3X4);
+mat4x2		TOKEN_OR_IDENTIFIER(120, MAT4X2);
+mat4x3		TOKEN_OR_IDENTIFIER(120, MAT4X3);
+mat4x4		TOKEN_OR_IDENTIFIER(120, MAT4X4);
+
+in		return IN_TOK;
+out		return OUT_TOK;
+inout		return INOUT_TOK;
+uniform		return UNIFORM;
+varying		return VARYING;
+centroid	TOKEN_OR_IDENTIFIER(120, CENTROID);
+invariant	TOKEN_OR_IDENTIFIER_ES(120, INVARIANT);
+
+flat		TOKEN_OR_IDENTIFIER_ES(130, FLAT);
+smooth		TOKEN_OR_IDENTIFIER(130, SMOOTH);
+noperspective	TOKEN_OR_IDENTIFIER(130, NOPERSPECTIVE);
+
+sampler1D	return SAMPLER1D;
+sampler2D	return SAMPLER2D;
+sampler3D	return SAMPLER3D;
+samplerCube	return SAMPLERCUBE;
+sampler1DShadow	return SAMPLER1DSHADOW;
+sampler2DShadow	return SAMPLER2DSHADOW;
+
+struct		return STRUCT;
+void		return VOID_TOK;
+
+layout		{
+		  if ((yyextra->language_version >= 140)
+		      || (yyextra->ARB_fragment_coord_conventions_enable)){
+		      return LAYOUT_TOK;
+		   } else {
+		      yylval->identifier = strdup(yytext);
+		      return IDENTIFIER;
+		   }
+		}
+
+\+\+		return INC_OP;
+--		return DEC_OP;
+\<=		return LE_OP;
+>=		return GE_OP;
+==		return EQ_OP;
+!=		return NE_OP;
+&&		return AND_OP;
+\|\|		return OR_OP;
+"^^"		return XOR_OP;
+
+\*=		return MUL_ASSIGN;
+\/=		return DIV_ASSIGN;
+\+=		return ADD_ASSIGN;
+\%=		return MOD_ASSIGN;
+\<\<=		return LEFT_ASSIGN;
+>>=		return RIGHT_ASSIGN;
+&=		return AND_ASSIGN;
+^=		return XOR_ASSIGN;
+\|=		return OR_ASSIGN;
+-=		return SUB_ASSIGN;
+
+[1-9][0-9]*		{
+			    yylval->n = strtol(yytext, NULL, 10);
+			    return INTCONSTANT;
+			}
+0[xX][0-9a-fA-F]+	{
+			    yylval->n = strtol(yytext + 2, NULL, 16);
+			    return INTCONSTANT;
+			}
+0[0-7]*			{
+			    yylval->n = strtol(yytext, NULL, 8);
+			    return INTCONSTANT;
+			}
+
+[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?	{
+			    yylval->real = strtod(yytext, NULL);
+			    return FLOATCONSTANT;
+			}
+\.[0-9]+([eE][+-]?[0-9]+)?[fF]?		{
+			    yylval->real = strtod(yytext, NULL);
+			    return FLOATCONSTANT;
+			}
+[0-9]+\.([eE][+-]?[0-9]+)?[fF]?		{
+			    yylval->real = strtod(yytext, NULL);
+			    return FLOATCONSTANT;
+			}
+[0-9]+[eE][+-]?[0-9]+[fF]?		{
+			    yylval->real = strtod(yytext, NULL);
+			    return FLOATCONSTANT;
+			}
+[0-9]+[fF]		{
+			    yylval->real = strtod(yytext, NULL);
+			    return FLOATCONSTANT;
+			}
+
+true			{
+			    yylval->n = 1;
+			    return BOOLCONSTANT;
+			}
+false			{
+			    yylval->n = 0;
+			    return BOOLCONSTANT;
+			}
+
+
+    /* Reserved words in GLSL 1.10. */
+asm		RESERVED_WORD(999, ASM);
+class		RESERVED_WORD(999, CLASS);
+union		RESERVED_WORD(999, UNION);
+enum		RESERVED_WORD(999, ENUM);
+typedef		RESERVED_WORD(999, TYPEDEF);
+template	RESERVED_WORD(999, TEMPLATE);
+this		RESERVED_WORD(999, THIS);
+packed		RESERVED_WORD(999, PACKED_TOK);
+goto		RESERVED_WORD(999, GOTO);
+switch		RESERVED_WORD(130, SWITCH);
+default		RESERVED_WORD(130, DEFAULT);
+inline		RESERVED_WORD(999, INLINE_TOK);
+noinline	RESERVED_WORD(999, NOINLINE);
+volatile	RESERVED_WORD(999, VOLATILE);
+public		RESERVED_WORD(999, PUBLIC_TOK);
+static		RESERVED_WORD(999, STATIC);
+extern		RESERVED_WORD(999, EXTERN);
+external	RESERVED_WORD(999, EXTERNAL);
+interface	RESERVED_WORD(999, INTERFACE);
+long		RESERVED_WORD(999, LONG_TOK);
+short		RESERVED_WORD(999, SHORT_TOK);
+double		RESERVED_WORD(999, DOUBLE_TOK);
+half		RESERVED_WORD(999, HALF);
+fixed		RESERVED_WORD(999, FIXED_TOK);
+unsigned	RESERVED_WORD(999, UNSIGNED);
+input		RESERVED_WORD(999, INPUT_TOK);
+output		RESERVED_WORD(999, OUTPUT);
+hvec2		RESERVED_WORD(999, HVEC2);
+hvec3		RESERVED_WORD(999, HVEC3);
+hvec4		RESERVED_WORD(999, HVEC4);
+dvec2		RESERVED_WORD(999, DVEC2);
+dvec3		RESERVED_WORD(999, DVEC3);
+dvec4		RESERVED_WORD(999, DVEC4);
+fvec2		RESERVED_WORD(999, FVEC2);
+fvec3		RESERVED_WORD(999, FVEC3);
+fvec4		RESERVED_WORD(999, FVEC4);
+sampler2DRect		return SAMPLER2DRECT;
+sampler3DRect		RESERVED_WORD(999, SAMPLER3DRECT);
+sampler2DRectShadow	return SAMPLER2DRECTSHADOW;
+sizeof		RESERVED_WORD(999, SIZEOF);
+cast		RESERVED_WORD(999, CAST);
+namespace	RESERVED_WORD(999, NAMESPACE);
+using		RESERVED_WORD(999, USING);
+
+    /* Additional reserved words in GLSL 1.20. */
+lowp		TOKEN_OR_IDENTIFIER_ES(120, LOWP);
+mediump		TOKEN_OR_IDENTIFIER_ES(120, MEDIUMP);
+highp		TOKEN_OR_IDENTIFIER_ES(120, HIGHP);
+precision	TOKEN_OR_IDENTIFIER_ES(120, PRECISION);
+
+    /* Additional reserved words in GLSL 1.30. */
+common		TOKEN_OR_IDENTIFIER(130, COMMON);
+partition	TOKEN_OR_IDENTIFIER(130, PARTITION);
+active		TOKEN_OR_IDENTIFIER(130, ACTIVE);
+superp		TOKEN_OR_IDENTIFIER_ES(130, SUPERP);
+samplerBuffer	TOKEN_OR_IDENTIFIER(130, SAMPLERBUFFER);
+filter		TOKEN_OR_IDENTIFIER(130, FILTER);
+image1D		TOKEN_OR_IDENTIFIER(130, IMAGE1D);
+image2D		TOKEN_OR_IDENTIFIER(130, IMAGE2D);
+image3D		TOKEN_OR_IDENTIFIER(130, IMAGE3D);
+imageCube	TOKEN_OR_IDENTIFIER(130, IMAGECUBE);
+iimage1D	TOKEN_OR_IDENTIFIER(130, IIMAGE1D);
+iimage2D	TOKEN_OR_IDENTIFIER(130, IIMAGE2D);
+iimage3D	TOKEN_OR_IDENTIFIER(130, IIMAGE3D);
+iimageCube	TOKEN_OR_IDENTIFIER(130, IIMAGECUBE);
+uimage1D	TOKEN_OR_IDENTIFIER(130, UIMAGE1D);
+uimage2D	TOKEN_OR_IDENTIFIER(130, UIMAGE2D);
+uimage3D	TOKEN_OR_IDENTIFIER(130, UIMAGE3D);
+uimageCube	TOKEN_OR_IDENTIFIER(130, UIMAGECUBE);
+image1DArray	TOKEN_OR_IDENTIFIER(130, IMAGE1DARRAY);
+image2DArray	TOKEN_OR_IDENTIFIER(130, IMAGE2DARRAY);
+iimage1DArray	TOKEN_OR_IDENTIFIER(130, IIMAGE1DARRAY);
+iimage2DArray	TOKEN_OR_IDENTIFIER(130, IIMAGE2DARRAY);
+uimage1DArray	TOKEN_OR_IDENTIFIER(130, UIMAGE1DARRAY);
+uimage2DArray	TOKEN_OR_IDENTIFIER(130, UIMAGE2DARRAY);
+image1DShadow	TOKEN_OR_IDENTIFIER(130, IMAGE1DSHADOW);
+image2DShadow	TOKEN_OR_IDENTIFIER(130, IMAGE2DSHADOW);
+imageBuffer	TOKEN_OR_IDENTIFIER(130, IMAGEBUFFER);
+iimageBuffer	TOKEN_OR_IDENTIFIER(130, IIMAGEBUFFER);
+uimageBuffer	TOKEN_OR_IDENTIFIER(130, UIMAGEBUFFER);
+row_major	TOKEN_OR_IDENTIFIER(130, ROW_MAJOR);
+
+[_a-zA-Z][_a-zA-Z0-9]*	{
+			    struct _mesa_glsl_parse_state *state = yyextra;
+			    void *ctx = state;	
+			    yylval->identifier = talloc_strdup(ctx, yytext);
+			    return IDENTIFIER;
+			}
+
+.			{ return yytext[0]; }
+
+%%
+
+void
+_mesa_glsl_lexer_ctor(struct _mesa_glsl_parse_state *state, const char *string)
+{
+   yylex_init_extra(state, & state->scanner);
+   yy_scan_string(string, state->scanner);
+}
+
+void
+_mesa_glsl_lexer_dtor(struct _mesa_glsl_parse_state *state)
+{
+   yylex_destroy(state->scanner);
+}