Remove the pack/unpack languages and bring grammar up from 1.1 to 4.2 and fix the affected 1.1 productions and semantics to still work correctly for 1.1 shaders.

For 4.2, largely, it is only the grammar that is working.  Productions and semantics are mostly missing.  Lexical analysis is mostly done, but not in the preprocessor, which still can't handle uint and double literals.

The grammar and token names are reorganized to match the specification, to allow easier comparison between the specification and the working grammar.


git-svn-id: https://cvs.khronos.org/svn/repos/ogl/trunk/ecosystem/public/sdk/tools/glslang@19946 e7fa87d3-cd2b-0410-9028-fcbf551c1848

StandAlone/StandAlone.cpp

@@ -212,8 +212,6 @@ int C_DECL main(int argc, char* argv[])
 //
 //   .frag*    = fragment programs
 //   .vert*    = vertex programs
-//   .pack*    = pack programs
-//   .unpa*    = unpack pragrams
 //
 static EShLanguage FindLanguage(char *name)
 {
@@ -228,8 +226,6 @@ static EShLanguage FindLanguage(char *name)
     if (ext = strrchr(name, '.')) {
         if (strncmp(ext, ".frag", 4) == 0) return EShLangFragment;
         if (strncmp(ext, ".vert", 4) == 0) return EShLangVertex;
-        if (strncmp(ext, ".pack", 4) == 0) return EShLangPack;
-        if (strncmp(ext, ".unpa", 4) == 0) return EShLangUnpack;
     }
 
     return EShLangFragment;

glslang/Include/BaseTypes.h

@@ -77,10 +77,6 @@ enum TQualifier {
     EvqVaryingOut,    // vertex shaders only  read/write
     EvqUniform,       // Readonly, vertex and fragment
 
-    // pack/unpack input and output
-    EvqInput,
-    EvqOutput,
-
     // parameters
     EvqIn,
     EvqOut,
@@ -113,16 +109,14 @@ __inline const char* getQualifierString(TQualifier q)
     case EvqTemporary:      return "Temporary";      break;
     case EvqGlobal:         return "Global";         break;
     case EvqConst:          return "const";          break;
-    case EvqConstReadOnly:  return "const";          break;
+    case EvqConstReadOnly:  return "const (read only)"; break;
     case EvqAttribute:      return "attribute";      break;
-    case EvqVaryingIn:      return "varying";        break;
+    case EvqVaryingIn:      return "varying in";     break;
-    case EvqVaryingOut:     return "varying";        break;
+    case EvqVaryingOut:     return "varying out";    break;
     case EvqUniform:        return "uniform";        break;
     case EvqIn:             return "in";             break;
     case EvqOut:            return "out";            break;
     case EvqInOut:          return "inout";          break;
-    case EvqInput:          return "input";          break;
-    case EvqOutput:         return "output";         break;
     case EvqPosition:       return "Position";       break;
     case EvqPointSize:      return "PointSize";      break;
     case EvqClipVertex:     return "ClipVertex";     break;

glslang/Include/intermediate.h

@@ -118,6 +118,8 @@ enum TOperator {
 
     EOpVectorSwizzle,
 
+    EOpMethod,
+
     //
     // Built-in functions potentially mapped to operators
     //
@@ -169,16 +171,6 @@ enum TOperator {
     EOpAny,
     EOpAll,
 
-    EOpItof,         // pack/unpack only
-    EOpFtoi,         // pack/unpack only    
-    EOpSkipPixels,   // pack/unpack only
-    EOpReadInput,    // unpack only
-    EOpWritePixel,   // unpack only
-    EOpBitmapLsb,    // unpack only
-    EOpBitmapMsb,    // unpack only
-    EOpWriteOutput,  // pack only
-    EOpReadPixel,    // pack only
-    
     //
     // Branch
     //
@@ -242,6 +234,7 @@ class TIntermBinary;
 class TIntermConstantUnion;
 class TIntermSelection;
 class TIntermTyped;
+class TIntermMethod;
 class TIntermSymbol;
 class TInfoSink;
 
@@ -261,6 +254,7 @@ public:
     virtual TIntermAggregate* getAsAggregate()     { return 0; }
     virtual TIntermBinary*    getAsBinaryNode()    { return 0; }
     virtual TIntermSelection* getAsSelectionNode() { return 0; }
+    virtual TIntermMethod*    getAsMethodNode()    { return 0; }
     virtual TIntermSymbol*    getAsSymbolNode()    { return 0; }
     virtual ~TIntermNode() { }
 protected:
@@ -342,6 +336,23 @@ protected:
     TIntermTyped* expression;  // non-zero except for "return exp;" statements
 };
 
+//
+// Represent method names before seeing their calling signature
+// or resolving them to operations.  Just an expression as the base object
+// and a textural name.
+//
+class TIntermMethod : public TIntermTyped {
+public:
+    TIntermMethod(TIntermTyped* o, const TType& t, const TString& m) : TIntermTyped(t), object(o), method(m) { }
+    virtual TIntermMethod* getAsMethodNode() { return this; }
+    virtual const TString& getMethodName() const { return method; }
+    virtual TIntermTyped* getObject() const { return object; }
+    virtual void traverse(TIntermTraverser*);
+protected:
+    TIntermTyped* object;
+    TString method;
+};
+
 //
 // Nodes that correspond to symbols or constants in the source code.
 //

glslang/MachineIndependent/Initialize.cpp

@@ -918,18 +918,6 @@ void IdentifyBuiltIns(EShLanguage language, TSymbolTable& symbolTable)
 
         break;
 
-    case EShLangPack:
-    case EShLangUnpack:
-        symbolTable.relateToOperator("itof",         EOpItof);
-        symbolTable.relateToOperator("ftoi",         EOpFtoi);
-        symbolTable.relateToOperator("skipPixels",   EOpSkipPixels);
-        symbolTable.relateToOperator("readInput",    EOpReadInput);
-        symbolTable.relateToOperator("writePixel",   EOpWritePixel);
-        symbolTable.relateToOperator("bitmapLSB",    EOpBitmapLsb);
-        symbolTable.relateToOperator("bitmapMSB",    EOpBitmapMsb);
-        symbolTable.relateToOperator("writeOutput",  EOpWriteOutput);
-        symbolTable.relateToOperator("readPixel",    EOpReadPixel);
-        break;
 	default: assert(false && "Language not supported");
     }
 }

glslang/MachineIndependent/IntermTraverse.cpp

@@ -51,6 +51,12 @@
 //
 // Traversal functions for terminals are straighforward....
 //
+void TIntermMethod::traverse(TIntermTraverser* it)
+{
+    // TODO: current tree should always resolve all methods as constants
+    // 4.3 will leave some length methods as methods
+}
+
 void TIntermSymbol::traverse(TIntermTraverser* it)
 {
     if (it->visitSymbol)

glslang/MachineIndependent/Intermediate.cpp

@@ -554,6 +554,14 @@ TIntermTyped* TIntermediate::addComma(TIntermTyped* left, TIntermTyped* right, T
     }
 }
 
+TIntermTyped* TIntermediate::addMethod(TIntermTyped* object, TType& type, const TString* name, TSourceLoc line)
+{
+    TIntermMethod* method = new TIntermMethod(object, type, *name);
+    method->setLine(line);
+
+    return method;
+}
+
 //
 // For "?:" test nodes.  There are three children; a condition,
 // a true path, and a false path.  The two paths are specified

glslang/MachineIndependent/ParseHelper.cpp

@@ -251,6 +251,30 @@ void TParseContext::binaryOpError(int line, char* op, TString left, TString righ
             op, left.c_str(), right.c_str());
 }
 
