lolengine
/
lol
spogulis no https://github.com/lolengine/lol
1
0
Atdalīts 0
Kods Problēmas 0 Laidieni 0 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
902 Revīzijas
5 Atzari
251 MiB
 
 
 
Koks: 67113aa9f0
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '67113aa9f0'
${ noResults }
lol/test/sandbox/lex/lolfx.l

562 rindas
24 KiB
Neapstrādāts Vainot Vēsture 

  1. %{

  2. #include <iostream>

  3. #define YY_DECL extern "C" int yylex()

  4. #include "lolfx.tab.h"

  5. %}

  6. 

  7. %x GLSL

  8. %x HLSL

  9. %x C_COMMENT

  10. %x CPP_COMMENT

  11. 

  12. %%

  13. 

  14. %{

  15. int comment_caller = INITIAL;

  16. %}

  17. 

  18.  /*

  19.   * GLSL keywords

  20.   */

  21. 

  22. "subroutine"                 { return GT_SUBROUTINE; }

  23. "patch"                      { return GT_PATCH; }

  24. "sample"                     { return GT_SAMPLE; }

  25. "flat"                       { return GT_FLAT; }

  26. "smooth"                     { return GT_SMOOTH; }

  27. "layout"                     { return GT_LAYOUT; }

  28. "sampler1dshadow"            { return GT_SAMPLER1DSHADOW; }

  29. "sampler2dshadow"            { return GT_SAMPLER2DSHADOW; }

  30. "samplercubeshadow"          { return GT_SAMPLERCUBESHADOW; }

  31. "sampler1darray"             { return GT_SAMPLER1DARRAY; }

  32. "sampler2darray"             { return GT_SAMPLER2DARRAY; }

  33. "sampler1darrayshadow"       { return GT_SAMPLER1DARRAYSHADOW; }

  34. "sampler2darrayshadow"       { return GT_SAMPLER2DARRAYSHADOW; }

  35. "isampler1d"                 { return GT_ISAMPLER1D; }

  36. "isampler2d"                 { return GT_ISAMPLER2D; }

  37. "isampler3d"                 { return GT_ISAMPLER3D; }

  38. "isamplercube"               { return GT_ISAMPLERCUBE; }

  39. "isampler1darray"            { return GT_ISAMPLER1DARRAY; }

  40. "isampler2darray"            { return GT_ISAMPLER2DARRAY; }

  41. "usampler1d"                 { return GT_USAMPLER1D; }

  42. "usampler2d"                 { return GT_USAMPLER2D; }

  43. "usampler3d"                 { return GT_USAMPLER3D; }

  44. "usamplercube"               { return GT_USAMPLERCUBE; }

  45. "usampler1darray"            { return GT_USAMPLER1DARRAY; }

  46. "usampler2darray"            { return GT_USAMPLER2DARRAY; }

  47. "sampler2drect"              { return GT_SAMPLER2DRECT; }

  48. "sampler2drectshadow"        { return GT_SAMPLER2DRECTSHADOW; }

  49. "isampler2drect"             { return GT_ISAMPLER2DRECT; }

  50. "usampler2drect"             { return GT_USAMPLER2DRECT; }

  51. "samplerbuffer"              { return GT_SAMPLERBUFFER; }

  52. "isamplerbuffer"             { return GT_ISAMPLERBUFFER; }

  53. "usamplerbuffer"             { return GT_USAMPLERBUFFER; }

  54. "samplercubearray"           { return GT_SAMPLERCUBEARRAY; }

  55. "samplercubearrayshadow"     { return GT_SAMPLERCUBEARRAYSHADOW; }

  56. "isamplercubearray"          { return GT_ISAMPLERCUBEARRAY; }

  57. "usamplercubearray"          { return GT_USAMPLERCUBEARRAY; }

  58. "sampler2dms"                { return GT_SAMPLER2DMS; }

  59. "isampler2dms"               { return GT_ISAMPLER2DMS; }

  60. "usampler2dms"               { return GT_USAMPLER2DMS; }

  61. "sampler2dmsarray"           { return GT_SAMPLER2DMSARRAY; }

  62. "isampler2dmsarray"          { return GT_ISAMPLER2DMSARRAY; }

  63. "usampler2dmsarray"          { return GT_USAMPLER2DMSARRAY; }

  64. 

  65. "highp"                      { return GT_HIGHP; }

  66. "mediump"                    { return GT_MEDIUMP; }

  67. "lowp"                       { return GT_LOWP; }

  68. "precision"                  { return GT_PRECISION; }

  69. "invariant"                  { return GT_INVARIANT; }

  70. 

  71.  /*

  72.   * Deprecated GLSL keywords

  73.   */

  74. 

  75. "attribute"                  { return GT_ATTRIBUTE; }

  76. 

  77.  /*

  78.   * GLSL vector types

  79.   */

  80. 

  81. "bvec2"                      { return GT_BVEC2; }

  82. "bvec3"                      { return GT_BVEC3; }

  83. "bvec4"                      { return GT_BVEC4; }

  84. 

  85. "ivec2"                      { return GT_IVEC2; }

  86. "ivec3"                      { return GT_IVEC3; }

  87. "ivec4"                      { return GT_IVEC4; }

  88. 

  89. "uvec2"                      { return GT_UVEC2; }

  90. "uvec3"                      { return GT_UVEC3; }

  91. "uvec4"                      { return GT_UVEC4; }

  92. 

  93. "vec2"                       { return GT_VEC2; }

  94. "vec3"                       { return GT_VEC3; }

  95. "vec4"                       { return GT_VEC4; }

  96. "mat2"                       { return GT_MAT2; }

  97. "mat2x2"                     { return GT_MAT2X2; }

  98. "mat2x3"                     { return GT_MAT2X3; }

  99. "mat2x4"                     { return GT_MAT2X4; }

  100. "mat3"                       { return GT_MAT3; }

  101. "mat3x2"                     { return GT_MAT3X2; }

  102. "mat3x3"                     { return GT_MAT3X3; }

  103. "mat3x4"                     { return GT_MAT3X4; }

  104. "mat4"                       { return GT_MAT4; }

  105. "mat4x2"                     { return GT_MAT4X2; }

  106. "mat4x3"                     { return GT_MAT4X3; }

  107. "mat4x4"                     { return GT_MAT4X4; }

  108. 

  109. "dvec2"                      { return GT_DVEC2; }

  110. "dvec3"                      { return GT_DVEC3; }

  111. "dvec4"                      { return GT_DVEC4; }

  112. "dmat2"                      { return GT_DMAT2; }

  113. "dmat2x2"                    { return GT_DMAT2X2; }

  114. "dmat2x3"                    { return GT_DMAT2X3; }

  115. "dmat2x4"                    { return GT_DMAT2X4; }

  116. "dmat3"                      { return GT_DMAT3; }

  117. "dmat3x2"                    { return GT_DMAT3X2; }

  118. "dmat3x3"                    { return GT_DMAT3X3; }

  119. "dmat3x4"                    { return GT_DMAT3X4; }

  120. "dmat4"                      { return GT_DMAT4; }

  121. "dmat4x2"                    { return GT_DMAT4X2; }

  122. "dmat4x3"                    { return GT_DMAT4X3; }

  123. "dmat4x4"                    { return GT_DMAT4X4; }

  124. 

  125.  /*

  126.   * GLSL constant values

  127.   */

  128. 

  129. "true"                       { yylval.ival = 1; return BOOLCONSTANT; }

  130. "false"                      { yylval.ival = 0; return BOOLCONSTANT; }

  131. 

  132. [xyzw]{1,4}                  { return FIELDSELECTION; }

  133. [rgba]{1,4}                  { return FIELDSELECTION; }

  134. [stpq]{1,4}                  { return FIELDSELECTION; }

  135. 

  136.  /*

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

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

  139.   */

  140. 

  141. "bool"                       { return GHT_BOOL; }

  142. "break"                      { return GHT_BREAK; }

  143. "case"                       { return GHT_CASE; }

  144. "centroid"                   { return GHT_CENTROID; }

  145. "const"                      { return GHT_CONST; }

  146. "continue"                   { return GHT_CONTINUE; }

  147. "default"                    { return GHT_DEFAULT; }

  148. "discard"                    { return GHT_DISCARD; }

  149. "do"                         { return GHT_DO; }

  150. "double"                     { return GHT_DOUBLE; }

  151. "else"                       { return GHT_ELSE; }

  152. "float"                      { return GHT_FLOAT; }

  153. "for"                        { return GHT_FOR; }

  154. "if"                         { return GHT_IF; }

  155. "in"                         { return GHT_IN; }

  156. "inout"                      { return GHT_INOUT; }

  157. "int"                        { return GHT_INT; }

  158. "noperspective"              { return GHT_NOPERSPECTIVE; }

  159. "out"                        { return GHT_OUT; }

  160. "return"                     { return GHT_RETURN; }

  161. "sampler1d"                  { return GHT_SAMPLER1D; }

  162. "sampler2d"                  { return GHT_SAMPLER2D; }

  163. "sampler3d"                  { return GHT_SAMPLER3D; }

  164. "samplercube"                { return GHT_SAMPLERCUBE; }

  165. "struct"                     { return GHT_STRUCT; }

  166. "switch"                     { return GHT_SWITCH; }

  167. "uint"                       { return GHT_UINT; }

  168. "uniform"                    { return GHT_UNIFORM; }

  169. "void"                       { return GHT_VOID; }

  170. "while"                      { return GHT_WHILE; }

  171. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  191. (?i:return)                  { return HGT_RETURN; }

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

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

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

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

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

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

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

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

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

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

  202. 

  203.  /*

  204.   * HLSL keywords

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

  206.   */

  207. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  278. "texture"                    { return HT_TEXTURE; }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  298. 

  299.  /*

  300.   * HLSL vector types

  301.   * TODO: this can probably be factored somehow

  302.   */

  303. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  324. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  345. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  366. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  387. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  408. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  429. 

  430.  /*

  431.   * HLSL preprocessor directives

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

  433.   */

  434. 

  435. "#"[ \t]*"define"            { return PREPROCESSOR_DEFINE; }

  436. "#"[ \t]*"elif"              { return PREPROCESSOR_ELIF; }

  437. "#"[ \t]*"else"              { return PREPROCESSOR_ELSE; }

  438. "#"[ \t]*"endif"             { return PREPROCESSOR_ENDIF; }

  439. "#"[ \t]*"error"             { return PREPROCESSOR_ERROR; }

  440. "#"[ \t]*"if"                { return PREPROCESSOR_IF; }

  441. "#"[ \t]*"ifdef"             { return PREPROCESSOR_IFDEF; }

  442. "#"[ \t]*"ifndef"            { return PREPROCESSOR_IFNDEF; }

  443. "#"[ \t]*"include"           { return PREPROCESSOR_INCLUDE; }

  444. "#"[ \t]*"line"              { return PREPROCESSOR_LINE; }

  445. "#"[ \t]*"pragma"            { return PREPROCESSOR_PRAGMA; }

  446. "#"[ \t]*"undef"             { return PREPROCESSOR_UNDEF; }

  447. 

  448.  /*

  449.   * GLSL preprocessor directives

  450.   */

  451. 

  452. "#"[ \t]*"version".*         { /* ignore for now */ }

  453. 

  454.  /*

  455.   * LolFx preprocessor directives

  456.   */

  457. 

  458. "#"[ \t]*"region GLSL"       { BEGIN(GLSL); }

  459. "#"[ \t]*"region HLSL"       { BEGIN(HLSL); }

  460. "#"[ \t]*"pragma"[ \t]*"lolfx".*   { /* ignore for now */ }

  461. 

  462.  /*

  463.   * HLSL reserved keywords

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

  465.   */

  466. 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  499. 

  500.  /*

  501.   * Various tokens

  502.   */

  503. 

  504. "++"                    { return T_INC; }

  505. "--"                    { return T_DEC; }

  506. "<="                    { return T_LE; }

  507. ">="                    { return T_GE; }

  508. "=="                    { return T_EQ; }

  509. "!="                    { return T_NE; }

  510. "<<"                    { return T_LEFT; }

  511. ">>"                    { return T_RIGHT; }

  512. "&&"                    { return T_AND; }

  513. "||"                    { return T_OR; }

  514. "^^"                    { return T_XOR; }

  515. 

  516. "*="                    { return T_MULEQ; }

  517. "/="                    { return T_DIVEQ; }

  518. "%="                    { return T_MODEQ; }

  519. "+="                    { return T_ADDEQ; }

  520. "-="                    { return T_SUBEQ; }

  521. "<<="                   { return T_LEFTEQ; }

  522. ">>="                   { return T_RIGHTEQ; }

  523. "&="                    { return T_ANDEQ; }

  524. "^="                    { return T_XOREQ; }

  525. "|="                    { return T_OREQ; }

  526. 

  527. (0|[1-9][0-9]*)\.[0-9]+ { yylval.fval = atof(yytext); return FLOATCONSTANT; }

  528. (0|[1-9][0-9]*)[uU]     { yylval.uval = atoi(yytext); return UINTCONSTANT; }

  529. (0|[1-9][0-9]*)         { yylval.ival = atoi(yytext); return INTCONSTANT; }

  530. 

  531. [a-zA-Z][a-zA-Z0-9_]*   {

  532.     /* Copy token for now */

  533.     yylval.sval = strdup(yytext);

  534.     return IDENTIFIER;

  535. }

  536. [ \t\n]+                { /* ignore whitespace */ }

  537. .                       { return *yytext; }

  538. 

  539.  /*

  540.   * Ignore C comments

  541.   */

  542. 

  543. <GLSL>"/*"        { comment_caller = GLSL; BEGIN(C_COMMENT); }

  544. <HLSL>"/*"        { comment_caller = HLSL; BEGIN(C_COMMENT); }

  545. "/*"              { comment_caller = INITIAL; BEGIN(C_COMMENT); }

  546. <C_COMMENT>"*/"   { BEGIN(comment_caller); }

  547. <C_COMMENT>[^*]*  { }

  548. <C_COMMENT>.      { }

  549. 

  550.  /*

  551.   * Ignore C++ comments

  552.   */

  553. 

  554. <GLSL>"//"        { comment_caller = GLSL; BEGIN(CPP_COMMENT); }

  555. <HLSL>"//"        { comment_caller = HLSL; BEGIN(CPP_COMMENT); }

  556. "//"              { comment_caller = INITIAL; BEGIN(CPP_COMMENT); }

  557. <CPP_COMMENT>\n   { BEGIN(comment_caller); }

  558. <CPP_COMMENT>.*   { }

  559. 

  560. %%