lolengine
/
lol
огледало от https://github.com/lolengine/lol
1
0
Разклонения 0
Код Задачи 0 Версии 0 Уики Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2583 Ревизии
5 Клонове
269 MiB
 
 
 
ИН на ревизия: e8a3d0235b
Клонове Маркери
${ item.name }
Create branch ${ searchTerm }
от 'e8a3d0235b'
${ noResults }
lol/doc/grammar/lolfx-scanner.l

799 lines
32 KiB
Директен файл Blame История 

  1. %{

  2. //

  3. //  Lol Engine

  4. //

  5. //  Copyright © 2010-2015 Sam Hocevar <sam@hocevar.net>

  6. //

  7. //  This program is free software. It comes without any warranty, to

  8. //  the extent permitted by applicable law. You can redistribute it

  9. //  and/or modify it under the terms of the Do What the Fuck You Want

  10. //  to Public License, Version 2, as published by the WTFPL Task Force.

  11. //  See http://www.wtfpl.net/ for more details.

  12. //

  13. 

  14. #if defined HAVE_CONFIG_H

  15. #   include "config.h"

  16. #endif

  17. 

  18. #include <cstdlib>

  19. using std::exit;

  20. using std::malloc;

  21. using std::realloc;

  22. using std::free;

  23. #include <iostream>

  24. 

  25. #include "core.h"

  26. #include "gpu/lolfx-compiler.h"

  27. 

  28. typedef lol::LolFxParser::token token;

  29. typedef lol::LolFxParser::token_type token_type;

  30. 

  31. #ifndef YY_DECL

  32. #   define YY_DECL lol::LolFxParser::token_type \

  33.         lol::LolFxScanner::lex(lol::LolFxParser::semantic_type* yylval, \

  34.                                lol::LolFxParser::location_type* yylloc)

  35. #endif

  36. 

  37. #define yyterminate() return token::T_END

  38. #define YY_NO_UNISTD_H

  39. #define YY_USER_ACTION yylloc->columns(yyleng);

  40. %}

  41. 

  42. %option c++ prefix="LolFx"

  43. %option batch yywrap nounput stack

  44. 

  45. %x C_COMMENT

  46. %x CPP_COMMENT

  47. %x PREPROCESSOR_COMMENT

  48. 

  49. %%

  50. 

  51. %{

  52.     /* reset location at the beginning of yylex() */

  53.     yylloc->step();

  54. 

  55.     int language_guess = INITIAL;

  56.     m_pp_stack.Push(BlockIsTrue);

  57. %}

  58. 

  59.  /*

  60.   * GLSL keywords

  61.   */

  62. 

  63. "subroutine"                 { return token::GT_SUBROUTINE; }

  64. "patch"                      { return token::GT_PATCH; }

  65. "sample"                     { return token::GT_SAMPLE; }

  66. "flat"                       { return token::GT_FLAT; }

  67. "smooth"                     { return token::GT_SMOOTH; }

  68. "layout"                     { return token::GT_LAYOUT; }

  69. "sampler1dshadow"            { return token::GT_SAMPLER1DSHADOW; }

  70. "sampler2dshadow"            { return token::GT_SAMPLER2DSHADOW; }

  71. "samplercubeshadow"          { return token::GT_SAMPLERCUBESHADOW; }

  72. "sampler1darray"             { return token::GT_SAMPLER1DARRAY; }

  73. "sampler2darray"             { return token::GT_SAMPLER2DARRAY; }

  74. "sampler1darrayshadow"       { return token::GT_SAMPLER1DARRAYSHADOW; }

  75. "sampler2darrayshadow"       { return token::GT_SAMPLER2DARRAYSHADOW; }

  76. "isampler1d"                 { return token::GT_ISAMPLER1D; }

  77. "isampler2d"                 { return token::GT_ISAMPLER2D; }

  78. "isampler3d"                 { return token::GT_ISAMPLER3D; }

  79. "isamplercube"               { return token::GT_ISAMPLERCUBE; }

  80. "isampler1darray"            { return token::GT_ISAMPLER1DARRAY; }

  81. "isampler2darray"            { return token::GT_ISAMPLER2DARRAY; }

  82. "usampler1d"                 { return token::GT_USAMPLER1D; }

  83. "usampler2d"                 { return token::GT_USAMPLER2D; }

  84. "usampler3d"                 { return token::GT_USAMPLER3D; }

  85. "usamplercube"               { return token::GT_USAMPLERCUBE; }

  86. "usampler1darray"            { return token::GT_USAMPLER1DARRAY; }

  87. "usampler2darray"            { return token::GT_USAMPLER2DARRAY; }

  88. "sampler2drect"              { return token::GT_SAMPLER2DRECT; }

  89. "sampler2drectshadow"        { return token::GT_SAMPLER2DRECTSHADOW; }

  90. "isampler2drect"             { return token::GT_ISAMPLER2DRECT; }

  91. "usampler2drect"             { return token::GT_USAMPLER2DRECT; }

  92. "samplerbuffer"              { return token::GT_SAMPLERBUFFER; }

  93. "isamplerbuffer"             { return token::GT_ISAMPLERBUFFER; }

  94. "usamplerbuffer"             { return token::GT_USAMPLERBUFFER; }

  95. "samplercubearray"           { return token::GT_SAMPLERCUBEARRAY; }

  96. "samplercubearrayshadow"     { return token::GT_SAMPLERCUBEARRAYSHADOW; }

  97. "isamplercubearray"          { return token::GT_ISAMPLERCUBEARRAY; }

  98. "usamplercubearray"          { return token::GT_USAMPLERCUBEARRAY; }

  99. "sampler2dms"                { return token::GT_SAMPLER2DMS; }

  100. "isampler2dms"               { return token::GT_ISAMPLER2DMS; }

  101. "usampler2dms"               { return token::GT_USAMPLER2DMS; }

  102. "sampler2dmsarray"           { return token::GT_SAMPLER2DMSARRAY; }

  103. "isampler2dmsarray"          { return token::GT_ISAMPLER2DMSARRAY; }

  104. "usampler2dmsarray"          { return token::GT_USAMPLER2DMSARRAY; }

  105. 

  106. "highp"                      { return token::GT_HIGHP; }

  107. "mediump"                    { return token::GT_MEDIUMP; }

  108. "lowp"                       { return token::GT_LOWP; }

  109. "precision"                  { return token::GT_PRECISION; }

  110. "invariant"                  { return token::GT_INVARIANT; }

  111. 

  112.  /*

  113.   * Deprecated GLSL keywords

  114.   */

  115. 

  116. "attribute"                  { return token::GT_ATTRIBUTE; }

  117. "varying"                    { return token::GT_VARYING; }

  118. 

  119.  /*

  120.   * GLSL vector types

  121.   */

  122. 

  123. "bvec2"                      { return token::GT_BVEC2; }

  124. "bvec3"                      { return token::GT_BVEC3; }

  125. "bvec4"                      { return token::GT_BVEC4; }

  126. 

  127. "ivec2"                      { return token::GT_IVEC2; }

  128. "ivec3"                      { return token::GT_IVEC3; }

  129. "ivec4"                      { return token::GT_IVEC4; }

  130. 

  131. "uvec2"                      { return token::GT_UVEC2; }

  132. "uvec3"                      { return token::GT_UVEC3; }

  133. "uvec4"                      { return token::GT_UVEC4; }

  134. 

  135. "vec2"                       { return token::GT_VEC2; }

  136. "vec3"                       { return token::GT_VEC3; }

  137. "vec4"                       { return token::GT_VEC4; }

  138. "mat2"                       { return token::GT_MAT2; }

  139. "mat2x2"                     { return token::GT_MAT2X2; }

  140. "mat2x3"                     { return token::GT_MAT2X3; }

  141. "mat2x4"                     { return token::GT_MAT2X4; }

  142. "mat3"                       { return token::GT_MAT3; }

  143. "mat3x2"                     { return token::GT_MAT3X2; }

  144. "mat3x3"                     { return token::GT_MAT3X3; }

  145. "mat3x4"                     { return token::GT_MAT3X4; }

  146. "mat4"                       { return token::GT_MAT4; }

  147. "mat4x2"                     { return token::GT_MAT4X2; }

  148. "mat4x3"                     { return token::GT_MAT4X3; }

  149. "mat4x4"                     { return token::GT_MAT4X4; }

  150. 

  151. "dvec2"                      { return token::GT_DVEC2; }

  152. "dvec3"                      { return token::GT_DVEC3; }

  153. "dvec4"                      { return token::GT_DVEC4; }

  154. "dmat2"                      { return token::GT_DMAT2; }

  155. "dmat2x2"                    { return token::GT_DMAT2X2; }

  156. "dmat2x3"                    { return token::GT_DMAT2X3; }

  157. "dmat2x4"                    { return token::GT_DMAT2X4; }

  158. "dmat3"                      { return token::GT_DMAT3; }

  159. "dmat3x2"                    { return token::GT_DMAT3X2; }

  160. "dmat3x3"                    { return token::GT_DMAT3X3; }

  161. "dmat3x4"                    { return token::GT_DMAT3X4; }

  162. "dmat4"                      { return token::GT_DMAT4; }

  163. "dmat4x2"                    { return token::GT_DMAT4X2; }

  164. "dmat4x3"                    { return token::GT_DMAT4X3; }

  165. "dmat4x4"                    { return token::GT_DMAT4X4; }

  166. 

  167.  /*

  168.   * GLSL constant values

  169.   */

  170. 

  171. "true"                       { yylval->ival = 1; return token::BOOLCONSTANT; }

  172. "false"                      { yylval->ival = 0; return token::BOOLCONSTANT; }

  173. 

  174.  /*

  175.   * GLSL keywords that are also valid or reserved in HLSL

  176.   * and HLSL keywords that are also valid or reserved in GLSL.

  177.   */

  178. 

  179. "bool"                       { return token::GHT_BOOL; }

  180. "break"                      { return token::GHT_BREAK; }

  181. "case"                       { return token::GHT_CASE; }

  182. "centroid"                   { return token::GHT_CENTROID; }

  183. "const"                      { return token::GHT_CONST; }

  184. "continue"                   { return token::GHT_CONTINUE; }

  185. "default"                    { return token::GHT_DEFAULT; }

  186. "discard"                    { return token::GHT_DISCARD; }

  187. "do"                         { return token::GHT_DO; }

  188. "double"                     { return token::GHT_DOUBLE; }

  189. "else"                       { return token::GHT_ELSE; }

  190. "float"                      { return token::GHT_FLOAT; }

  191. "for"                        { return token::GHT_FOR; }

  192. "if"                         { return token::GHT_IF; }

  193. "in"                         { return token::GHT_IN; }

  194. "inout"                      { return token::GHT_INOUT; }

  195. "int"                        { return token::GHT_INT; }

  196. "noperspective"              { return token::GHT_NOPERSPECTIVE; }

  197. "out"                        { return token::GHT_OUT; }

  198. "return"                     { return token::GHT_RETURN; }

  199. "sampler1d"                  { return token::GHT_SAMPLER1D; }

  200. "sampler2d"                  { return token::GHT_SAMPLER2D; }

  201. "sampler3d"                  { return token::GHT_SAMPLER3D; }

  202. "samplercube"                { return token::GHT_SAMPLERCUBE; }

  203. "struct"                     { return token::GHT_STRUCT; }

  204. "switch"                     { return token::GHT_SWITCH; }

  205. "uint"                       { return token::GHT_UINT; }

  206. "uniform"                    { return token::GHT_UNIFORM; }

  207. "void"                       { return token::GHT_VOID; }

  208. "while"                      { return token::GHT_WHILE; }

  209. 

  210. (?i:bool)                    { return token::HGT_BOOL; }

  211. (?i:break)                   { return token::HGT_BREAK; }

  212. (?i:case)                    { return token::HGT_CASE; }

  213. (?i:centroid)                { return token::HGT_CENTROID; }

  214. (?i:const)                   { return token::HGT_CONST; }

  215. (?i:continue)                { return token::HGT_CONTINUE; }

  216. (?i:default)                 { return token::HGT_DEFAULT; }

  217. (?i:discard)                 { return token::HGT_DISCARD; }

  218. (?i:do)                      { return token::HGT_DO; }

  219. (?i:double)                  { return token::HGT_DOUBLE; }

  220. (?i:else)                    { return token::HGT_ELSE; }

  221. (?i:float)                   { return token::HGT_FLOAT; }

  222. (?i:for)                     { return token::HGT_FOR; }

  223. (?i:if)                      { return token::HGT_IF; }

  224. (?i:in)                      { return token::HGT_IN; }

  225. (?i:inout)                   { return token::HGT_INOUT; }

  226. (?i:int)                     { return token::HGT_INT; }

  227. (?i:noperspective)           { return token::HGT_NOPERSPECTIVE; }

  228. (?i:out)                     { return token::HGT_OUT; }

  229. (?i:return)                  { return token::HGT_RETURN; }

  230. (?i:sampler1d)               { return token::HGT_SAMPLER1D; }

  231. (?i:sampler2d)               { return token::HGT_SAMPLER2D; }

  232. (?i:sampler3d)               { return token::HGT_SAMPLER3D; }

  233. (?i:samplercube)             { return token::HGT_SAMPLERCUBE; }

  234. (?i:struct)                  { return token::HGT_STRUCT; }

  235. (?i:switch)                  { return token::HGT_SWITCH; }

  236. (?i:uint)                    { return token::HGT_UINT; }

  237. (?i:uniform)                 { return token::HGT_UNIFORM; }

  238. (?i:void)                    { return token::HGT_VOID; }

  239. (?i:while)                   { return token::HGT_WHILE; }

  240. 

  241.  /*

  242.   * HLSL keywords

  243.   * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509568%28v=vs.85%29.aspx

  244.   */

  245. 

  246. (?i:appendstructuredbuffer)  { return token::HT_APPENDSTRUCTUREDBUFFER; }

  247. (?i:asm)                     { return token::HT_ASM; }

  248. (?i:asm_fragment)            { return token::HT_ASM_FRAGMENT; }

  249. (?i:blendstate)              { return token::HT_BLENDSTATE; }

  250. (?i:buffer)                  { return token::HT_BUFFER; }

  251. (?i:byteaddressbuffer)       { return token::HT_BYTEADDRESSBUFFER; }

  252. (?i:cbuffer)                 { return token::HT_CBUFFER; }

  253. (?i:column_major)            { return token::HT_COLUMN_MAJOR; }

  254. (?i:compile)                 { return token::HT_COMPILE; }

  255. (?i:compile_fragment)        { return token::HT_COMPILE_FRAGMENT; }

  256. (?i:compileshader)           { return token::HT_COMPILESHADER; }

  257. (?i:computeshader)           { return token::HT_COMPUTESHADER; }

  258. (?i:consumestructuredbuffer) { return token::HT_CONSUMESTRUCTUREDBUFFER; }

  259. (?i:depthstencilstate)       { return token::HT_DEPTHSTENCILSTATE; }

  260. (?i:depthstencilview)        { return token::HT_DEPTHSTENCILVIEW; }

  261. (?i:domainshader)            { return token::HT_DOMAINSHADER; }

  262. (?i:dword)                   { return token::HT_DWORD; }

  263. (?i:extern)                  { return token::HT_EXTERN; }

  264. (?i:false)                   { return token::HT_FALSE; }

  265. (?i:fxgroup)                 { return token::HT_FXGROUP; }

  266. (?i:geometryshader)          { return token::HT_GEOMETRYSHADER; }

  267. (?i:groupshared)             { return token::HT_GROUPSHARED; }

  268. (?i:half)                    { return token::HT_HALF; }

  269. (?i:hullshader)              { return token::HT_HULLSHADER; }

  270. (?i:inline)                  { return token::HT_INLINE; }

  271. (?i:inputpatch)              { return token::HT_INPUTPATCH; }

  272. (?i:interface)               { return token::HT_INTERFACE; }

  273. (?i:line)                    { return token::HT_LINE; }

  274. (?i:lineadj)                 { return token::HT_LINEADJ; }

  275. (?i:linear)                  { return token::HT_LINEAR; }

  276. (?i:linestream)              { return token::HT_LINESTREAM; }

  277. (?i:matrix)                  { return token::HT_MATRIX; }

  278. (?i:namespace)               { return token::HT_NAMESPACE; }

  279. (?i:nointerpolation)         { return token::HT_NOINTERPOLATION; }

  280. (?i:null)                    { return token::HT_NULL; }

  281. (?i:outputpatch)             { return token::HT_OUTPUTPATCH; }

  282. (?i:packoffset)              { return token::HT_PACKOFFSET; }

  283. (?i:pass)                    { return token::HT_PASS; }

  284. (?i:pixelfragment)           { return token::HT_PIXELFRAGMENT; }

  285. (?i:pixelshader)             { return token::HT_PIXELSHADER; }

  286. (?i:point)                   { return token::HT_POINT; }

  287. (?i:pointstream)             { return token::HT_POINTSTREAM; }

  288. (?i:precise)                 { return token::HT_PRECISE; }

  289. (?i:rasterizerstate)         { return token::HT_RASTERIZERSTATE; }

  290. (?i:rendertargetview)        { return token::HT_RENDERTARGETVIEW; }

  291. (?i:register)                { return token::HT_REGISTER; }

  292. (?i:row_major)               { return token::HT_ROW_MAJOR; }

  293. (?i:rwbuffer)                { return token::HT_RWBUFFER; }

  294. (?i:rwbyteaddressbuffer)     { return token::HT_RWBYTEADDRESSBUFFER; }

  295. (?i:rwstructuredbuffer)      { return token::HT_RWSTRUCTUREDBUFFER; }

  296. (?i:rwtexture1d)             { return token::HT_RWTEXTURE1D; }

  297. (?i:rwtexture1darray)        { return token::HT_RWTEXTURE1DARRAY; }

  298. (?i:rwtexture2d)             { return token::HT_RWTEXTURE2D; }

  299. (?i:rwtexture2darray)        { return token::HT_RWTEXTURE2DARRAY; }

  300. (?i:rwtexture3d)             { return token::HT_RWTEXTURE3D; }

  301. (?i:sampler)                 { return token::HT_SAMPLER; }

  302. (?i:sampler_state)           { return token::HT_SAMPLER_STATE; }

  303. (?i:samplerstate)            { return token::HT_SAMPLERSTATE; }

  304. (?i:samplercomparisonstate)  { return token::HT_SAMPLERCOMPARISONSTATE; }

  305. (?i:shared)                  { return token::HT_SHARED; }

  306. (?i:snorm)                   { return token::HT_SNORM; }

  307. (?i:stateblock)              { return token::HT_STATEBLOCK; }

  308. (?i:stateblock_state)        { return token::HT_STATEBLOCK_STATE; }

  309. (?i:static)                  { return token::HT_STATIC; }

  310. (?i:string)                  { return token::HT_STRING; }

  311. (?i:structuredbuffer)        { return token::HT_STRUCTUREDBUFFER; }

  312. (?i:tbuffer)                 { return token::HT_TBUFFER; }

  313. (?i:technique)               { return token::HT_TECHNIQUE; }

  314. (?i:technique10)             { return token::HT_TECHNIQUE10; }

  315. (?i:technique11xz)           { return token::HT_TECHNIQUE11XZ; }

  316. "texture"                    { return token::HT_TEXTURE; }

  317. (?i:texture1d)               { return token::HT_TEXTURE1D; }

  318. (?i:texture1darray)          { return token::HT_TEXTURE1DARRAY; }

  319. (?i:texture2d)               { return token::HT_TEXTURE2D; }

  320. (?i:texture2darray)          { return token::HT_TEXTURE2DARRAY; }

  321. (?i:texture2dms)             { return token::HT_TEXTURE2DMS; }

  322. (?i:texture2dmsarray)        { return token::HT_TEXTURE2DMSARRAY; }

  323. (?i:texture3d)               { return token::HT_TEXTURE3D; }

  324. (?i:texturecube)             { return token::HT_TEXTURECUBE; }

  325. (?i:texturecubearray)        { return token::HT_TEXTURECUBEARRAY; }

  326. (?i:true)                    { return token::HT_TRUE; }

  327. (?i:typedef)                 { return token::HT_TYPEDEF; }

  328. (?i:triangle)                { return token::HT_TRIANGLE; }

  329. (?i:triangleadj)             { return token::HT_TRIANGLEADJ; }

  330. (?i:trianglestream)          { return token::HT_TRIANGLESTREAM; }

  331. (?i:unorm)                   { return token::HT_UNORM; }

  332. (?i:vector)                  { return token::HT_VECTOR; }

  333. (?i:vertexfragment)          { return token::HT_VERTEXFRAGMENT; }

  334. (?i:vertexshader)            { return token::HT_VERTEXSHADER; }

  335. (?i:volatile)                { return token::HT_VOLATILE; }

  336. 

  337.  /*

  338.   * HLSL vector types

  339.   * TODO: this can probably be factored somehow

  340.   */

  341. 

  342. (?i:bool1)                   { return token::HT_BOOL1; }

  343. (?i:bool1x1)                 { return token::HT_BOOL1x1; }

  344. (?i:bool2x1)                 { return token::HT_BOOL2x1; }

  345. (?i:bool3x1)                 { return token::HT_BOOL3x1; }

  346. (?i:bool4x1)                 { return token::HT_BOOL4x1; }

  347. (?i:bool2)                   { return token::HT_BOOL2; }

  348. (?i:bool1x2)                 { return token::HT_BOOL1x2; }

  349. (?i:bool2x2)                 { return token::HT_BOOL2x2; }

  350. (?i:bool3x2)                 { return token::HT_BOOL3x2; }

  351. (?i:bool4x2)                 { return token::HT_BOOL4x2; }

  352. (?i:bool3)                   { return token::HT_BOOL3; }

  353. (?i:bool1x3)                 { return token::HT_BOOL1x3; }

  354. (?i:bool2x3)                 { return token::HT_BOOL2x3; }

  355. (?i:bool3x3)                 { return token::HT_BOOL3x3; }

  356. (?i:bool4x3)                 { return token::HT_BOOL4x3; }

  357. (?i:bool4)                   { return token::HT_BOOL4; }

  358. (?i:bool1x4)                 { return token::HT_BOOL1x4; }

  359. (?i:bool2x4)                 { return token::HT_BOOL2x4; }

  360. (?i:bool3x4)                 { return token::HT_BOOL3x4; }

  361. (?i:bool4x4)                 { return token::HT_BOOL4x4; }

  362. 

  363. (?i:float1)                  { return token::HT_FLOAT1; }

  364. (?i:float1x1)                { return token::HT_FLOAT1x1; }

  365. (?i:float2x1)                { return token::HT_FLOAT2x1; }

  366. (?i:float3x1)                { return token::HT_FLOAT3x1; }

  367. (?i:float4x1)                { return token::HT_FLOAT4x1; }

  368. (?i:float2)                  { return token::HT_FLOAT2; }

  369. (?i:float1x2)                { return token::HT_FLOAT1x2; }

  370. (?i:float2x2)                { return token::HT_FLOAT2x2; }

  371. (?i:float3x2)                { return token::HT_FLOAT3x2; }

  372. (?i:float4x2)                { return token::HT_FLOAT4x2; }

  373. (?i:float3)                  { return token::HT_FLOAT3; }

  374. (?i:float1x3)                { return token::HT_FLOAT1x3; }

  375. (?i:float2x3)                { return token::HT_FLOAT2x3; }

  376. (?i:float3x3)                { return token::HT_FLOAT3x3; }

  377. (?i:float4x3)                { return token::HT_FLOAT4x3; }

  378. (?i:float4)                  { return token::HT_FLOAT4; }

  379. (?i:float1x4)                { return token::HT_FLOAT1x4; }

  380. (?i:float2x4)                { return token::HT_FLOAT2x4; }

  381. (?i:float3x4)                { return token::HT_FLOAT3x4; }

  382. (?i:float4x4)                { return token::HT_FLOAT4x4; }

  383. 

  384. (?i:double1)                 { return token::HT_DOUBLE1; }

  385. (?i:double1x1)               { return token::HT_DOUBLE1x1; }

  386. (?i:double2x1)               { return token::HT_DOUBLE2x1; }

  387. (?i:double3x1)               { return token::HT_DOUBLE3x1; }

  388. (?i:double4x1)               { return token::HT_DOUBLE4x1; }

  389. (?i:double2)                 { return token::HT_DOUBLE2; }

  390. (?i:double1x2)               { return token::HT_DOUBLE1x2; }

  391. (?i:double2x2)               { return token::HT_DOUBLE2x2; }

  392. (?i:double3x2)               { return token::HT_DOUBLE3x2; }

  393. (?i:double4x2)               { return token::HT_DOUBLE4x2; }

  394. (?i:double3)                 { return token::HT_DOUBLE3; }

  395. (?i:double1x3)               { return token::HT_DOUBLE1x3; }

  396. (?i:double2x3)               { return token::HT_DOUBLE2x3; }

  397. (?i:double3x3)               { return token::HT_DOUBLE3x3; }

  398. (?i:double4x3)               { return token::HT_DOUBLE4x3; }

  399. (?i:double4)                 { return token::HT_DOUBLE4; }

  400. (?i:double1x4)               { return token::HT_DOUBLE1x4; }

  401. (?i:double2x4)               { return token::HT_DOUBLE2x4; }

  402. (?i:double3x4)               { return token::HT_DOUBLE3x4; }

  403. (?i:double4x4)               { return token::HT_DOUBLE4x4; }

  404. 

  405. (?i:dword1)                  { return token::HT_DWORD1; }

  406. (?i:dword1x1)                { return token::HT_DWORD1x1; }

  407. (?i:dword2x1)                { return token::HT_DWORD2x1; }

  408. (?i:dword3x1)                { return token::HT_DWORD3x1; }

  409. (?i:dword4x1)                { return token::HT_DWORD4x1; }

  410. (?i:dword2)                  { return token::HT_DWORD2; }

  411. (?i:dword1x2)                { return token::HT_DWORD1x2; }

  412. (?i:dword2x2)                { return token::HT_DWORD2x2; }

  413. (?i:dword3x2)                { return token::HT_DWORD3x2; }

  414. (?i:dword4x2)                { return token::HT_DWORD4x2; }

  415. (?i:dword3)                  { return token::HT_DWORD3; }

  416. (?i:dword1x3)                { return token::HT_DWORD1x3; }

  417. (?i:dword2x3)                { return token::HT_DWORD2x3; }

  418. (?i:dword3x3)                { return token::HT_DWORD3x3; }

  419. (?i:dword4x3)                { return token::HT_DWORD4x3; }

  420. (?i:dword4)                  { return token::HT_DWORD4; }

  421. (?i:dword1x4)                { return token::HT_DWORD1x4; }

  422. (?i:dword2x4)                { return token::HT_DWORD2x4; }

  423. (?i:dword3x4)                { return token::HT_DWORD3x4; }

  424. (?i:dword4x4)                { return token::HT_DWORD4x4; }

  425. 

  426. (?i:int1)                    { return token::HT_INT1; }

  427. (?i:int1x1)                  { return token::HT_INT1x1; }

  428. (?i:int2x1)                  { return token::HT_INT2x1; }

  429. (?i:int3x1)                  { return token::HT_INT3x1; }

  430. (?i:int4x1)                  { return token::HT_INT4x1; }

  431. (?i:int2)                    { return token::HT_INT2; }

  432. (?i:int1x2)                  { return token::HT_INT1x2; }

  433. (?i:int2x2)                  { return token::HT_INT2x2; }

  434. (?i:int3x2)                  { return token::HT_INT3x2; }

  435. (?i:int4x2)                  { return token::HT_INT4x2; }

  436. (?i:int3)                    { return token::HT_INT3; }

  437. (?i:int1x3)                  { return token::HT_INT1x3; }

  438. (?i:int2x3)                  { return token::HT_INT2x3; }

  439. (?i:int3x3)                  { return token::HT_INT3x3; }

  440. (?i:int4x3)                  { return token::HT_INT4x3; }

  441. (?i:int4)                    { return token::HT_INT4; }

  442. (?i:int1x4)                  { return token::HT_INT1x4; }

  443. (?i:int2x4)                  { return token::HT_INT2x4; }

  444. (?i:int3x4)                  { return token::HT_INT3x4; }

  445. (?i:int4x4)                  { return token::HT_INT4x4; }

  446. 

  447. (?i:uint1)                   { return token::HT_UINT1; }

  448. (?i:uint1x1)                 { return token::HT_UINT1x1; }

  449. (?i:uint2x1)                 { return token::HT_UINT2x1; }

  450. (?i:uint3x1)                 { return token::HT_UINT3x1; }

  451. (?i:uint4x1)                 { return token::HT_UINT4x1; }

  452. (?i:uint2)                   { return token::HT_UINT2; }

  453. (?i:uint1x2)                 { return token::HT_UINT1x2; }

  454. (?i:uint2x2)                 { return token::HT_UINT2x2; }

  455. (?i:uint3x2)                 { return token::HT_UINT3x2; }

  456. (?i:uint4x2)                 { return token::HT_UINT4x2; }

  457. (?i:uint3)                   { return token::HT_UINT3; }

  458. (?i:uint1x3)                 { return token::HT_UINT1x3; }

  459. (?i:uint2x3)                 { return token::HT_UINT2x3; }

  460. (?i:uint3x3)                 { return token::HT_UINT3x3; }

  461. (?i:uint4x3)                 { return token::HT_UINT4x3; }

  462. (?i:uint4)                   { return token::HT_UINT4; }

  463. (?i:uint1x4)                 { return token::HT_UINT1x4; }

  464. (?i:uint2x4)                 { return token::HT_UINT2x4; }

  465. (?i:uint3x4)                 { return token::HT_UINT3x4; }

  466. (?i:uint4x4)                 { return token::HT_UINT4x4; }

  467. 

  468.  /*

  469.   * HLSL preprocessor directives

  470.   * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb943993%28v=vs.85%29.aspx

  471.   */

  472. 

  473. ^[ \t]*"#"[ \t]*"define".* {

  474.     /* FIXME: this is very, very limited */

  475.     char const *tmp = strstr(yytext, "define") + 6;

  476.     while (*tmp == ' ' || *tmp == '\n')

  477.         tmp++;

  478.     if (*tmp == '\0')

  479.         return token::PREPROCESSOR_DEFINE;

  480.     char const *tmp2 = tmp;

  481.     while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0')

  482.         tmp++;

  483.     String key(tmp2, (int)(tmp - tmp2));

  484.     while (*tmp == ' ' || *tmp == '\n')

  485.         tmp++;

  486.     String val(*tmp ? tmp : "1");

  487. 

  488.     Log::Debug("new macro: ‘%s’ = ‘%s’\n", key.C(), val.C());

  489.     m_pp_defines[key] = val;

  490. }

  491. 

  492. ^[ \t]*"#"[ \t]*"elif" {

  493.     if (m_pp_stack.Count() <= 1)

  494.         return token::PREPROCESSOR_ELIF;

  495.     m_pp_stack.Last() = BlockIsForeverFalse;

  496.     BEGIN(PREPROCESSOR_COMMENT);

  497. }

  498. 

  499. ^[ \t]*"#"[ \t]*"else" {

  500.     if (m_pp_stack.Count() <= 1)

  501.         return token::PREPROCESSOR_ELSE;

  502.     m_pp_stack.Last() = BlockIsForeverFalse;

  503.     BEGIN(PREPROCESSOR_COMMENT);

  504. }

  505. 

  506. ^[ \t]*"#"[ \t]*"endif" {

  507.     if (m_pp_stack.Count() <= 1)

  508.         return token::PREPROCESSOR_ENDIF;

  509.     m_pp_stack.Pop();

  510. }

  511. 

  512. ^[ \t]*"#"[ \t]*"error".*    { return token::PREPROCESSOR_ERROR; }

  513. 

  514. ^[ \t]*"#"[ \t]*"if".* {

  515.     if (IsExpressionTrue(strstr(yytext, "if") + 2))

  516.     {

  517.         m_pp_stack.Push(BlockIsTrue);

  518.     }

  519.     else

  520.     {

  521.         m_pp_stack.Push(BlockIsFalse);

  522.         BEGIN(PREPROCESSOR_COMMENT);

  523.     }

  524. }

  525. 

  526. ^[ \t]*"#"[ \t]*"ifdef" {

  527.     /* FIXME: this is very, very limited */

  528.     char const *tmp = strstr(yytext, "ifdef") + 5;

  529.     while (*tmp == ' ' || *tmp == '\n')

  530.         tmp++;

  531.     if (*tmp == '\0')

  532.         return token::PREPROCESSOR_IFDEF;

  533.     char const *tmp2 = tmp;

  534.     while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0')

  535.         tmp++;

  536.     String key(tmp2, (int)(tmp - tmp2));

  537.     if (m_pp_defines.has_key(key))

  538.     {

  539.         m_pp_stack.Push(BlockIsTrue);

  540.     }

  541.     else

  542.     {

  543.         m_pp_stack.Push(BlockIsFalse);

  544.         BEGIN(PREPROCESSOR_COMMENT);

  545.     }

  546. }

  547. 

  548. ^[ \t]*"#"[ \t]*"ifndef" {

  549.     /* FIXME: this is very, very limited */

  550.     char const *tmp = strstr(yytext, "ifndef") + 6;

  551.     while (*tmp == ' ' || *tmp == '\n')

  552.         tmp++;

  553.     if (*tmp == '\0')

  554.         return token::PREPROCESSOR_IFDEF;

  555.     char const *tmp2 = tmp;

  556.     while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0')

  557.         tmp++;

  558.     String key(tmp2, (int)(tmp - tmp2));

  559.     if (m_pp_defines.has_key(key))

  560.     {

  561.         m_pp_stack.Push(BlockIsFalse);

  562.         BEGIN(PREPROCESSOR_COMMENT);

  563.     }

  564.     else

  565.     {

  566.         m_pp_stack.Push(BlockIsTrue);

  567.     }

  568. }

  569. 

  570. ^[ \t]*"#"[ \t]*"include"    { return token::PREPROCESSOR_INCLUDE; }

  571. 

  572. ^[ \t]*"#"[ \t]*"line".*     { /* ignore for now */ }

  573. 

  574. ^[ \t]*"#"[ \t]*"pragma".*   { /* ignore for now */ }

  575. 

  576. ^[ \t]*"#"[ \t]*"undef" {

  577.     /* FIXME: this is very, very limited */

  578.     char const *tmp = strstr(yytext, "undef") + 5;

  579.     while (*tmp == ' ' || *tmp == '\n')

  580.         tmp++;

  581.     if (*tmp == '\0')

  582.         return token::PREPROCESSOR_UNDEF;

  583.     char const *tmp2 = tmp;

  584.     while (*tmp != ' ' && *tmp != '\n' && *tmp != '\0')

  585.         tmp++;

  586.     String key(tmp2, (int)(tmp - tmp2));

  587. 

  588.     Log::Debug("undef macro: ‘%s’\n", key.C());

  589.     m_pp_defines.remove(key);

  590. }

  591. 

  592. <PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*(if|ifdef|ifndef)[ \t]+.*$ {

  593.     m_pp_stack.Push(BlockIsForeverFalse);

  594. }

  595. <PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*"else" {

  596.     switch (m_pp_stack.Last())

  597.     {

  598.         case BlockIsFalse:

  599.             m_pp_stack.Last() = BlockIsTrue;

  600.             BEGIN(INITIAL);

  601.             break;

  602.         case BlockIsForeverFalse:

  603.             break;

  604.         case BlockIsTrue:

  605.             m_pp_stack.Last() = BlockIsForeverFalse;

  606.             break;

  607.     }

  608. }

  609. <PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*"elif" {

  610.     switch (m_pp_stack.Last())

  611.     {

  612.         case BlockIsFalse:

  613.             if (IsExpressionTrue(strstr(yytext, "elif") + 4))

  614.             {

  615.                 m_pp_stack.Last() = BlockIsTrue;

  616.                 BEGIN(INITIAL);

  617.             }

  618.             break;

  619.         case BlockIsForeverFalse:

  620.             break;

  621.         case BlockIsTrue:

  622.             m_pp_stack.Last() = BlockIsForeverFalse;

  623.             break;

  624.     }

  625. }

  626. <PREPROCESSOR_COMMENT>^[ \t]*"#"[ \t]*"endif" {

  627.     m_pp_stack.Pop();

  628.     if (m_pp_stack.Last() == BlockIsTrue)

  629.         BEGIN(INITIAL);

  630. }

  631. <PREPROCESSOR_COMMENT>\n     { yylloc->lines(1); }

  632. <PREPROCESSOR_COMMENT>[^/#]* { }

  633. <PREPROCESSOR_COMMENT>"/*"   { BEGIN(C_COMMENT); }

  634. <PREPROCESSOR_COMMENT>[/#]   { }

  635. 

  636.  /*

  637.   * GLSL preprocessor directives

  638.   */

  639. 

  640. ^[ \t]*"#"[ \t]*"version"[^\n]* { /* ignore for now */ }

  641. 

  642.  /*

  643.   * HLSL reserved keywords

  644.   * Gathered from http://msdn.microsoft.com/en-us/library/windows/desktop/bb509569%28v=vs.85%29.aspx

  645.   */

  646. 

  647. (?i:auto)                    { return token::HT_AUTO; }

  648. (?i:catch)                   { return token::HT_CATCH; }

  649. (?i:char)                    { return token::HT_CHAR; }

  650. (?i:class)                   { return token::HT_CLASS; }

  651. (?i:const_cast)              { return token::HT_CONST_CAST; }

  652. (?i:delete)                  { return token::HT_DELETE; }

  653. (?i:dynamic_cast)            { return token::HT_DYNAMIC_CAST; }

  654. (?i:enum)                    { return token::HT_ENUM; }

  655. (?i:explicit)                { return token::HT_EXPLICIT; }

  656. (?i:friend)                  { return token::HT_FRIEND; }

  657. (?i:goto)                    { return token::HT_GOTO; }

  658. (?i:long)                    { return token::HT_LONG; }

  659. (?i:mutable)                 { return token::HT_MUTABLE; }

  660. (?i:new)                     { return token::HT_NEW; }

  661. (?i:operator)                { return token::HT_OPERATOR; }

  662. (?i:private)                 { return token::HT_PRIVATE; }

  663. (?i:protected)               { return token::HT_PROTECTED; }

  664. (?i:public)                  { return token::HT_PUBLIC; }

  665. (?i:reinterpret_cast)        { return token::HT_REINTERPRET_CAST; }

  666. (?i:short)                   { return token::HT_SHORT; }

  667. (?i:signed)                  { return token::HT_SIGNED; }

  668. (?i:sizeof)                  { return token::HT_SIZEOF; }

  669. (?i:static_cast)             { return token::HT_STATIC_CAST; }

  670. (?i:template)                { return token::HT_TEMPLATE; }

  671. (?i:this)                    { return token::HT_THIS; }

  672. (?i:throw)                   { return token::HT_THROW; }

  673. (?i:try)                     { return token::HT_TRY; }

  674. (?i:typename)                { return token::HT_TYPENAME; }

  675. (?i:union)                   { return token::HT_UNION; }

  676. (?i:unsigned)                { return token::HT_UNSIGNED; }

  677. (?i:using)                   { return token::HT_USING; }

  678. (?i:virtual)                 { return token::HT_VIRTUAL; }

  679. 

  680.  /*

  681.   * Various tokens

  682.   */

  683. 

  684. "++"                    { return token::T_INC; }

  685. "--"                    { return token::T_DEC; }

  686. "<="                    { return token::T_LE; }

  687. ">="                    { return token::T_GE; }

  688. "=="                    { return token::T_EQ; }

  689. "!="                    { return token::T_NE; }

  690. "<<"                    { return token::T_LEFT; }

  691. ">>"                    { return token::T_RIGHT; }

  692. "&&"                    { return token::T_AND; }

  693. "||"                    { return token::T_OR; }

  694. "^^"                    { return token::T_XOR; }

  695. 

  696. "*="                    { return token::T_MULEQ; }

  697. "/="                    { return token::T_DIVEQ; }

  698. "%="                    { return token::T_MODEQ; }

  699. "+="                    { return token::T_ADDEQ; }

  700. "-="                    { return token::T_SUBEQ; }

  701. "<<="                   { return token::T_LEFTEQ; }

  702. ">>="                   { return token::T_RIGHTEQ; }

  703. "&="                    { return token::T_ANDEQ; }

  704. "^="                    { return token::T_XOREQ; }

  705. "|="                    { return token::T_OREQ; }

  706. 

  707. (0|[1-9][0-9]*)\.[0-9]+ {

  708.     yylval->fval = std::atof(yytext);

  709.     return token::FLOATCONSTANT;

  710. }

  711. (0|[1-9][0-9]*)[uU]     {

  712.     yylval->uval = std::atoi(yytext);

  713.     return token::UINTCONSTANT;

  714. }

  715. (0|[1-9][0-9]*)         {

  716.     yylval->ival = std::atoi(yytext);

  717.     return token::INTCONSTANT;

  718. }

  719. 

  720. ([xyzw]{1,4}|[rgba]{1,4}|[stpq]{1,4}) {

  721.     /* Copy token for now */

  722.     yylval->sval = strdup(yytext);

  723.     return token::FIELDSELECTION;

  724. }

  725. 

  726. [a-zA-Z_][a-zA-Z0-9_]*   {

  727.     /* Copy token for now */

  728.     yylval->sval = strdup(yytext);

  729.     return token::IDENTIFIER;

  730. }

  731. 

  732. [ \t\r]+            { /* ignore whitespace */ }

  733. [\n]                { yylloc->lines(1); }

  734. .                   { return (token_type)*yytext; /* accept all characters */ }

  735. 

  736.  /*

  737.   * Ignore C comments

  738.   */

  739. 

  740. "/*"                { BEGIN(C_COMMENT); }

  741. <C_COMMENT>[^*\n]*  { }

  742. <C_COMMENT>\n       { yylloc->lines(1); }

  743. <C_COMMENT>.        { }

  744. <C_COMMENT>"*/"     {

  745.     if (m_pp_stack.Last() == BlockIsTrue)

  746.         BEGIN(INITIAL);

  747.     else

  748.         BEGIN(PREPROCESSOR_COMMENT);

  749. }

  750. 

  751.  /*

  752.   * Ignore C++ comments

  753.   */

  754. 

  755. "//"              { BEGIN(CPP_COMMENT); }

  756. <CPP_COMMENT>\n   { yylloc->lines(1); BEGIN(INITIAL); }

  757. <CPP_COMMENT>.*   { }

  758. 

  759. %%

  760. 

  761. lol::LolFxScanner::LolFxScanner(char const *command)

  762.     : LolFxFlexLexer(0, 0),

  763.       m_input(command)

  764. {

  765. }

  766. 

  767. lol::LolFxScanner::~LolFxScanner()

  768. {

  769. }

  770. 

  771. int lol::LolFxScanner::LexerInput(char* buf, int max_size)

  772. {

  773.     buf[0] = m_input[0];

  774.     if (buf[0])

  775.         ++m_input;

  776.     return buf[0] ? 1 : 0;

  777. }

  778. 

  779. bool lol::LolFxScanner::IsExpressionTrue(char const *buf)

  780. {

  781.     /* FIXME: this is really too limited */

  782.     return std::atoi(buf) != 0;

  783. }

  784. 

  785. #ifdef yylex

  786. #undef yylex

  787. #endif

  788. int LolFxFlexLexer::yylex()

  789. {

  790.     std::cerr << "in LolFxFlexLexer::yylex() !" << std::endl;

  791.     return 0;

  792. }

  793. 

  794. int LolFxFlexLexer::yywrap()

  795. {

  796.     return 1;

  797. }