+//
+// A basic type of EbtVoid is a key that the name string was seen in the source, but
+// it was not found as a variable in the symbol table.  If so, give the error
+// message and insert a dummy variable in the symbol table to prevent future errors.
+//
+void TParseContext::variableErrorCheck(TIntermTyped*& nodePtr) 
+{
+    TIntermSymbol* symbol = nodePtr->getAsSymbolNode();
+    if (symbol && symbol->getType().getBasicType() == EbtVoid) {
+        error(symbol->getLine(), "undeclared identifier", symbol->getSymbol().c_str(), "");
+        recover();
+
+        // Add to symbol table to prevent future error messages on the same name
+            
+        TVariable* fakeVariable = new TVariable(&symbol->getSymbol(), TType(EbtFloat));
+        symbolTable.insert(*fakeVariable);
+
+        // substitute a symbol node for this new variable
+        nodePtr = intermediate.addSymbol(fakeVariable->getUniqueId(), 
+                                         fakeVariable->getName(), 
+                                         fakeVariable->getType(), symbol->getLine());
+    }
+}
+
 //
 // Both test and if necessary, spit out an error, to see if the node is really
 // an l-value that can be operated on this way.
@@ -311,7 +335,6 @@ bool TParseContext::lValueErrorCheck(int line, char* op, TIntermTyped* node)
     case EvqAttribute:      message = "can't modify an attribute";   break;
     case EvqUniform:        message = "can't modify a uniform";      break;
     case EvqVaryingIn:      message = "can't modify a varying";      break;
