Browse Source

Add the keywords straight to the Tries

Toni Helenius 8 months ago
parent
commit
2c53a1cefa

+ 404 - 424
jme3-glsl-highlighter/src/com/jme3/gde/glsl/highlighter/lexer/GlslKeywordLibrary.java

@@ -32,8 +32,6 @@
 package com.jme3.gde.glsl.highlighter.lexer;
 package com.jme3.gde.glsl.highlighter.lexer;
 
 
 import com.jme3.gde.glsl.highlighter.util.Trie;
 import com.jme3.gde.glsl.highlighter.util.Trie;
-import java.util.ArrayList;
-import java.util.List;
 
 
 /**
 /**
  * Brace, yourselves, this file contains every word that means something in
  * Brace, yourselves, this file contains every word that means something in
@@ -54,438 +52,420 @@ final class GlslKeywordLibrary {
 
 
     static {
     static {
         //keywords
         //keywords
-        List<String> keywords = new ArrayList<>();
-        keywords.add("attribute");
-        keywords.add("const");
-        keywords.add("uniform");
-        keywords.add("varying");
-        keywords.add("buffer");
-        keywords.add("shared");
-        keywords.add("coherent");
-        keywords.add("volatile");
-        keywords.add("restrict");
-        keywords.add("readonly");
-        keywords.add("writeonly");
-        keywords.add("atomic_uint");
-        keywords.add("layout");
-        keywords.add("centroid");
-        keywords.add("flat");
-        keywords.add("smooth");
-        keywords.add("noperspective");
-        keywords.add("patch");
-        keywords.add("sample");
-        keywords.add("break");
-        keywords.add("continue");
-        keywords.add("do");
-        keywords.add("for");
-        keywords.add("while");
-        keywords.add("switch");
-        keywords.add("case");
-        keywords.add("default");
-        keywords.add("if");
-        keywords.add("else");
-        keywords.add("subroutine");
-        keywords.add("in");
-        keywords.add("out");
-        keywords.add("inout");
-        keywords.add("void");
-        keywords.add("true");
-        keywords.add("false");
-        keywords.add("invariant");
-        keywords.add("precise");
-        keywords.add("discard");
-        keywords.add("return");
+        keywordsTrie.insert("attribute");
+        keywordsTrie.insert("const");
+        keywordsTrie.insert("uniform");
+        keywordsTrie.insert("varying");
+        keywordsTrie.insert("buffer");
+        keywordsTrie.insert("shared");
+        keywordsTrie.insert("coherent");
+        keywordsTrie.insert("volatile");
+        keywordsTrie.insert("restrict");
+        keywordsTrie.insert("readonly");
+        keywordsTrie.insert("writeonly");
+        keywordsTrie.insert("atomic_uint");
+        keywordsTrie.insert("layout");
+        keywordsTrie.insert("centroid");
+        keywordsTrie.insert("flat");
+        keywordsTrie.insert("smooth");
+        keywordsTrie.insert("noperspective");
+        keywordsTrie.insert("patch");
+        keywordsTrie.insert("sample");
+        keywordsTrie.insert("break");
+        keywordsTrie.insert("continue");
+        keywordsTrie.insert("do");
+        keywordsTrie.insert("for");
+        keywordsTrie.insert("while");
+        keywordsTrie.insert("switch");
+        keywordsTrie.insert("case");
+        keywordsTrie.insert("default");
+        keywordsTrie.insert("if");
+        keywordsTrie.insert("else");
+        keywordsTrie.insert("subroutine");
+        keywordsTrie.insert("in");
+        keywordsTrie.insert("out");
+        keywordsTrie.insert("inout");
+        keywordsTrie.insert("void");
+        keywordsTrie.insert("true");
+        keywordsTrie.insert("false");
+        keywordsTrie.insert("invariant");
+        keywordsTrie.insert("precise");
+        keywordsTrie.insert("discard");
+        keywordsTrie.insert("return");
         //primitives and other types
         //primitives and other types
-        List<String> basicTypes = new ArrayList<>();
-        basicTypes.add("float");
-        basicTypes.add("double");
-        basicTypes.add("int");
-        basicTypes.add("bool");
-        basicTypes.add("mat2");
-        basicTypes.add("mat3");
-        basicTypes.add("mat4");
-        basicTypes.add("dmat2");
-        basicTypes.add("dmat3");
-        basicTypes.add("dmat4");
-        basicTypes.add("mat2x2");
-        basicTypes.add("mat2x3");
-        basicTypes.add("mat2x4");
-        basicTypes.add("dmat2x2");
-        basicTypes.add("dmat2x3");
-        basicTypes.add("dmat2x4");
-        basicTypes.add("mat3x2");
-        basicTypes.add("mat3x3");
-        basicTypes.add("mat3x4");
-        basicTypes.add("dmat3x2");
-        basicTypes.add("dmat3x3");
-        basicTypes.add("dmat3x4");
-        basicTypes.add("mat4x2");
-        basicTypes.add("mat4x3");
-        basicTypes.add("mat4x4");
-        basicTypes.add("dmat4x2");
-        basicTypes.add("dmat4x3");
-        basicTypes.add("dmat4x4");
-        basicTypes.add("vec2");
-        basicTypes.add("vec3");
-        basicTypes.add("vec4");
-        basicTypes.add("ivec2");
-        basicTypes.add("ivec3");
-        basicTypes.add("ivec4");
-        basicTypes.add("bvec2");
-        basicTypes.add("bvec3");
-        basicTypes.add("bvec4");
-        basicTypes.add("dvec2");
-        basicTypes.add("dvec3");
-        basicTypes.add("dvec4");
-        basicTypes.add("uint");
-        basicTypes.add("uvec2");
-        basicTypes.add("uvec3");
-        basicTypes.add("uvec4");
-        basicTypes.add("lowp");
-        basicTypes.add("mediump");
-        basicTypes.add("highp");
-        basicTypes.add("precision");
-        basicTypes.add("sampler1D");
-        basicTypes.add("sampler2D");
-        basicTypes.add("sampler3D");
-        basicTypes.add("samplerCube");
-        basicTypes.add("sampler1DShadow");
-        basicTypes.add("sampler2DShadow");
-        basicTypes.add("samplerCubeShadow");
-        basicTypes.add("sampler1DArray");
-        basicTypes.add("sampler2DArray");
-        basicTypes.add("sampler1DArrayShadow");
-        basicTypes.add("sampler2DArrayShadow");
-        basicTypes.add("isampler1D");
-        basicTypes.add("isampler2D");
-        basicTypes.add("isampler3D");
-        basicTypes.add("isamplerCube");
-        basicTypes.add("isampler1DArray");
-        basicTypes.add("isampler2DArray");
-        basicTypes.add("usampler1D");
-        basicTypes.add("usampler2D");
-        basicTypes.add("usampler3D");
-        basicTypes.add("usamplerCube");
-        basicTypes.add("usampler1DArray");
-        basicTypes.add("usampler2DArray");
-        basicTypes.add("sampler2DRect");
-        basicTypes.add("sampler2DRectShadow");
-        basicTypes.add("isampler2DRect");
-        basicTypes.add("usampler2DRect");
-        basicTypes.add("samplerBuffer");
-        basicTypes.add("isamplerBuffer");
-        basicTypes.add("usamplerBuffer");
-        basicTypes.add("sampler2DMS");
-        basicTypes.add("isampler2DMS");
-        basicTypes.add("usampler2DMS");
-        basicTypes.add("sampler2DMSArray");
-        basicTypes.add("isampler2DMSArray");
-        basicTypes.add("usampler2DMSArray");
-        basicTypes.add("samplerCubeArray");
-        basicTypes.add("samplerCubeArrayShadow");
-        basicTypes.add("isamplerCubeArray");
-        basicTypes.add("usamplerCubeArray");
-        basicTypes.add("image1D");
-        basicTypes.add("iimage1D");
-        basicTypes.add("uimage1D");
-        basicTypes.add("image2D");
-        basicTypes.add("iimage2D");
-        basicTypes.add("uimage2D");
-        basicTypes.add("image3D");
-        basicTypes.add("iimage3D");
-        basicTypes.add("uimage3D");
-        basicTypes.add("image2DRect");
-        basicTypes.add("iimage2DRect");
-        basicTypes.add("uimage2DRect");
-        basicTypes.add("imageCube");
-        basicTypes.add("iimageCube");
-        basicTypes.add("uimageCube");
-        basicTypes.add("imageBuffer");
-        basicTypes.add("iimageBuffer");
-        basicTypes.add("uimageBuffer");
-        basicTypes.add("image1DArray");
-        basicTypes.add("iimage1DArray");
-        basicTypes.add("uimage1DArray");
-        basicTypes.add("image2DArray");
-        basicTypes.add("iimage2DArray");
-        basicTypes.add("uimage2DArray");
-        basicTypes.add("imageCubeArray");
-        basicTypes.add("iimageCubeArray");
-        basicTypes.add("uimageCubeArray");
-        basicTypes.add("image2DMS");
-        basicTypes.add("iimage2DMS");
-        basicTypes.add("uimage2DMS");
-        basicTypes.add("image2DMSArray");
-        basicTypes.add("iimage2DMSArray");
-        basicTypes.add("uimage2DMSArray");
-        basicTypes.add("struct");
+        basicTypesTrie.insert("float");
+        basicTypesTrie.insert("double");
+        basicTypesTrie.insert("int");
+        basicTypesTrie.insert("bool");
+        basicTypesTrie.insert("mat2");
+        basicTypesTrie.insert("mat3");
+        basicTypesTrie.insert("mat4");
+        basicTypesTrie.insert("dmat2");
+        basicTypesTrie.insert("dmat3");
+        basicTypesTrie.insert("dmat4");
+        basicTypesTrie.insert("mat2x2");
+        basicTypesTrie.insert("mat2x3");
+        basicTypesTrie.insert("mat2x4");
+        basicTypesTrie.insert("dmat2x2");
+        basicTypesTrie.insert("dmat2x3");
+        basicTypesTrie.insert("dmat2x4");
+        basicTypesTrie.insert("mat3x2");
+        basicTypesTrie.insert("mat3x3");
+        basicTypesTrie.insert("mat3x4");
+        basicTypesTrie.insert("dmat3x2");
+        basicTypesTrie.insert("dmat3x3");
+        basicTypesTrie.insert("dmat3x4");
+        basicTypesTrie.insert("mat4x2");
+        basicTypesTrie.insert("mat4x3");
+        basicTypesTrie.insert("mat4x4");
+        basicTypesTrie.insert("dmat4x2");
+        basicTypesTrie.insert("dmat4x3");
+        basicTypesTrie.insert("dmat4x4");
+        basicTypesTrie.insert("vec2");
+        basicTypesTrie.insert("vec3");
+        basicTypesTrie.insert("vec4");
+        basicTypesTrie.insert("ivec2");
+        basicTypesTrie.insert("ivec3");
+        basicTypesTrie.insert("ivec4");
+        basicTypesTrie.insert("bvec2");
+        basicTypesTrie.insert("bvec3");
+        basicTypesTrie.insert("bvec4");
+        basicTypesTrie.insert("dvec2");
+        basicTypesTrie.insert("dvec3");
+        basicTypesTrie.insert("dvec4");
+        basicTypesTrie.insert("uint");
+        basicTypesTrie.insert("uvec2");
+        basicTypesTrie.insert("uvec3");
+        basicTypesTrie.insert("uvec4");
+        basicTypesTrie.insert("lowp");
+        basicTypesTrie.insert("mediump");
+        basicTypesTrie.insert("highp");
+        basicTypesTrie.insert("precision");
+        basicTypesTrie.insert("sampler1D");
+        basicTypesTrie.insert("sampler2D");
+        basicTypesTrie.insert("sampler3D");
+        basicTypesTrie.insert("samplerCube");
+        basicTypesTrie.insert("sampler1DShadow");
+        basicTypesTrie.insert("sampler2DShadow");
+        basicTypesTrie.insert("samplerCubeShadow");
+        basicTypesTrie.insert("sampler1DArray");
+        basicTypesTrie.insert("sampler2DArray");
+        basicTypesTrie.insert("sampler1DArrayShadow");
+        basicTypesTrie.insert("sampler2DArrayShadow");
+        basicTypesTrie.insert("isampler1D");
+        basicTypesTrie.insert("isampler2D");
+        basicTypesTrie.insert("isampler3D");
+        basicTypesTrie.insert("isamplerCube");
+        basicTypesTrie.insert("isampler1DArray");
+        basicTypesTrie.insert("isampler2DArray");
+        basicTypesTrie.insert("usampler1D");
+        basicTypesTrie.insert("usampler2D");
+        basicTypesTrie.insert("usampler3D");
+        basicTypesTrie.insert("usamplerCube");
+        basicTypesTrie.insert("usampler1DArray");
+        basicTypesTrie.insert("usampler2DArray");
+        basicTypesTrie.insert("sampler2DRect");
+        basicTypesTrie.insert("sampler2DRectShadow");
+        basicTypesTrie.insert("isampler2DRect");
+        basicTypesTrie.insert("usampler2DRect");
+        basicTypesTrie.insert("samplerBuffer");
+        basicTypesTrie.insert("isamplerBuffer");
+        basicTypesTrie.insert("usamplerBuffer");
+        basicTypesTrie.insert("sampler2DMS");
+        basicTypesTrie.insert("isampler2DMS");
+        basicTypesTrie.insert("usampler2DMS");
+        basicTypesTrie.insert("sampler2DMSArray");
+        basicTypesTrie.insert("isampler2DMSArray");
+        basicTypesTrie.insert("usampler2DMSArray");
+        basicTypesTrie.insert("samplerCubeArray");
+        basicTypesTrie.insert("samplerCubeArrayShadow");
+        basicTypesTrie.insert("isamplerCubeArray");
+        basicTypesTrie.insert("usamplerCubeArray");
+        basicTypesTrie.insert("image1D");
+        basicTypesTrie.insert("iimage1D");
+        basicTypesTrie.insert("uimage1D");
+        basicTypesTrie.insert("image2D");
+        basicTypesTrie.insert("iimage2D");
+        basicTypesTrie.insert("uimage2D");
+        basicTypesTrie.insert("image3D");
+        basicTypesTrie.insert("iimage3D");
+        basicTypesTrie.insert("uimage3D");
+        basicTypesTrie.insert("image2DRect");
+        basicTypesTrie.insert("iimage2DRect");
+        basicTypesTrie.insert("uimage2DRect");
+        basicTypesTrie.insert("imageCube");
+        basicTypesTrie.insert("iimageCube");
+        basicTypesTrie.insert("uimageCube");
+        basicTypesTrie.insert("imageBuffer");
+        basicTypesTrie.insert("iimageBuffer");
+        basicTypesTrie.insert("uimageBuffer");
+        basicTypesTrie.insert("image1DArray");
+        basicTypesTrie.insert("iimage1DArray");
+        basicTypesTrie.insert("uimage1DArray");
+        basicTypesTrie.insert("image2DArray");
+        basicTypesTrie.insert("iimage2DArray");
+        basicTypesTrie.insert("uimage2DArray");
+        basicTypesTrie.insert("imageCubeArray");
+        basicTypesTrie.insert("iimageCubeArray");
+        basicTypesTrie.insert("uimageCubeArray");
+        basicTypesTrie.insert("image2DMS");
+        basicTypesTrie.insert("iimage2DMS");
+        basicTypesTrie.insert("uimage2DMS");
+        basicTypesTrie.insert("image2DMSArray");
+        basicTypesTrie.insert("iimage2DMSArray");
+        basicTypesTrie.insert("uimage2DMSArray");
+        basicTypesTrie.insert("struct");
         //builtin variables
         //builtin variables
         //compute shaders
         //compute shaders
-        List<String> builtinVariables = new ArrayList<>();
-        builtinVariables.add("gl_NumWorkGroups");
-        builtinVariables.add("gl_WorkGroupSize");
-        builtinVariables.add("gl_WorkGroupID");
-        builtinVariables.add("gl_LocalInvocationID");
-        builtinVariables.add("gl_GlobalInvocationID");
-        builtinVariables.add("gl_LocalInvocationIndex");
+        builtinVariablesTrie.insert("gl_NumWorkGroups");
+        builtinVariablesTrie.insert("gl_WorkGroupSize");
+        builtinVariablesTrie.insert("gl_WorkGroupID");
+        builtinVariablesTrie.insert("gl_LocalInvocationID");
+        builtinVariablesTrie.insert("gl_GlobalInvocationID");
+        builtinVariablesTrie.insert("gl_LocalInvocationIndex");
         //vertex shaders
         //vertex shaders
-        builtinVariables.add("gl_VertexID");
-        builtinVariables.add("gl_InstanceID");
-        builtinVariables.add("gl_Position");
+        builtinVariablesTrie.insert("gl_VertexID");
+        builtinVariablesTrie.insert("gl_InstanceID");
+        builtinVariablesTrie.insert("gl_Position");
         //geometry shaders
         //geometry shaders
-        builtinVariables.add("gl_PrimitiveIDIn");
-        builtinVariables.add("gl_Layer");
-        builtinVariables.add("gl_ViewportIndex");
+        builtinVariablesTrie.insert("gl_PrimitiveIDIn");
+        builtinVariablesTrie.insert("gl_Layer");
+        builtinVariablesTrie.insert("gl_ViewportIndex");
         //tesselation shaders
         //tesselation shaders
-        builtinVariables.add("gl_MaxPatchVertices");
-        builtinVariables.add("gl_PatchVerticesIn");
-        builtinVariables.add("gl_TessLevelOuter");
-        builtinVariables.add("gl_TessLevelInner");
-        builtinVariables.add("gl_TessCoord");
+        builtinVariablesTrie.insert("gl_MaxPatchVertices");
+        builtinVariablesTrie.insert("gl_PatchVerticesIn");
+        builtinVariablesTrie.insert("gl_TessLevelOuter");
+        builtinVariablesTrie.insert("gl_TessLevelInner");
+        builtinVariablesTrie.insert("gl_TessCoord");
         //fragment shaders
         //fragment shaders
-        builtinVariables.add("gl_FragCoord");
-        builtinVariables.add("gl_FrontFacing");
-        builtinVariables.add("gl_PointCoord");
-        builtinVariables.add("gl_SampleID");
-        builtinVariables.add("gl_SamplePosition");
-        builtinVariables.add("gl_SampleMaskIn");
-        builtinVariables.add("gl_Layer");
-        builtinVariables.add("gl_ViewportIndex");
-        builtinVariables.add("gl_FragColor");
+        builtinVariablesTrie.insert("gl_FragCoord");
+        builtinVariablesTrie.insert("gl_FrontFacing");
+        builtinVariablesTrie.insert("gl_PointCoord");
+        builtinVariablesTrie.insert("gl_SampleID");
+        builtinVariablesTrie.insert("gl_SamplePosition");
+        builtinVariablesTrie.insert("gl_SampleMaskIn");
+        builtinVariablesTrie.insert("gl_Layer");
+        builtinVariablesTrie.insert("gl_ViewportIndex");
+        builtinVariablesTrie.insert("gl_FragColor");
         //general
         //general
-        builtinVariables.add("gl_Position");
-        builtinVariables.add("gl_PointSize");
-        builtinVariables.add("gl_ClipDistance");
-        builtinVariables.add("gl_InvocationID");
-        builtinVariables.add("gl_PrimitiveID");
+        builtinVariablesTrie.insert("gl_Position");
+        builtinVariablesTrie.insert("gl_PointSize");
+        builtinVariablesTrie.insert("gl_ClipDistance");
+        builtinVariablesTrie.insert("gl_InvocationID");
+        builtinVariablesTrie.insert("gl_PrimitiveID");
         //jme variables - this is why we build custom plugins :) (apart from existing being under GPL)
         //jme variables - this is why we build custom plugins :) (apart from existing being under GPL)
-        builtinVariables.add("inPosition");
-        builtinVariables.add("inNormal");
-        builtinVariables.add("inColor");
-        builtinVariables.add("inTextCoord");
-        builtinVariables.add("g_WorldMatrix");
-        builtinVariables.add("g_ViewMatrix");
-        builtinVariables.add("g_ProjectionMatrix");
-        builtinVariables.add("g_WorldViewMatrix");
-        builtinVariables.add("g_WorldViewProjectionMatrix");
-        builtinVariables.add("g_WorldNormalMatrix");
-        builtinVariables.add("g_NormalMatrix");
-        builtinVariables.add("g_ViewProjectionMatrix");
-        builtinVariables.add("g_WorldMatrixInverseTranspose");
-        builtinVariables.add("g_WorldMatrixInverse");
-        builtinVariables.add("g_ViewMatrixInverse");
-        builtinVariables.add("g_ProjectionMatrixInverse");
-        builtinVariables.add("g_ViewProjectionMatrixInverse");
-        builtinVariables.add("g_WorldViewMatrixInverse");
-        builtinVariables.add("g_NormalMatrixInverse");
-        builtinVariables.add("g_WorldViewProjectionMatrixInverse");
-        builtinVariables.add("g_ViewPort");
-        builtinVariables.add("g_FrustumNearFar");
-        builtinVariables.add("g_Resolution");
-        builtinVariables.add("g_ResolutionInverse");
-        builtinVariables.add("g_Aspect");
-        builtinVariables.add("g_CameraPosition");
-        builtinVariables.add("g_CameraDirection");
-        builtinVariables.add("g_CameraLeft");
-        builtinVariables.add("g_CameraUp");
-        builtinVariables.add("g_Time");
-        builtinVariables.add("g_Tpf");
-        builtinVariables.add("g_FrameRate");
-        builtinVariables.add("g_LightDirection");
-        builtinVariables.add("g_LightPosition");
-        builtinVariables.add("g_LightColor");
-        builtinVariables.add("g_AmbientLightColor");
+        builtinVariablesTrie.insert("inPosition");
+        builtinVariablesTrie.insert("inNormal");
+        builtinVariablesTrie.insert("inColor");
+        builtinVariablesTrie.insert("inTextCoord");
+        builtinVariablesTrie.insert("g_WorldMatrix");
+        builtinVariablesTrie.insert("g_ViewMatrix");
+        builtinVariablesTrie.insert("g_ProjectionMatrix");
+        builtinVariablesTrie.insert("g_WorldViewMatrix");
+        builtinVariablesTrie.insert("g_WorldViewProjectionMatrix");
+        builtinVariablesTrie.insert("g_WorldNormalMatrix");
+        builtinVariablesTrie.insert("g_NormalMatrix");
+        builtinVariablesTrie.insert("g_ViewProjectionMatrix");
+        builtinVariablesTrie.insert("g_WorldMatrixInverseTranspose");
+        builtinVariablesTrie.insert("g_WorldMatrixInverse");
+        builtinVariablesTrie.insert("g_ViewMatrixInverse");
+        builtinVariablesTrie.insert("g_ProjectionMatrixInverse");
+        builtinVariablesTrie.insert("g_ViewProjectionMatrixInverse");
+        builtinVariablesTrie.insert("g_WorldViewMatrixInverse");
+        builtinVariablesTrie.insert("g_NormalMatrixInverse");
+        builtinVariablesTrie.insert("g_WorldViewProjectionMatrixInverse");
+        builtinVariablesTrie.insert("g_ViewPort");
+        builtinVariablesTrie.insert("g_FrustumNearFar");
+        builtinVariablesTrie.insert("g_Resolution");
+        builtinVariablesTrie.insert("g_ResolutionInverse");
+        builtinVariablesTrie.insert("g_Aspect");
+        builtinVariablesTrie.insert("g_CameraPosition");
+        builtinVariablesTrie.insert("g_CameraDirection");
+        builtinVariablesTrie.insert("g_CameraLeft");
+        builtinVariablesTrie.insert("g_CameraUp");
+        builtinVariablesTrie.insert("g_Time");
+        builtinVariablesTrie.insert("g_Tpf");
+        builtinVariablesTrie.insert("g_FrameRate");
+        builtinVariablesTrie.insert("g_LightDirection");
+        builtinVariablesTrie.insert("g_LightPosition");
+        builtinVariablesTrie.insert("g_LightColor");
+        builtinVariablesTrie.insert("g_AmbientLightColor");
         //builtin functions
         //builtin functions
-        List<String> builtinFunctions = new ArrayList<>();
-        builtinFunctions.add("radians");
-        builtinFunctions.add("degrees");
-        builtinFunctions.add("sin");
-        builtinFunctions.add("cos");
-        builtinFunctions.add("tan");
-        builtinFunctions.add("asin");
-        builtinFunctions.add("acos");
-        builtinFunctions.add("atan");
-        builtinFunctions.add("sinh");
-        builtinFunctions.add("cosh");
-        builtinFunctions.add("tanh");
-        builtinFunctions.add("asinh");
-        builtinFunctions.add("acosh");
-        builtinFunctions.add("atanh");
-        builtinFunctions.add("pow");
-        builtinFunctions.add("exp");
-        builtinFunctions.add("log");
-        builtinFunctions.add("exp2");
-        builtinFunctions.add("log2");
-        builtinFunctions.add("sqrt");
-        builtinFunctions.add("inversesqrt");
-        builtinFunctions.add("abs");
-        builtinFunctions.add("sign");
-        builtinFunctions.add("floor");
-        builtinFunctions.add("trunc");
-        builtinFunctions.add("round");
-        builtinFunctions.add("roundEven");
-        builtinFunctions.add("ceil");
-        builtinFunctions.add("fract");
-        builtinFunctions.add("mod");
-        builtinFunctions.add("modf");
-        builtinFunctions.add("min");
-        builtinFunctions.add("max");
-        builtinFunctions.add("clamp");
-        builtinFunctions.add("mix");
-        builtinFunctions.add("step");
-        builtinFunctions.add("smoothstep");
-        builtinFunctions.add("isnan");
-        builtinFunctions.add("isinf");
-        builtinFunctions.add("floatBitsToInt");
-        builtinFunctions.add("floatBitsToUInt");
-        builtinFunctions.add("intBitsToFloat");
-        builtinFunctions.add("uintBitsToFloat");
-        builtinFunctions.add("fma");
-        builtinFunctions.add("frexp");
-        builtinFunctions.add("packUnorm2x16");
-        builtinFunctions.add("packSnorm2x16");
-        builtinFunctions.add("packUnorm4x8");
-        builtinFunctions.add("packSnorm4x8");
-        builtinFunctions.add("unpackUnorm2x16");
-        builtinFunctions.add("unpackSnorm2x16");
-        builtinFunctions.add("unpackUnorm4x8");
-        builtinFunctions.add("unpackSnorm4x8");
-        builtinFunctions.add("packDouble2x32");
-        builtinFunctions.add("unpackDouble2x32");
-        builtinFunctions.add("packHalf2x16");
-        builtinFunctions.add("unpackHalf2x16");
-        builtinFunctions.add("length");
-        builtinFunctions.add("distance");
-        builtinFunctions.add("dot");
-        builtinFunctions.add("cross");
-        builtinFunctions.add("normalize");
-        builtinFunctions.add("ftransform");
-        builtinFunctions.add("faceforward");
-        builtinFunctions.add("reflect");
-        builtinFunctions.add("refract");
-        builtinFunctions.add("matrixCompMult");
-        builtinFunctions.add("outerProduct");
-        builtinFunctions.add("transpose");
-        builtinFunctions.add("determinant");
-        builtinFunctions.add("inverse");
-        builtinFunctions.add("lessThan");
-        builtinFunctions.add("lessThanEqual");
-        builtinFunctions.add("greaterThan");
-        builtinFunctions.add("greaterThanEqual");
-        builtinFunctions.add("equal");
-        builtinFunctions.add("notEqual");
-        builtinFunctions.add("any");
-        builtinFunctions.add("all");
-        builtinFunctions.add("not");
-        builtinFunctions.add("uaddCarry");
-        builtinFunctions.add("usubBorrow");
-        builtinFunctions.add("umulExtended");
-        builtinFunctions.add("imulExtended");
-        builtinFunctions.add("bitfieldExtract");
-        builtinFunctions.add("bitfieldInsert");
-        builtinFunctions.add("bitfieldReverse");
-        builtinFunctions.add("bitCount");
-        builtinFunctions.add("findLSB");
-        builtinFunctions.add("findMSB");
-        builtinFunctions.add("textureSize");
-        builtinFunctions.add("textureQueryLod");
-        builtinFunctions.add("textureQueryLevels");
-        builtinFunctions.add("texture");
-        builtinFunctions.add("textureProj");
-        builtinFunctions.add("textureLod");
-        builtinFunctions.add("textureOffset");
-        builtinFunctions.add("texelFetch");
-        builtinFunctions.add("texelFetchOffset");
-        builtinFunctions.add("textureProjOffset");
-        builtinFunctions.add("textureLodOffset");
-        builtinFunctions.add("textureProjLod");
-        builtinFunctions.add("textureProjLodOffset");
-        builtinFunctions.add("textureGrad");
-        builtinFunctions.add("textureGradOffset");
-        builtinFunctions.add("textureProjGrad");
-        builtinFunctions.add("textureProjGradOffset");
-        builtinFunctions.add("textureGather");
-        builtinFunctions.add("textureGatherOffset");
-        builtinFunctions.add("textureGatherOffsets");
-        builtinFunctions.add("texture1D");
-        builtinFunctions.add("texture1DProj");
-        builtinFunctions.add("texture1DLod");
-        builtinFunctions.add("texture1DProjLod");
-        builtinFunctions.add("texture2D");
-        builtinFunctions.add("texture2DProj");
-        builtinFunctions.add("texture2DLod");
-        builtinFunctions.add("texture2DProjLod");
-        builtinFunctions.add("texture3D");
-        builtinFunctions.add("texture3DProj");
-        builtinFunctions.add("texture3DLod");
-        builtinFunctions.add("texture3DProjLod");
-        builtinFunctions.add("textureCube");
-        builtinFunctions.add("textureCubeLod");
-        builtinFunctions.add("shadow1D");
-        builtinFunctions.add("shadow2D");
-        builtinFunctions.add("shadow1DProj");
-        builtinFunctions.add("shadow2DProj");
-        builtinFunctions.add("shadow1DLod");
-        builtinFunctions.add("shadow2DLod");
-        builtinFunctions.add("shadow1DProjLod");
-        builtinFunctions.add("shadow2DProjLod");
-        builtinFunctions.add("atomicCounterIncrement");
-        builtinFunctions.add("atomicCounterDecrement");
-        builtinFunctions.add("atomicCounter");
-        builtinFunctions.add("atomicAdd");
-        builtinFunctions.add("atomicMin");
-        builtinFunctions.add("atomicMax");
-        builtinFunctions.add("atomicAnd");
-        builtinFunctions.add("atomicOr");
-        builtinFunctions.add("atomicXor");
-        builtinFunctions.add("atomicExchange");
-        builtinFunctions.add("atomicCompSwap");
-        builtinFunctions.add("imageSize");
-        builtinFunctions.add("imageLoad");
-        builtinFunctions.add("imageStore");
-        builtinFunctions.add("imageAtomicAdd");
-        builtinFunctions.add("imageAtomicMin");
-        builtinFunctions.add("imageAtomicMax");
-        builtinFunctions.add("imageAtomicAnd");
-        builtinFunctions.add("imageAtomicOr");
-        builtinFunctions.add("imageAtomicXor");
-        builtinFunctions.add("imageAtomicExchange");
-        builtinFunctions.add("imageAtomicCompSwap");
-        builtinFunctions.add("dFdx");
-        builtinFunctions.add("dFdy");
-        builtinFunctions.add("fwidth");
-        builtinFunctions.add("interpolateAtCentroid");
-        builtinFunctions.add("interpolateAtSample");
-        builtinFunctions.add("interpolateAtOffset");
-        builtinFunctions.add("noise1");
-        builtinFunctions.add("noise2");
-        builtinFunctions.add("noise3");
-        builtinFunctions.add("noise4");
-        builtinFunctions.add("EmitStreamVertex");
-        builtinFunctions.add("EndStreamPrimitive");
-        builtinFunctions.add("EmitVertex");
-        builtinFunctions.add("EndPrimitive");
-        builtinFunctions.add("barrier");
-        builtinFunctions.add("memoryBarrier");
-        builtinFunctions.add("memoryBarrierAtomicCounter");
-        builtinFunctions.add("memoryBarrierBuffer");
-        builtinFunctions.add("memoryBarrierShared");
-        builtinFunctions.add("memoryBarrierImage");
-        builtinFunctions.add("groupMemoryBarrier");
-        
-        // Create the search tries
-        for(String keyword : keywords) {
-            keywordsTrie.insert(keyword);
-        }
-        for(String keyword : builtinFunctions) {
-            builtinFunctionsTrie.insert(keyword);
-        }
-        for(String keyword : builtinVariables) {
-            builtinVariablesTrie.insert(keyword);
-        }
-        for(String keyword : basicTypes) {
-            basicTypesTrie.insert(keyword);
-        }
+        builtinFunctionsTrie.insert("radians");
+        builtinFunctionsTrie.insert("degrees");
+        builtinFunctionsTrie.insert("sin");
+        builtinFunctionsTrie.insert("cos");
+        builtinFunctionsTrie.insert("tan");
+        builtinFunctionsTrie.insert("asin");
+        builtinFunctionsTrie.insert("acos");
+        builtinFunctionsTrie.insert("atan");
+        builtinFunctionsTrie.insert("sinh");
+        builtinFunctionsTrie.insert("cosh");
+        builtinFunctionsTrie.insert("tanh");
+        builtinFunctionsTrie.insert("asinh");
+        builtinFunctionsTrie.insert("acosh");
+        builtinFunctionsTrie.insert("atanh");
+        builtinFunctionsTrie.insert("pow");
+        builtinFunctionsTrie.insert("exp");
+        builtinFunctionsTrie.insert("log");
+        builtinFunctionsTrie.insert("exp2");
+        builtinFunctionsTrie.insert("log2");
+        builtinFunctionsTrie.insert("sqrt");
+        builtinFunctionsTrie.insert("inversesqrt");
+        builtinFunctionsTrie.insert("abs");
+        builtinFunctionsTrie.insert("sign");
+        builtinFunctionsTrie.insert("floor");
+        builtinFunctionsTrie.insert("trunc");
+        builtinFunctionsTrie.insert("round");
+        builtinFunctionsTrie.insert("roundEven");
+        builtinFunctionsTrie.insert("ceil");
+        builtinFunctionsTrie.insert("fract");
+        builtinFunctionsTrie.insert("mod");
+        builtinFunctionsTrie.insert("modf");
+        builtinFunctionsTrie.insert("min");
+        builtinFunctionsTrie.insert("max");
+        builtinFunctionsTrie.insert("clamp");
+        builtinFunctionsTrie.insert("mix");
+        builtinFunctionsTrie.insert("step");
+        builtinFunctionsTrie.insert("smoothstep");
+        builtinFunctionsTrie.insert("isnan");
+        builtinFunctionsTrie.insert("isinf");
+        builtinFunctionsTrie.insert("floatBitsToInt");
+        builtinFunctionsTrie.insert("floatBitsToUInt");
+        builtinFunctionsTrie.insert("intBitsToFloat");
+        builtinFunctionsTrie.insert("uintBitsToFloat");
+        builtinFunctionsTrie.insert("fma");
+        builtinFunctionsTrie.insert("frexp");
+        builtinFunctionsTrie.insert("packUnorm2x16");
+        builtinFunctionsTrie.insert("packSnorm2x16");
+        builtinFunctionsTrie.insert("packUnorm4x8");
+        builtinFunctionsTrie.insert("packSnorm4x8");
+        builtinFunctionsTrie.insert("unpackUnorm2x16");
+        builtinFunctionsTrie.insert("unpackSnorm2x16");
+        builtinFunctionsTrie.insert("unpackUnorm4x8");
+        builtinFunctionsTrie.insert("unpackSnorm4x8");
+        builtinFunctionsTrie.insert("packDouble2x32");
+        builtinFunctionsTrie.insert("unpackDouble2x32");
+        builtinFunctionsTrie.insert("packHalf2x16");
+        builtinFunctionsTrie.insert("unpackHalf2x16");
+        builtinFunctionsTrie.insert("length");
+        builtinFunctionsTrie.insert("distance");
+        builtinFunctionsTrie.insert("dot");
+        builtinFunctionsTrie.insert("cross");
+        builtinFunctionsTrie.insert("normalize");
+        builtinFunctionsTrie.insert("ftransform");
+        builtinFunctionsTrie.insert("faceforward");
+        builtinFunctionsTrie.insert("reflect");
+        builtinFunctionsTrie.insert("refract");
+        builtinFunctionsTrie.insert("matrixCompMult");
+        builtinFunctionsTrie.insert("outerProduct");
+        builtinFunctionsTrie.insert("transpose");
+        builtinFunctionsTrie.insert("determinant");
+        builtinFunctionsTrie.insert("inverse");
+        builtinFunctionsTrie.insert("lessThan");
+        builtinFunctionsTrie.insert("lessThanEqual");
+        builtinFunctionsTrie.insert("greaterThan");
+        builtinFunctionsTrie.insert("greaterThanEqual");
+        builtinFunctionsTrie.insert("equal");
+        builtinFunctionsTrie.insert("notEqual");
+        builtinFunctionsTrie.insert("any");
+        builtinFunctionsTrie.insert("all");
+        builtinFunctionsTrie.insert("not");
+        builtinFunctionsTrie.insert("uaddCarry");
+        builtinFunctionsTrie.insert("usubBorrow");
+        builtinFunctionsTrie.insert("umulExtended");
+        builtinFunctionsTrie.insert("imulExtended");
+        builtinFunctionsTrie.insert("bitfieldExtract");
+        builtinFunctionsTrie.insert("bitfieldInsert");
+        builtinFunctionsTrie.insert("bitfieldReverse");
+        builtinFunctionsTrie.insert("bitCount");
+        builtinFunctionsTrie.insert("findLSB");
+        builtinFunctionsTrie.insert("findMSB");
+        builtinFunctionsTrie.insert("textureSize");
+        builtinFunctionsTrie.insert("textureQueryLod");
+        builtinFunctionsTrie.insert("textureQueryLevels");
+        builtinFunctionsTrie.insert("texture");
+        builtinFunctionsTrie.insert("textureProj");
+        builtinFunctionsTrie.insert("textureLod");
+        builtinFunctionsTrie.insert("textureOffset");
+        builtinFunctionsTrie.insert("texelFetch");
+        builtinFunctionsTrie.insert("texelFetchOffset");
+        builtinFunctionsTrie.insert("textureProjOffset");
+        builtinFunctionsTrie.insert("textureLodOffset");
+        builtinFunctionsTrie.insert("textureProjLod");
+        builtinFunctionsTrie.insert("textureProjLodOffset");
+        builtinFunctionsTrie.insert("textureGrad");
+        builtinFunctionsTrie.insert("textureGradOffset");
+        builtinFunctionsTrie.insert("textureProjGrad");
+        builtinFunctionsTrie.insert("textureProjGradOffset");
+        builtinFunctionsTrie.insert("textureGather");
+        builtinFunctionsTrie.insert("textureGatherOffset");
+        builtinFunctionsTrie.insert("textureGatherOffsets");
+        builtinFunctionsTrie.insert("texture1D");
+        builtinFunctionsTrie.insert("texture1DProj");
+        builtinFunctionsTrie.insert("texture1DLod");
+        builtinFunctionsTrie.insert("texture1DProjLod");
+        builtinFunctionsTrie.insert("texture2D");
+        builtinFunctionsTrie.insert("texture2DProj");
+        builtinFunctionsTrie.insert("texture2DLod");
+        builtinFunctionsTrie.insert("texture2DProjLod");
+        builtinFunctionsTrie.insert("texture3D");
+        builtinFunctionsTrie.insert("texture3DProj");
+        builtinFunctionsTrie.insert("texture3DLod");
+        builtinFunctionsTrie.insert("texture3DProjLod");
+        builtinFunctionsTrie.insert("textureCube");
+        builtinFunctionsTrie.insert("textureCubeLod");
+        builtinFunctionsTrie.insert("shadow1D");
+        builtinFunctionsTrie.insert("shadow2D");
+        builtinFunctionsTrie.insert("shadow1DProj");
+        builtinFunctionsTrie.insert("shadow2DProj");
+        builtinFunctionsTrie.insert("shadow1DLod");
+        builtinFunctionsTrie.insert("shadow2DLod");
+        builtinFunctionsTrie.insert("shadow1DProjLod");
+        builtinFunctionsTrie.insert("shadow2DProjLod");
+        builtinFunctionsTrie.insert("atomicCounterIncrement");
+        builtinFunctionsTrie.insert("atomicCounterDecrement");
+        builtinFunctionsTrie.insert("atomicCounter");
+        builtinFunctionsTrie.insert("atomicAdd");
+        builtinFunctionsTrie.insert("atomicMin");
+        builtinFunctionsTrie.insert("atomicMax");
+        builtinFunctionsTrie.insert("atomicAnd");
+        builtinFunctionsTrie.insert("atomicOr");
+        builtinFunctionsTrie.insert("atomicXor");
+        builtinFunctionsTrie.insert("atomicExchange");
+        builtinFunctionsTrie.insert("atomicCompSwap");
+        builtinFunctionsTrie.insert("imageSize");
+        builtinFunctionsTrie.insert("imageLoad");
+        builtinFunctionsTrie.insert("imageStore");
+        builtinFunctionsTrie.insert("imageAtomicAdd");
+        builtinFunctionsTrie.insert("imageAtomicMin");
+        builtinFunctionsTrie.insert("imageAtomicMax");
+        builtinFunctionsTrie.insert("imageAtomicAnd");
+        builtinFunctionsTrie.insert("imageAtomicOr");
+        builtinFunctionsTrie.insert("imageAtomicXor");
+        builtinFunctionsTrie.insert("imageAtomicExchange");
+        builtinFunctionsTrie.insert("imageAtomicCompSwap");
+        builtinFunctionsTrie.insert("dFdx");
+        builtinFunctionsTrie.insert("dFdy");
+        builtinFunctionsTrie.insert("fwidth");
+        builtinFunctionsTrie.insert("interpolateAtCentroid");
+        builtinFunctionsTrie.insert("interpolateAtSample");
+        builtinFunctionsTrie.insert("interpolateAtOffset");
+        builtinFunctionsTrie.insert("noise1");
+        builtinFunctionsTrie.insert("noise2");
+        builtinFunctionsTrie.insert("noise3");
+        builtinFunctionsTrie.insert("noise4");
+        builtinFunctionsTrie.insert("EmitStreamVertex");
+        builtinFunctionsTrie.insert("EndStreamPrimitive");
+        builtinFunctionsTrie.insert("EmitVertex");
+        builtinFunctionsTrie.insert("EndPrimitive");
+        builtinFunctionsTrie.insert("barrier");
+        builtinFunctionsTrie.insert("memoryBarrier");
+        builtinFunctionsTrie.insert("memoryBarrierAtomicCounter");
+        builtinFunctionsTrie.insert("memoryBarrierBuffer");
+        builtinFunctionsTrie.insert("memoryBarrierShared");
+        builtinFunctionsTrie.insert("memoryBarrierImage");
+        builtinFunctionsTrie.insert("groupMemoryBarrier");
     }
     }
 
 
     public static KeywordType lookup(String s) {
     public static KeywordType lookup(String s) {