dlls/d3dcompiler_43/hlsl.l

   1 /*
   2  * HLSL parser
   3  *
   4  * Copyright 2008 Stefan Dösinger
   5  * Copyright 2012 Matteo Bruni for CodeWeavers
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 %{
  23 #include "wine/debug.h"
  24
  25 #define YY_NO_UNISTD_H
  26 #include "d3dcompiler_private.h"
  27 #include "hlsl.tab.h"
  28
  29 WINE_DEFAULT_DEBUG_CHANNEL(hlsl_parser);
  30
  31 #define YY_USER_ACTION                               \
  32    do {                                              \
  33       hlsl_lloc.first_column = hlsl_ctx.column;      \
  34       hlsl_lloc.first_line = hlsl_ctx.line_no;       \
  35       hlsl_ctx.column += yyleng;                     \
  36    } while(0);
  37
  38 %}
  39
  40 %option noyywrap nounput noinput never-interactive
  41 %option prefix="hlsl_"
  42
  43 %x pp pp_line pp_pragma pp_ignore
  44
  45 RESERVED1               auto|case|catch|char|class|const_cast|default|delete|dynamic_cast|enum
  46 RESERVED2               explicit|friend|goto|long|mutable|new|operator|private|protected|public
  47 RESERVED3               reinterpret_cast|short|signed|sizeof|static_cast|template|this|throw|try
  48 RESERVED4               typename|union|unsigned|using|virtual
  49
  50 WS                      [ \t]
  51 NEWLINE                 (\n)|(\r\n)
  52 DOUBLESLASHCOMMENT      "//"[^\n]*
  53 STRING                  \"[^\"]*\"
  54 IDENTIFIER              [A-Za-z_][A-Za-z0-9_]*
  55
  56 ANY                     (.)
  57
  58 %%
  59 {RESERVED1}             {
  60                             hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
  61                             set_parse_status(&hlsl_ctx.status, PARSE_ERR);
  62                         }
  63 {RESERVED2}             {
  64                             hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
  65                             set_parse_status(&hlsl_ctx.status, PARSE_ERR);
  66                         }
  67 {RESERVED3}             {
  68                             hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
  69                             set_parse_status(&hlsl_ctx.status, PARSE_ERR);
  70                         }
  71 {RESERVED4}             {
  72                             hlsl_message("Line %u: Reserved keyword \"%s\" used.\n", hlsl_ctx.line_no, yytext);
  73                             set_parse_status(&hlsl_ctx.status, PARSE_ERR);
  74                         }
  75
  76 BlendState              {return KW_BLENDSTATE;          }
  77 break                   {return KW_BREAK;               }
  78 Buffer                  {return KW_BUFFER;              }
  79 cbuffer                 {return KW_CBUFFER;             }
  80 compile                 {return KW_COMPILE;             }
  81 const                   {return KW_CONST;               }
  82 continue                {return KW_CONTINUE;            }
  83 DepthStencilState       {return KW_DEPTHSTENCILSTATE;   }
  84 DepthStencilView        {return KW_DEPTHSTENCILVIEW;    }
  85 discard                 {return KW_DISCARD;             }
  86 do                      {return KW_DO;                  }
  87 double                  {return KW_DOUBLE;              }
  88 else                    {return KW_ELSE;                }
  89 extern                  {return KW_EXTERN;              }
  90 false                   {return KW_FALSE;               }
  91 for                     {return KW_FOR;                 }
  92 GeometryShader          {return KW_GEOMETRYSHADER;      }
  93 groupshared             {return KW_GROUPSHARED;         }
  94 if                      {return KW_IF;                  }
  95 in                      {return KW_IN;                  }
  96 inline                  {return KW_INLINE;              }
  97 inout                   {return KW_INOUT;               }
  98 matrix                  {return KW_MATRIX;              }
  99 namespace               {return KW_NAMESPACE;           }
 100 nointerpolation         {return KW_NOINTERPOLATION;     }
 101 out                     {return KW_OUT;                 }
 102 pass                    {return KW_PASS;                }
 103 PixelShader             {return KW_PIXELSHADER;         }
 104 precise                 {return KW_PRECISE;             }
 105 RasterizerState         {return KW_RASTERIZERSTATE;     }
 106 RenderTargetView        {return KW_RENDERTARGETVIEW;    }
 107 return                  {return KW_RETURN;              }
 108 register                {return KW_REGISTER;            }
 109 sampler                 {return KW_SAMPLER;             }
 110 sampler1D               {return KW_SAMPLER1D;           }
 111 sampler2D               {return KW_SAMPLER2D;           }
 112 sampler3D               {return KW_SAMPLER3D;           }
 113 samplerCUBE             {return KW_SAMPLERCUBE;         }
 114 sampler_state           {return KW_SAMPLER_STATE;       }
 115 SamplerComparisonState  {return KW_SAMPLERCOMPARISONSTATE;}
 116 shared                  {return KW_SHARED;              }
 117 stateblock              {return KW_STATEBLOCK;          }
 118 stateblock_state        {return KW_STATEBLOCK_STATE;    }
 119 static                  {return KW_STATIC;              }
 120 string                  {return KW_STRING;              }
 121 struct                  {return KW_STRUCT;              }
 122 switch                  {return KW_SWITCH;              }
 123 tbuffer                 {return KW_TBUFFER;             }
 124 technique               {return KW_TECHNIQUE;           }
 125 technique10             {return KW_TECHNIQUE10;         }
 126 texture                 {return KW_TEXTURE;             }
 127 texture1D               {return KW_TEXTURE1D;           }
 128 Texture1DArray          {return KW_TEXTURE1DARRAY;      }
 129 texture2D               {return KW_TEXTURE2D;           }
 130 Texture2DArray          {return KW_TEXTURE2DARRAY;      }
 131 Texture2DMS             {return KW_TEXTURE2DMS;         }
 132 Texture2DMSArray        {return KW_TEXTURE2DMSARRAY;    }
 133 texture3D               {return KW_TEXTURE3D;           }
 134 Texture3DArray          {return KW_TEXTURE3DARRAY;      }
 135 textureCUBE             {return KW_TEXTURECUBE;         }
 136 true                    {return KW_TRUE;                }
 137 typedef                 {return KW_TYPEDEF;             }
 138 uniform                 {return KW_UNIFORM;             }
 139 vector                  {return KW_VECTOR;              }
 140 VertexShader            {return KW_VERTEXSHADER;        }
 141 void                    {return KW_VOID;                }
 142 volatile                {return KW_VOLATILE;            }
 143 while                   {return KW_WHILE;               }
 144
 145 \+\+                    {return OP_INC;                 }
 146 \-\-                    {return OP_DEC;                 }
 147 &&                      {return OP_AND;                 }
 148 \|\|                    {return OP_OR;                  }
 149 ==                      {return OP_EQ;                  }
 150 \<\<                    {return OP_LEFTSHIFT;           }
 151 \<\<=                   {return OP_LEFTSHIFTASSIGN;     }
 152 \>\>                    {return OP_RIGHTSHIFT;          }
 153 \>\>=                   {return OP_RIGHTSHIFTASSIGN;    }
 154 \.\.\.                  {return OP_ELLIPSIS;            }
 155 \<=                     {return OP_LE;                  }
 156 \>=                     {return OP_GE;                  }
 157 !=                      {return OP_NE;                  }
 158 \+=                     {return OP_ADDASSIGN;           }
 159 \-=                     {return OP_SUBASSIGN;           }
 160 \*=                     {return OP_MULASSIGN;           }
 161 \/=                     {return OP_DIVASSIGN;           }
 162 %=                      {return OP_MODASSIGN;           }
 163 &=                      {return OP_ANDASSIGN;           }
 164 \|=                     {return OP_ORASSIGN;            }
 165 ^=                      {return OP_XORASSIGN;           }
 166 ##                      {return OP_UNKNOWN1;            }
 167 #@                      {return OP_UNKNOWN2;            }
 168 ::                      {return OP_UNKNOWN3;            }
 169 \-\>                    {return OP_UNKNOWN4;            }
 170
 171 column_major            {return KW_COLUMN_MAJOR;        }
 172 row_major               {return KW_ROW_MAJOR;           }
 173
 174 {IDENTIFIER}            {
 175                             hlsl_lval.name = d3dcompiler_strdup(yytext);
 176                             if (get_variable(hlsl_ctx.cur_scope, yytext)
 177                                     || find_function(yytext))
 178                                 return VAR_IDENTIFIER;
 179                             else if (get_type(hlsl_ctx.cur_scope, yytext, TRUE))
 180                                 return TYPE_IDENTIFIER;
 181                             else
 182                                 return NEW_IDENTIFIER;
 183                         }
 184
 185 [0-9]*\.[0-9]+([eE][+-]?[0-9]+)?[h|H|f|F]? {
 186                             hlsl_lval.floatval = atof(yytext);
 187                             return C_FLOAT;
 188                         }
 189 [0-9]+\.([eE][+-]?[0-9]+)?[h|H|f|F]? {
 190                             hlsl_lval.floatval = atof(yytext);
 191                             return C_FLOAT;
 192                         }
 193 [0-9]+([eE][+-]?[0-9]+)?[h|H|f|F] {
 194                             hlsl_lval.floatval = atof(yytext);
 195                             return C_FLOAT;
 196                         }
 197 0x[0-9a-fA-F]+          {
 198                             sscanf(yytext, "0x%x", &hlsl_lval.intval);
 199                             return C_INTEGER;
 200                         }
 201 0[0-7]+                 {
 202                             sscanf(yytext, "0%o", &hlsl_lval.intval);
 203                             return C_INTEGER;
 204                         }
 205 [0-9]+                  {
 206                             hlsl_lval.intval = (atoi(yytext));
 207                             return C_INTEGER;
 208                         }
 209
 210 {DOUBLESLASHCOMMENT}    {}
 211
 212 {WS}+                   {}
 213 {NEWLINE}               {
 214                             hlsl_ctx.line_no++;
 215                             hlsl_ctx.column = 1;
 216                         }
 217
 218 ^#                      {
 219                             BEGIN pp;
 220                         }
 221
 222 <pp>pragma{WS}+         {
 223                             TRACE("Got a #pragma.\n");
 224                             BEGIN pp_pragma;
 225                         }
 226 <pp_pragma>pack_matrix{WS}*\({WS}*row_major{WS}*\) {
 227                             TRACE("#pragma setting row_major mode.\n");
 228                             hlsl_ctx.matrix_majority = HLSL_ROW_MAJOR;
 229                             BEGIN pp_ignore;
 230                         }
 231 <pp_pragma>pack_matrix{WS}*\({WS}*column_major{WS}*\) {
 232                             TRACE("#pragma setting column_major mode.\n");
 233                             hlsl_ctx.matrix_majority = HLSL_COLUMN_MAJOR;
 234                             BEGIN pp_ignore;
 235                         }
 236 <pp_pragma>{NEWLINE}    {
 237                             FIXME("Unsupported preprocessor #pragma directive at line %u.\n", hlsl_ctx.line_no);
 238                             BEGIN INITIAL;
 239                         }
 240 <pp_pragma>{ANY}        {}
 241 <pp>[0-9]+              {
 242                             TRACE("Preprocessor line info.\n");
 243                             BEGIN pp_line;
 244                             hlsl_lval.intval = (atoi(yytext));
 245                             return PRE_LINE;
 246                         }
 247 <pp_line>{STRING}       {
 248                             char *string = d3dcompiler_strdup(yytext + 1);
 249
 250                             BEGIN pp_ignore;
 251                             string[strlen(string) - 1] = 0;
 252                             hlsl_lval.name = string;
 253                             return STRING;
 254                         }
 255 <pp_line>{WS}+          {}
 256 <pp_line>{NEWLINE}      {
 257                             FIXME("Malformed preprocessor line directive?\n");
 258                             BEGIN INITIAL;
 259                         }
 260 <pp_ignore>{NEWLINE}    {
 261                             BEGIN INITIAL;
 262                         }
 263 <pp_ignore>{ANY}        {}
 264 <pp>{NEWLINE}           {
 265                             FIXME("Unexpected preprocessor directive.\n");
 266                             BEGIN INITIAL;
 267                         }
 268 <pp>{ANY}               {}
 269
 270 {ANY}                   {
 271                             return yytext[0];
 272                         }
 273
 274 %%
 275
 276 struct bwriter_shader *parse_hlsl(enum shader_type type, DWORD major, DWORD minor,
 277         const char *entrypoint, char **messages);
 278
 279 struct bwriter_shader *parse_hlsl_shader(const char *text, enum shader_type type, DWORD major, DWORD minor,
 280         const char *entrypoint, char **messages)
 281 {
 282     struct bwriter_shader *ret = NULL;
 283     YY_BUFFER_STATE buffer;
 284
 285     buffer = hlsl__scan_string(text);
 286     hlsl__switch_to_buffer(buffer);
 287
 288     ret = parse_hlsl(type, major, minor, entrypoint, messages);
 289
 290     hlsl__delete_buffer(buffer);
 291     return ret;
 292 }