-    case EvqInput:          message = "can't modify an input";       break;
     case EvqFace:           message = "can't modify gl_FrontFace";   break;
     case EvqFragCoord:      message = "can't modify gl_FragCoord";   break;
     default:
@@ -596,6 +619,24 @@ bool TParseContext::samplerErrorCheck(int line, const TPublicType& pType, const
     return false;
 }
 
+bool TParseContext::globalQualifierFixAndErrorCheck(int line, TQualifier& qualifier)
+{
+    switch (qualifier) {
+    case EvqIn:
+        qualifier = EvqVaryingIn;
+        return false;
+    case EvqOut:
+        qualifier = EvqVaryingOut;
+        return false;
+    case EvqInOut:
+        qualifier = EvqVaryingIn;
+        error(line, "cannot use both 'in' and 'out' at global scope", "", "");
+        return true;
+    }
+
+    return false;
+}
+
 bool TParseContext::structQualifierErrorCheck(int line, const TPublicType& pType)
 {
     if ((pType.qualifier == EvqVaryingIn || pType.qualifier == EvqVaryingOut || pType.qualifier == EvqAttribute) &&
@@ -885,23 +926,26 @@ bool TParseContext::nonInitErrorCheck(int line, TString& identifier, TPublicType
     return false;
 }
 
-bool TParseContext::paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type)
+bool TParseContext::paramErrorCheck(int line, TQualifier qualifier, TType* type)
 {
-    if (qualifier != EvqConst && qualifier != EvqTemporary) {
+    switch (qualifier) {
+    case EvqConst:
+    case EvqConstReadOnly:
+        type->changeQualifier(EvqConstReadOnly);
+        return false;
+    case EvqIn:
+    case EvqOut:
+    case EvqInOut:
+        type->changeQualifier(qualifier);
+        return false;
+    case EvqTemporary:
+        type->changeQualifier(EvqIn);
+        return false;
+    default:
+        type->changeQualifier(EvqIn);
         error(line, "qualifier not allowed on function parameter", getQualifierString(qualifier), "");
         return true;
     }
-    if (qualifier == EvqConst && paramQualifier != EvqIn) {
-        error(line, "qualifier not allowed with ", getQualifierString(qualifier), getQualifierString(paramQualifier));
-        return true;
-    }
-
-    if (qualifier == EvqConst)
-        type->changeQualifier(EvqConstReadOnly);
-    else
-        type->changeQualifier(paramQualifier);
-
-    return false;
 }
 
 bool TParseContext::extensionErrorCheck(int line, const char* extension)

glslang/MachineIndependent/ParseHelper.h

@@ -67,16 +67,18 @@ struct TParseContext {
     TParseContext(TSymbolTable& symt, TIntermediate& interm, EShLanguage L, TInfoSink& is) : 
             intermediate(interm), symbolTable(symt), infoSink(is), language(L), treeRoot(0),
             recoveredFromError(false), numErrors(0), lexAfterType(false), loopNestingLevel(0),
+            switchNestingLevel(0),
             inTypeParen(false), contextPragma(true, false) {  }
     TIntermediate& intermediate; // to hold and build a parse tree
     TSymbolTable& symbolTable;   // symbol table that goes with the language currently being parsed
     TInfoSink& infoSink;
-    EShLanguage language;        // vertex or fragment language (future: pack or unpack)
+    EShLanguage language;        // vertex or fragment language
     TIntermNode* treeRoot;       // root of parse tree being created
     bool recoveredFromError;     // true if a parse error has occurred, but we continue to parse
     int numErrors;
     bool lexAfterType;           // true if we've recognized a type, so can only be looking for an identifier
     int loopNestingLevel;        // 0 if outside all loops
+    int switchNestingLevel;      // 0 if outside all switch statements
     bool inTypeParen;            // true if in parentheses, looking only for an identifier
     const TType* currentFunctionType;  // the return type of the function that's currently being parsed
     bool functionReturnsValue;   // true if a non-void function has a return
@@ -93,6 +95,7 @@ struct TParseContext {
     void assignError(int line, const char* op, TString left, TString right);
     void unaryOpError(int line, char* op, TString operand);
     void binaryOpError(int line, char* op, TString left, TString right);
+    void variableErrorCheck(TIntermTyped*& nodePtr);
     bool lValueErrorCheck(int line, char* op, TIntermTyped*);
     bool constErrorCheck(TIntermTyped* node);
     bool integerErrorCheck(TIntermTyped* node, char* token);
@@ -107,12 +110,13 @@ struct TParseContext {
     bool boolErrorCheck(int, const TIntermTyped*);
     bool boolErrorCheck(int, const TPublicType&);
     bool samplerErrorCheck(int line, const TPublicType& pType, const char* reason);
+    bool globalQualifierFixAndErrorCheck(int line, TQualifier&);
     bool structQualifierErrorCheck(int line, const TPublicType& pType);
     bool parameterSamplerErrorCheck(int line, TQualifier qualifier, const TType& type);
     bool containsSampler(TType& type);
     bool nonInitConstErrorCheck(int line, TString& identifier, TPublicType& type);
     bool nonInitErrorCheck(int line, TString& identifier, TPublicType& type);
-    bool paramErrorCheck(int line, TQualifier qualifier, TQualifier paramQualifier, TType* type);
+    bool paramErrorCheck(int line, TQualifier qualifier, TType* type);
     bool extensionErrorCheck(int line, const char*);
     const TFunction* findFunction(int line, TFunction* pfnCall, bool *builtIn = 0);
     bool executeInitializer(TSourceLoc line, TString& identifier, TPublicType& pType, 

glslang/MachineIndependent/glslang.l

@@ -53,6 +53,10 @@ L           [a-zA-Z_]
 H           [a-fA-F0-9]
 E           [Ee][+-]?{D}+
 O           [0-7]
+U           [uU]
+
+/* TODO: double literals, which will likely require pre-processor rework */
+/* TODO: unsigned int literals, which will likely require pre-processor rework */
 
 %option nounput 
 %{
@@ -92,36 +96,85 @@ TSourceLoc yylineno;
 <*>"//"[^\n]*"\n"     { /* ?? carriage and/or line-feed? */ };
 
 "attribute"    {  pyylval->lex.line = yylineno; return(ATTRIBUTE); }
-"const"        {  pyylval->lex.line = yylineno; return(CONST_QUAL); }
+"const"        {  pyylval->lex.line = yylineno; return(CONST); }
+"patch"        {  pyylval->lex.line = yylineno; return(PATCH); }
+"sample"       {  pyylval->lex.line = yylineno; return(SAMPLE); }
 "uniform"      {  pyylval->lex.line = yylineno; return(UNIFORM); }
+"coherent"     {  pyylval->lex.line = yylineno; return(COHERENT); }
+"volatile"     {  pyylval->lex.line = yylineno; return(VOLATILE); }
+"restrict"     {  pyylval->lex.line = yylineno; return(RESTRICT); }
+"readonly"     {  pyylval->lex.line = yylineno; return(READONLY); }
+"writeonly"    {  pyylval->lex.line = yylineno; return(WRITEONLY); }
 "varying"      {  pyylval->lex.line = yylineno; return(VARYING); }
+"layout"       {  pyylval->lex.line = yylineno; return(LAYOUT); }
 
 "break"        {  pyylval->lex.line = yylineno; return(BREAK); }
 "continue"     {  pyylval->lex.line = yylineno; return(CONTINUE); }
 "do"           {  pyylval->lex.line = yylineno; return(DO); }
 "for"          {  pyylval->lex.line = yylineno; return(FOR); }
 "while"        {  pyylval->lex.line = yylineno; return(WHILE); }
+"switch"       {  pyylval->lex.line = yylineno; return(SWITCH); }
+"case"         {  pyylval->lex.line = yylineno; return(CASE); }
+"default"      {  pyylval->lex.line = yylineno; return(DEFAULT); }
 
 "if"           {  pyylval->lex.line = yylineno; return(IF); }
 "else"         {  pyylval->lex.line = yylineno; return(ELSE); }
 
-"in"           {  pyylval->lex.line = yylineno; return(IN_QUAL); }
+"in"           {  pyylval->lex.line = yylineno; return(IN); }
-"out"          {  pyylval->lex.line = yylineno; return(OUT_QUAL); }
+"out"          {  pyylval->lex.line = yylineno; return(OUT); }
-"inout"        {  pyylval->lex.line = yylineno; return(INOUT_QUAL); }
+"inout"        {  pyylval->lex.line = yylineno; return(INOUT); }
+"centroid"      {  pyylval->lex.line = yylineno; return(CENTROID); }
+"noperspective" {  pyylval->lex.line = yylineno; return(NOPERSPECTIVE); }
+"flat"          {  pyylval->lex.line = yylineno; return(FLAT); }
+"smooth"        {  pyylval->lex.line = yylineno; return(SMOOTH); }
 
-"float"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(FLOAT_TYPE); }
+"precise"      {  pyylval->lex.line = yylineno; return(PRECISE); }
-"int"          {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(INT_TYPE); }
+"invariant"    {  pyylval->lex.line = yylineno; return(INVARIANT); }
-"void"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(VOID_TYPE); }
+
-"bool"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(BOOL_TYPE); }
+"precision"    {  pyylval->lex.line = yylineno; return(PRECISION); }
+"highp"        {  pyylval->lex.line = yylineno; return(HIGH_PRECISION); }
+"mediump"      {  pyylval->lex.line = yylineno; return(MEDIUM_PRECISION); }
+"lowp"         {  pyylval->lex.line = yylineno; return(LOW_PRECISION); }
+
+"float"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(FLOAT); }
+"double"       {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DOUBLE); }
+"int"          {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(INT); }
+"uint"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UINT); }
+"void"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(VOID); }
+"bool"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(BOOL); }
 "true"         {  pyylval->lex.line = yylineno; pyylval->lex.b = true;  return(BOOLCONSTANT); }
 "false"        {  pyylval->lex.line = yylineno; pyylval->lex.b = false; return(BOOLCONSTANT); }
 
 "discard"      {  pyylval->lex.line = yylineno; return(DISCARD); }
 "return"       {  pyylval->lex.line = yylineno; return(RETURN); }
+"subroutine"   {  pyylval->lex.line = yylineno; return(SUBROUTINE); }
 
-"mat2"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MATRIX2); }
+"mat2"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT2); }
-"mat3"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MATRIX3); }
+"mat3"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT3); }
-"mat4"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MATRIX4); }
+"mat4"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT4); }
+
+"mat2x2"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT2X2); }
+"mat2x3"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT2X3); }
+"mat2x4"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT2X4); }
+"mat3x2"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT3X2); }
+"mat3x3"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT3X3); }
+"mat3x4"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT3X4); }
+"mat4x2"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT4X2); }
+"mat4x3"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT4X3); }
+"mat4x4"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(MAT4X4); }
+"dmat2"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT2); }
+"dmat3"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT3); }
+"dmat4"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT4); }
+"dmat2x2"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT2X2); }
+"dmat2x3"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT2X3); }
+"dmat2x4"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT2X4); }
+"dmat3x2"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT3X2); }
+"dmat3x3"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT3X3); }
+"dmat3x4"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT3X4); }
+"dmat4x2"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT4X2); }
+"dmat4x3"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT4X3); }
+"dmat4x4"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(DMAT4X4); }
+"atomic_uint"  { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(ATOMIC_UINT); }
 
 "vec2"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (VEC2); }
 "vec3"         {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (VEC3); }
@@ -129,6 +182,9 @@ TSourceLoc yylineno;
 "ivec2"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (IVEC2); }
 "ivec3"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (IVEC3); }
 "ivec4"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (IVEC4); }
+"uvec2"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (UVEC2); }
+"uvec3"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (UVEC3); }
+"uvec4"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (UVEC4); }
 "bvec2"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (BVEC2); }
 "bvec3"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (BVEC3); }
 "bvec4"        {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return (BVEC4); }
@@ -140,8 +196,71 @@ TSourceLoc yylineno;
 "sampler1DShadow" {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER1DSHADOW; }
 "sampler2DShadow" {  pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER2DSHADOW; }
 
-"sampler2DRect"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLERRECTARB; /* ARB_texture_rectangle */ }
+"sampler2DRect"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER2DRECT; }
-"sampler2DRectShadow"  { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLERRECTSHADOWARB; /* ARB_texture_rectangle */ }
+"isampler2DRect"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLER2DRECT; }
+"usampler2DRect"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLER2DRECT; }
+"sampler2DRectShadow"  { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER2DRECTSHADOW; }
+
+"samplerCubeShadow"    { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLERCUBESHADOW; }
+"sampler1DArray"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER1DARRAY; }
+"sampler2DArray"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER2DARRAY; }
+"sampler1DArrayShadow" { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER1DARRAYSHADOW; }
+"sampler2DArrayShadow" { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return SAMPLER2DARRAYSHADOW; }
+"isampler1D"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLER1D; }
+"isampler2D"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLER2D; }
+"isampler3D"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLER3D; }
+"isamplerCube"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLERCUBE; }
+"isampler1DArray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLER1DARRAY; }
+"isampler2DArray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return ISAMPLER2DARRAY; }
+"usampler1D"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLER1D; }
+"usampler2D"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLER2D; }
+"usampler3D"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLER3D; }
+"usamplerCube"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLERCUBE; }
+"usampler1DArray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLER1DARRAY; }
+"usampler2DArray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return USAMPLER2DARRAY; }
+
+"samplerBuffer"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(SAMPLERBUFFER); }
+"isamplerBuffer"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(ISAMPLERBUFFER); }
+"usamplerBuffer"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(USAMPLERBUFFER); }
+"sampler2DMS"          { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(SAMPLER2DMS); }
+"isampler2DMS"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(ISAMPLER2DMS); }
+"usampler2DMS"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(USAMPLER2DMS); }
+"sampler2DMSarray"     { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(SAMPLER2DMSARRAY); }
+"isampler2DMSarray"    { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(ISAMPLER2DMSARRAY); }
+"usampler2DMSarray"    { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(USAMPLER2DMSARRAY); }
+"image1D"              { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE1D); }
+"iimage1D"             { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE1D); }
+"uimage1D"             { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE1D); }
+"image2D"              { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE2D); }
+"iimage2D"             { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE2D); }
+"uimage2D"             { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE2D); }
+"image3D"              { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE3D); }
+"iimage3D"             { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE3D); }
+"uimage3D"             { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE3D); }
+"image2Drect"          { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE2DRECT); }
+"iimage2Drect"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE2DRECT); }
+"uimage2Drect"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE2DRECT); }
+"imageCube"            { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGECUBE); }
+"iimageCube"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGECUBE); }
+"uimageCube"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGECUBE); }
+"imageBuffer"          { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGEBUFFER); }
+"iimageBuffer"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGEBUFFER); }
+"uimageBuffer"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGEBUFFER); }
+"image1Darray"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE1DARRAY); }
+"iimage1Darray"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE1DARRAY); }
+"uimage1Darray"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE1DARRAY); }
+"image2Darray"         { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE2DARRAY); }
+"iimage2Darray"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE2DARRAY); }
+"uimage2Darray"        { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE2DARRAY); }
+"imageCubearray"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGECUBEARRAY); }
+"iimageCubearray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGECUBEARRAY); }
+"uimageCubearray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGECUBEARRAY); }
+"image2DMS"            { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE2DMS); }
+"iimage2DMS"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE2DMS); }
+"uimage2DMS"           { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE2DMS); }
+"image2DMSarray"       { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IMAGE2DMSARRAY); }
+"iimage2DMSarray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(IIMAGE2DMSARRAY); }
+"uimage2DMSarray"      { pyylval->lex.line = yylineno; parseContext.lexAfterType = true; return(UIMAGE2DMSARRAY); }
 
 "struct"       {  pyylval->lex.line = yylineno; return(STRUCT); }
 
@@ -156,12 +275,9 @@ TSourceLoc yylineno;
 "packed"       {  PaReservedWord(); return 0; }
 
 "goto"         {  PaReservedWord(); return 0; }
-"switch"       {  PaReservedWord(); return 0; }
-"default"      {  PaReservedWord(); return 0; }
 
 "inline"       {  PaReservedWord(); return 0; }
 "noinline"     {  PaReservedWord(); return 0; }
-"volatile"     {  PaReservedWord(); return 0; }
 "public"       {  PaReservedWord(); return 0; }
 "static"       {  PaReservedWord(); return 0; }
 "extern"       {  PaReservedWord(); return 0; }
@@ -170,7 +286,6 @@ TSourceLoc yylineno;
 
 "long"         {  PaReservedWord(); return 0; }
 "short"        {  PaReservedWord(); return 0; }
-"double"       {  PaReservedWord(); return 0; }
 "half"         {  PaReservedWord(); return 0; }
 "fixed"        {  PaReservedWord(); return 0; }
 "unsigned"     {  PaReservedWord(); return 0; }
@@ -207,6 +322,11 @@ TSourceLoc yylineno;
 0{D}+             { pyylval->lex.line = yylineno; parseContext.error(yylineno, "Invalid Octal number.", yytext, "", ""); parseContext.recover(); return 0;}
 {D}+              { pyylval->lex.line = yylineno; pyylval->lex.i = strtol(yytext, 0, 0); return(INTCONSTANT); }
 
+0[xX]{H}+{U}      { pyylval->lex.line = yylineno; pyylval->lex.i = strtol(yytext, 0, 0); return(UINTCONSTANT); }
+0{O}+{U}          { pyylval->lex.line = yylineno; pyylval->lex.i = strtol(yytext, 0, 0); return(UINTCONSTANT); }
+0{D}+{U}          { pyylval->lex.line = yylineno; parseContext.error(yylineno, "Invalid Octal number.", yytext, "", ""); parseContext.recover(); return 0;}
+{D}+{U}           { pyylval->lex.line = yylineno; pyylval->lex.i = strtol(yytext, 0, 0); return(UINTCONSTANT); }
+
 {D}+{E}           { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return(FLOATCONSTANT); }
 {D}+"."{D}*({E})? { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return(FLOATCONSTANT); }
 "."{D}+({E})?     { pyylval->lex.line = yylineno; pyylval->lex.f = static_cast<float>(atof(yytext)); return(FLOATCONSTANT); }

glslang/MachineIndependent/intermOut.cpp

@@ -306,16 +306,6 @@ bool OutputAggregate(bool /* preVisit */, TIntermAggregate* node, TIntermTravers
     case EOpRefract:       out.debug << "refract";                 break;
     case EOpMul:           out.debug << "component-wise multiply"; break;
 
-    case EOpItof:          out.debug << "itof";        break;
-    case EOpFtoi:          out.debug << "ftoi";        break;
-    case EOpSkipPixels:    out.debug << "skipPixels";  break;
-    case EOpReadInput:     out.debug << "readInput";   break;
-    case EOpWritePixel:    out.debug << "writePixel";  break;
-    case EOpBitmapLsb:     out.debug << "bitmapLSB";   break;
-    case EOpBitmapMsb:     out.debug << "bitmapMSB";   break;
-    case EOpWriteOutput:   out.debug << "writeOutput"; break;
-    case EOpReadPixel:     out.debug << "readPixel";   break;
-
     default: out.debug.message(EPrefixError, "Bad aggregation op");
     }
 

glslang/MachineIndependent/localintermediate.h

@@ -65,6 +65,7 @@ public:
     TIntermNode*  addSelection(TIntermTyped* cond, TIntermNodePair code, TSourceLoc);
     TIntermTyped* addSelection(TIntermTyped* cond, TIntermTyped* trueBlock, TIntermTyped* falseBlock, TSourceLoc);
     TIntermTyped* addComma(TIntermTyped* left, TIntermTyped* right, TSourceLoc);
+    TIntermTyped* addMethod(TIntermTyped*, TType&, const TString*, TSourceLoc);
     TIntermConstantUnion* addConstantUnion(constUnion*, const TType&, TSourceLoc);
     TIntermTyped* promoteConstantUnion(TBasicType, TIntermConstantUnion*) ;
     bool parseConstTree(TSourceLoc, TIntermNode*, constUnion*, TOperator, TSymbolTable&, TType, bool singleConstantParam = false);        

glslang/Public/ShaderLang.h

@@ -72,8 +72,6 @@ SH_IMPORT_EXPORT int __fastcall ShFinalize();
 typedef enum {
 	EShLangVertex,
 	EShLangFragment,
-	EShLangPack,
-    EShLangUnpack,
     EShLangCount,
 } EShLanguage;
 
@@ -82,8 +80,6 @@ typedef enum {
 //
 typedef enum {
     EShExVertexFragment,
-    EShExPackFragment,
-    EShExUnpackFragment,
     EShExFragment
 } EShExecutable;