AST nodes for GLSL parser

src/libs/glsl/glsl-lib.pri

-HEADERS += $$PWD/glsl.h $$PWD/glsllexer.h $$PWD/glslparser.h glslparsertable_p.h $$PWD/glslast.h
+HEADERS += $$PWD/glsl.h $$PWD/glsllexer.h $$PWD/glslparser.h glslparsertable_p.h $$PWD/glslast.h \
+    $$PWD/glslastvisitor.h
 SOURCES += $$PWD/glslkeywords.cpp $$PWD/glslparser.cpp $$PWD/glslparsertable.cpp \
-    $$PWD/glsllexer.cpp $$PWD/glslast.cpp $$PWD/glsldump.cpp $$PWD/glsldelete.cpp
+    $$PWD/glsllexer.cpp $$PWD/glslast.cpp $$PWD/glsldump.cpp $$PWD/glsldelete.cpp \
+        $$PWD/glslastvisitor.cpp
 
 OTHER_FILES = $$PWD/specs/glsl.g.in \
     $$PWD/specs/grammar.txt

src/libs/glsl/glslast.cpp

@@ -27,14 +27,503 @@
 **
 **************************************************************************/
 #include "glslast.h"
+#include "glslastvisitor.h"
+#include "glslparsertable_p.h"
 
 using namespace GLSL;
 
-AST::AST()
+AST::~AST()
 {
 }
 
-AST::~AST()
+void AST::accept(Visitor *visitor)
+{
+    if (visitor->preVisit(this))
+        accept0(visitor);
+    visitor->postVisit(this);
+}
+
+void AST::accept(AST *ast, Visitor *visitor)
+{
+    if (ast)
+        ast->accept(visitor);
+}
+
+Statement *AST::makeCompound(Statement *left, Statement *right)
+{
+    if (!left)
+        return right;
+    else if (!right)
+        return left;
+    CompoundStatement *compound = left->asCompoundStatement();
+    if (compound) {
+        compound->statements.push_back(right);
+    } else {
+        compound = new CompoundStatement();
+        compound->statements.push_back(left);
+        compound->statements.push_back(right);
+    }
+    return compound;
+}
+
+void Operand::accept0(Visitor *visitor)
+{
+    visitor->visit(this);
+    visitor->endVisit(this);
+}
+
+void Operator::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (_Base::iterator it = begin(); it != end(); ++it)
+            accept(*it, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+IdentifierExpression::~IdentifierExpression()
+{
+}
+
+void IdentifierExpression::accept0(Visitor *visitor)
+{
+    visitor->visit(this);
+    visitor->endVisit(this);
+}
+
+LiteralExpression::~LiteralExpression()
+{
+}
+
+void LiteralExpression::accept0(Visitor *visitor)
+{
+    visitor->visit(this);
+    visitor->endVisit(this);
+}
+
+BinaryExpression::~BinaryExpression()
+{
+    delete left;
+    delete right;
+}
+
+void BinaryExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(left, visitor);
+        accept(right, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+UnaryExpression::~UnaryExpression()
+{
+    delete expr;
+}
+
+void UnaryExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this))
+        accept(expr, visitor);
+    visitor->endVisit(this);
+}
+
+TernaryExpression::~TernaryExpression()
+{
+    delete first;
+    delete second;
+    delete third;
+}
+
+void TernaryExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(first, visitor);
+        accept(second, visitor);
+        accept(third, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+AssignmentExpression::~AssignmentExpression()
+{
+    delete variable;
+    delete value;
+}
+
+void AssignmentExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(variable, visitor);
+        accept(value, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+MemberAccessExpression::~MemberAccessExpression()
+{
+    delete expr;
+}
+
+void MemberAccessExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this))
+        accept(expr, visitor);
+    visitor->endVisit(this);
+}
+
+FunctionCallExpression::~FunctionCallExpression()
+{
+    delete expr;
+    for (std::vector<Expression *>::iterator it = arguments.begin(); it != arguments.end(); ++it)
+        delete *it;
+}
+
+void FunctionCallExpression::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expr, visitor);
+        for (std::vector<Expression *>::iterator it = arguments.begin(); it != arguments.end(); ++it)
+            accept(*it, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+ExpressionStatement::~ExpressionStatement()
+{
+    delete expr;
+}
+
+void ExpressionStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this))
+        accept(expr, visitor);
+    visitor->endVisit(this);
+}
+
+CompoundStatement::~CompoundStatement()
+{
+    for (std::vector<Statement *>::iterator it = statements.begin(); it != statements.end(); ++it)
+        delete *it;
+}
+
+void CompoundStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (std::vector<Statement *>::iterator it = statements.begin(); it != statements.end(); ++it)
+            accept(*it, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+IfStatement::~IfStatement()
+{
+    delete condition;
+    delete thenClause;
+    delete elseClause;
+}
+
+void IfStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(condition, visitor);
+        accept(thenClause, visitor);
+        accept(elseClause, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+WhileStatement::~WhileStatement()
+{
+    delete condition;
+    delete body;
+}
+
+void WhileStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(condition, visitor);
+        accept(body, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+DoStatement::~DoStatement()
+{
+    delete body;
+    delete condition;
+}
+
+void DoStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(body, visitor);
+        accept(condition, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+ForStatement::~ForStatement()
+{
+    delete init;
+    delete condition;
+    delete increment;
+    delete body;
+}
+
+void ForStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(init, visitor);
+        accept(condition, visitor);
+        accept(increment, visitor);
+        accept(body, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+JumpStatement::~JumpStatement()
 {
 }
 
+void JumpStatement::accept0(Visitor *visitor)
+{
+    visitor->visit(this);
+    visitor->endVisit(this);
+}
+
+ReturnStatement::~ReturnStatement()
+{
+    delete expr;
+}
+
+void ReturnStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this))
+        accept(expr, visitor);
+    visitor->endVisit(this);
+}
+
+SwitchStatement::~SwitchStatement()
+{
+    delete expr;
+    delete body;
+}
+
+void SwitchStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(expr, visitor);
+        accept(body, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+CaseLabelStatement::~CaseLabelStatement()
+{
+    delete expr;
+}
+
+void CaseLabelStatement::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this))
+        accept(expr, visitor);
+    visitor->endVisit(this);
+}
+
+Type *Type::clone(Type *type)
+{
+    if (!type)
+        return 0;
+    Type *c = type->clone();
+    c->lineno = type->lineno;
+    return c;
+}
+
+BasicType::BasicType(int _token)
+    : Type(Kind_BasicType), token(_token)
+{
+    switch (token) {
+    case GLSLParserTable::T_VOID:
+    case GLSLParserTable::T_BOOL:
+    case GLSLParserTable::T_BVEC2:
+    case GLSLParserTable::T_BVEC3:
+    case GLSLParserTable::T_BVEC4:
+        prec = PrecNotValid;
+        break;
+    default:
+        prec = PrecUnspecified;
+        break;
+    }
+}
+
+BasicType::~BasicType()
+{
+}
+
+void BasicType::accept0(Visitor *visitor)
+{
+    visitor->visit(this);
+    visitor->endVisit(this);
+}
+
+Type::Precision BasicType::precision() const
+{
+    return prec;
+}
+
+bool BasicType::setPrecision(Precision precision)
+{
+    if (prec == PrecNotValid)
+        return false;
+    prec = precision;
+    return true;
+}
+
+Type *BasicType::clone() const
+{
+    return new BasicType(token, prec);
+}
+
+NamedType::~NamedType()
+{
+}
+
+void NamedType::accept0(Visitor *visitor)
+{
+    visitor->visit(this);
+    visitor->endVisit(this);
+}
+
+Type::Precision NamedType::precision() const
+{
+    // Named types are typically structs, which cannot have their precision set.
+    return PrecNotValid;
+}
+
+bool NamedType::setPrecision(Precision)
+{
+    return false;
+}
+
+Type *NamedType::clone() const
+{
+    return new NamedType(name);
+}
+
+ArrayType::~ArrayType()
+{
+    delete elementType;
+    delete size;
+}
+
+void ArrayType::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        accept(elementType, visitor);
+        accept(size, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+Type::Precision ArrayType::precision() const
+{
+    return elementType ? elementType->precision() : PrecNotValid;
+}
+
+bool ArrayType::setPrecision(Precision precision)
+{
+    if (elementType)
+        return elementType->setPrecision(precision);
+    else
+        return false;
+}
+
+Type *ArrayType::clone() const
+{
+    if (kind == Kind_ArrayType)
+        return new ArrayType(Type::clone(elementType), size);
+    else
+        return new ArrayType(Type::clone(elementType));
+}
+
+StructType::~StructType()
+{
+    for (std::vector<Field *>::iterator it = fields.begin(); it != fields.end(); ++it)
+        delete *it;
+}
+
+void StructType::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (std::vector<Field *>::iterator it = fields.begin(); it != fields.end(); ++it)
+            accept(*it, visitor);
+    }
+    visitor->endVisit(this);
+}
+
+Type::Precision StructType::precision() const
+{
+    return PrecNotValid;
+}
+
+bool StructType::setPrecision(Precision)
+{
+    // Structs cannot have a precision set.
+    return false;
+}
+
+Type *StructType::clone() const
+{
+    StructType *stype;
+    if (kind == Kind_AnonymousStructType)
+        stype = new StructType();
+    else
+        stype = new StructType(name);
+    for (std::vector<Field *>::const_iterator it = fields.begin(); it != fields.end(); ++it) {
+        stype->fields.push_back
+            (new Field((*it)->name, Type::clone((*it)->type)));
+    }
+    return stype;
+}
+
+StructType::Field::~Field()
+{
+    delete type;
+}
+
+void StructType::Field::accept0(Visitor *visitor)
+{
+    if (visitor->visit(this))
+        accept(type, visitor);
+    visitor->endVisit(this);
+}
+
+void StructType::Field::setInnerType(Type *innerType)
+{
+    if (!innerType)
+        return;
+    Type **parent = &type;
+    Type *inner = type;
+    while (inner != 0) {
+        ArrayType *array = inner->asArrayType();
+        if (!array)
+            break;
+        parent = &(array->elementType);
+        inner = array->elementType;
+    }
+    *parent = Type::clone(innerType);
+}
+
+void StructType::fixInnerTypes(Type *innerType, std::vector<Field *> &fields)
+{
+    for (size_t index = 0; index < fields.size(); ++index)
+        fields[index]->setInnerType(innerType);
+    delete innerType;   // No longer needed - cloned into all fields.
+}
+
+void StructType::addFields(const std::vector<Field *> &list)
+{
+    for (size_t index = 0; index < list.size(); ++index)
+        fields.push_back(list[index]);
+}

src/libs/glsl/glslast.h

@@ -29,25 +29,183 @@
 #ifndef GLSLAST_H
 #define GLSLAST_H
 
+#include "glsl.h"
 #include <vector>
+#include <string>
 
 namespace GLSL {
 
 class AST;
 class Operand;
 class Operator;
+class Expression;
+class IdentifierExpression;
+class LiteralExpression;
+class BinaryExpression;
+class UnaryExpression;
+class TernaryExpression;
+class AssignmentExpression;
+class MemberAccessExpression;
+class FunctionCallExpression;
+class Statement;
+class ExpressionStatement;
+class CompoundStatement;
+class IfStatement;
+class WhileStatement;
+class DoStatement;
+class ForStatement;
+class JumpStatement;
+class ReturnStatement;
+class SwitchStatement;
+class CaseLabelStatement;
+class Type;
+class BasicType;
+class NamedType;
+class ArrayType;
+class StructType;
+class Visitor;
 
-class AST
+class GLSL_EXPORT AST
 {
 public:
-    AST();
+    enum Kind {
+        Kind_Undefined,
+
+        // Primary expressions
+        Kind_Identifier,
+        Kind_Literal,
+
+        // Unary expressions
+        Kind_PreIncrement,
+        Kind_PostIncrement,
+        Kind_PreDecrement,
+        Kind_PostDecrement,
+        Kind_UnaryPlus,
+        Kind_UnaryMinus,
+        Kind_LogicalNot,
+        Kind_BitwiseNot,
+
+        // Binary expressions
+        Kind_Plus,
+        Kind_Minus,
+        Kind_Multiply,
+        Kind_Divide,
+        Kind_Modulus,
+        Kind_ShiftLeft,
+        Kind_ShiftRight,
+        Kind_Equal,
+        Kind_NotEqual,
+        Kind_LessThan,
+        Kind_LessEqual,
+        Kind_GreaterThan,
+        Kind_GreaterEqual,
+        Kind_LogicalAnd,
+        Kind_LogicalOr,
+        Kind_BitwiseAnd,
+        Kind_BitwiseOr,
+        Kind_BitwiseXor,
+        Kind_Comma,
+        Kind_ArrayAccess,
+
+        // Other expressions
+        Kind_Conditional,
+        Kind_MemberAccess,
+        Kind_FunctionCall,
+        Kind_MemberFunctionCall,
+
+        // Assignment expressions
+        Kind_Assign,
+        Kind_AssignPlus,
+        Kind_AssignMinus,
+        Kind_AssignMultiply,
+        Kind_AssignDivide,
+        Kind_AssignModulus,
+        Kind_AssignShiftLeft,
+        Kind_AssignShiftRight,
+        Kind_AssignAnd,
+        Kind_AssignOr,
+        Kind_AssignXor,
+
+        // Statements
+        Kind_ExpressionStatement,
+        Kind_CompoundStatement,
+        Kind_If,
+        Kind_While,
+        Kind_Do,
+        Kind_For,
+        Kind_Break,
+        Kind_Continue,
+        Kind_Discard,
+        Kind_Return,
+        Kind_ReturnExpression,
+        Kind_Switch,
+        Kind_CaseLabel,
+        Kind_DefaultLabel,
+
+        // Declarations
+
+        // Types
+        Kind_BasicType,
+        Kind_NamedType,
+        Kind_ArrayType,
+        Kind_OpenArrayType,
+        Kind_StructType,
+        Kind_AnonymousStructType,
+        Kind_StructField
+    };
+
+    AST() : kind(Kind_Undefined), lineno(0) {}
     virtual ~AST();
 
     virtual Operand *asOperand() { return 0; }
     virtual Operator *asOperator() { return 0; }
+
+    virtual Expression *asExpression() { return 0; }
+    virtual IdentifierExpression *asIdentifierExpression() { return 0; }
+    virtual LiteralExpression *asLiteralExpression() { return 0; }
+    virtual BinaryExpression *asBinaryExpression() { return 0; }
+    virtual UnaryExpression *asUnaryExpression() { return 0; }
+    virtual TernaryExpression *asTernaryExpression() { return 0; }
+    virtual AssignmentExpression *asAssignmentExpression() { return 0; }
+    virtual MemberAccessExpression *asMemberAccessExpression() { return 0; }
+    virtual FunctionCallExpression *asFunctionCallExpression() { return 0; }
+
+    virtual Statement *asStatement() { return 0; }
+    virtual ExpressionStatement *asExpressionStatement() { return 0; }
+    virtual CompoundStatement *asCompoundStatement() { return 0; }
+    virtual IfStatement *asIfStatement() { return 0; }
+    virtual WhileStatement *asWhileStatement() { return 0; }
+    virtual DoStatement *asDoStatement() { return 0; }
+    virtual ForStatement *asForStatement() { return 0; }
+    virtual JumpStatement *asJumpStatement() { return 0; }
+    virtual ReturnStatement *asReturnStatement() { return 0; }
+    virtual SwitchStatement *asSwitchStatement() { return 0; }
+    virtual CaseLabelStatement *asCaseLabelStatement() { return 0; }
+
+    virtual Type *asType() { return 0; }
+    virtual BasicType *asBasicType() { return 0; }
+    virtual NamedType *asNamedType() { return 0; }
+    virtual ArrayType *asArrayType() { return 0; }
+    virtual StructType *asStructType() { return 0; }
+
+    void accept(Visitor *visitor);
+    static void accept(AST *ast, Visitor *visitor);
+
+    virtual void accept0(Visitor *visitor) = 0;
+
+    // Efficiently make a compound statement out of "left" and "right",
+    // removing left-recursion in the process.
+    static Statement *makeCompound(Statement *left, Statement *right);
+
+protected:
+    AST(Kind _kind) : kind(_kind), lineno(0) {}
+
+public: // attributes
+    int kind;
+    int lineno;
 };
 
-class Operand: public AST
+class GLSL_EXPORT Operand: public AST
 {
 public:
     Operand(int location)
@@ -55,11 +213,13 @@ public:
 
     virtual Operand *asOperand() { return this; }
 
+    virtual void accept0(Visitor *visitor);
+
 public: // attributes
     int location;
 };
 
-class Operator: public AST, public std::vector<AST *>
+class GLSL_EXPORT Operator: public AST, public std::vector<AST *>
 {
     typedef std::vector<AST *> _Base;
 
@@ -70,10 +230,459 @@ public:
 
     virtual Operator *asOperator() { return this; }
 
+    virtual void accept0(Visitor *visitor);
+
 public: // attributes
     int ruleno;
 };
 
+class GLSL_EXPORT Expression: public AST
+{
+protected:
+    Expression(Kind _kind) { kind = _kind; }
+
+public:
+    virtual Expression *asExpression() { return this; }
+};
+
+class GLSL_EXPORT IdentifierExpression: public Expression
+{
+public:
+    IdentifierExpression(const std::string &_name)
+        : Expression(Kind_Identifier), name(_name) {}
+    ~IdentifierExpression();
+
+    virtual IdentifierExpression *asIdentifierExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    std::string name;
+};
+
+class GLSL_EXPORT LiteralExpression: public Expression
+{
+public:
+    LiteralExpression(const std::string &_value)
+        : Expression(Kind_Literal), value(_value) {}
+    ~LiteralExpression();
+
+    virtual LiteralExpression *asLiteralExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    std::string value;
+};
+
+class GLSL_EXPORT BinaryExpression: public Expression
+{
+public:
+    BinaryExpression(Kind _kind, Expression *_left, Expression *_right)
+        : Expression(_kind), left(_left), right(_right) {}
+    ~BinaryExpression();
+
+    virtual BinaryExpression *asBinaryExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *left;
+    Expression *right;
+};
+
+class GLSL_EXPORT UnaryExpression: public Expression
+{
+public:
+    UnaryExpression(Kind _kind, Expression *_expr)
+        : Expression(_kind), expr(_expr) {}
+    ~UnaryExpression();
+
+    virtual UnaryExpression *asUnaryExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+};
+
+class GLSL_EXPORT TernaryExpression: public Expression
+{
+public:
+    TernaryExpression(Kind _kind, Expression *_first, Expression *_second, Expression *_third)
+        : Expression(_kind), first(_first), second(_second), third(_third) {}
+    ~TernaryExpression();
+
+    virtual TernaryExpression *asTernaryExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *first;
+    Expression *second;
+    Expression *third;
+};
+
+class GLSL_EXPORT AssignmentExpression: public Expression
+{
+public:
+    AssignmentExpression(Kind _kind, Expression *_variable, Expression *_value)
+        : Expression(_kind), variable(_variable), value(_value) {}
+    ~AssignmentExpression();
+
+    virtual AssignmentExpression *asAssignmentExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *variable;
+    Expression *value;
+};
+
+class GLSL_EXPORT MemberAccessExpression: public Expression
+{
+public:
+    MemberAccessExpression(Expression *_expr, const std::string &_field)
+        : Expression(Kind_MemberAccess), expr(_expr), field(_field) {}
+    ~MemberAccessExpression();
+
+    virtual MemberAccessExpression *asMemberAccessExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+    std::string field;
+};
+
+class GLSL_EXPORT FunctionCallExpression: public Expression
+{
+public:
+    FunctionCallExpression(const std::string &_name)
+        : Expression(Kind_FunctionCall), expr(0), name(_name) {}
+    FunctionCallExpression(Expression *_expr, const std::string &_name)
+        : Expression(Kind_MemberFunctionCall), expr(_expr), name(_name) {}
+    ~FunctionCallExpression();
+
+    void addArgument(Expression *expr) { arguments.push_back(expr); }
+
+    virtual FunctionCallExpression *asFunctionCallExpression() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+    std::string name;
+    std::vector<Expression *> arguments;
+};
+
+class GLSL_EXPORT Statement: public AST
+{
+protected:
+    Statement(Kind _kind) : AST(_kind) {}
+
+public:
+    virtual Statement *asStatement() { return this; }
+};
+
+class GLSL_EXPORT ExpressionStatement: public Statement
+{
+public:
+    ExpressionStatement(Expression *_expr)
+        : Statement(Kind_ExpressionStatement), expr(_expr) {}
+    ~ExpressionStatement();
+
+    virtual ExpressionStatement *asExpressionStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+};
+
+class GLSL_EXPORT CompoundStatement: public Statement
+{
+public:
+    CompoundStatement() : Statement(Kind_CompoundStatement) {}
+    ~CompoundStatement();
+
+    virtual CompoundStatement *asCompoundStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    std::vector<Statement *> statements;
+};
+
+class GLSL_EXPORT IfStatement: public Statement
+{
+public:
+    IfStatement(Expression *_condition, Statement *_thenClause, Statement *_elseClause)
+        : Statement(Kind_If), condition(_condition)
+        , thenClause(_thenClause), elseClause(_elseClause) {}
+    ~IfStatement();
+
+    virtual IfStatement *asIfStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *condition;
+    Statement *thenClause;
+    Statement *elseClause;
+};
+
+class GLSL_EXPORT WhileStatement: public Statement
+{
+public:
+    WhileStatement(Expression *_condition, Statement *_body)
+        : Statement(Kind_While), condition(_condition), body(_body) {}
+    ~WhileStatement();
+
+    virtual WhileStatement *asWhileStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *condition;
+    Statement *body;
+};
+
+class GLSL_EXPORT DoStatement: public Statement
+{
+public:
+    DoStatement(Statement *_body, Expression *_condition)
+        : Statement(Kind_Do), body(_body), condition(_condition) {}
+    ~DoStatement();
+
+    virtual DoStatement *asDoStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Statement *body;
+    Expression *condition;
+};
+
+class GLSL_EXPORT ForStatement: public Statement
+{
+public:
+    ForStatement(Statement *_init, Expression *_condition, Expression *_increment, Statement *_body)
+        : Statement(Kind_For), init(_init), condition(_condition), increment(_increment), body(_body) {}
+    ~ForStatement();
+
+    virtual ForStatement *asForStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Statement *init;
+    Expression *condition;
+    Expression *increment;
+    Statement *body;
+};
+
+class GLSL_EXPORT JumpStatement: public Statement
+{
+public:
+    JumpStatement(Kind _kind) : Statement(_kind) {}
+    ~JumpStatement();
+
+    virtual JumpStatement *asJumpStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+};
+
+class GLSL_EXPORT ReturnStatement: public Statement
+{
+public:
+    ReturnStatement() : Statement(Kind_Return), expr(0) {}
+    ReturnStatement(Expression *_expr)
+        : Statement(Kind_ReturnExpression), expr(_expr) {}
+    ~ReturnStatement();
+
+    virtual ReturnStatement *asReturnStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+};
+
+class GLSL_EXPORT SwitchStatement: public Statement
+{
+public:
+    SwitchStatement(Expression *_expr, Statement *_body)
+        : Statement(Kind_Switch), expr(_expr), body(_body) {}
+    ~SwitchStatement();
+
+    virtual SwitchStatement *asSwitchStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+    Statement *body;
+};
+
+class GLSL_EXPORT CaseLabelStatement: public Statement
+{
+public:
+    CaseLabelStatement() : Statement(Kind_DefaultLabel), expr(0) {}
+    CaseLabelStatement(Expression *_expr)
+        : Statement(Kind_CaseLabel), expr(_expr) {}
+    ~CaseLabelStatement();
+
+    virtual CaseLabelStatement *asCaseLabelStatement() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+public: // attributes
+    Expression *expr;
+};
+
+class GLSL_EXPORT Type: public AST
+{
+protected:
+    Type(Kind _kind) : AST(_kind) {}
+
+public:
+    enum Precision
+    {
+        PrecNotValid,       // Precision not valid (e.g. structs and samplers).
+        PrecUnspecified,    // Precision not known, but can be validly set.
+        Lowp,
+        Mediump,
+        Highp
+    };
+
+    virtual Type *asType() { return this; }
+
+    virtual Precision precision() const = 0;
+
+    // Set the precision for the innermost basic type.  Returns false if it
+    // is not valid to set a precision (e.g. structs, samplers, etc).
+    virtual bool setPrecision(Precision precision) = 0;
+
+    virtual Type *clone() const = 0;
+    static Type *clone(Type *type);
+};
+
+class GLSL_EXPORT BasicType: public Type
+{
+public:
+    // Pass the parser's token code: T_VOID, T_VEC4, etc.
+    BasicType(int _token);
+    BasicType(int _token, Precision _prec)
+        : Type(Kind_BasicType), prec(_prec), token(_token) {}
+    ~BasicType();
+
+    virtual BasicType *asBasicType() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual Precision precision() const;
+    virtual bool setPrecision(Precision precision);
+
+    virtual Type *clone() const;
+
+public: // attributes
+    Precision prec;
+    int token;
+};
+
+class GLSL_EXPORT NamedType: public Type
+{
+public:
+    NamedType(const std::string &_name) : Type(Kind_NamedType), name(_name) {}
+    ~NamedType();
+
+    virtual NamedType *asNamedType() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual Precision precision() const;
+    virtual bool setPrecision(Precision precision);
+
+    virtual Type *clone() const;
+
+public: // attributes
+    std::string name;
+};
+
+class GLSL_EXPORT ArrayType: public Type
+{
+public:
+    ArrayType(Type *_elementType)
+        : Type(Kind_OpenArrayType), elementType(_elementType), size(0) {}
+    ArrayType(Type *_elementType, Expression *_size)
+        : Type(Kind_ArrayType), elementType(_elementType), size(_size) {}
+    ~ArrayType();
+
+    virtual ArrayType *asArrayType() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual Precision precision() const;
+    virtual bool setPrecision(Precision precision);
+
+    virtual Type *clone() const;
+
+public: // attributes
+    Type *elementType;
+    Expression *size;
+};
+
+class GLSL_EXPORT StructType: public Type
+{
+public:
+    StructType() : Type(Kind_AnonymousStructType) {}
+    StructType(const std::string &_name)
+        : Type(Kind_StructType), name(_name) {}
+    ~StructType();
+
+    virtual StructType *asStructType() { return this; }
+
+    virtual void accept0(Visitor *visitor);
+
+    virtual Precision precision() const;
+    virtual bool setPrecision(Precision precision);
+
+    virtual Type *clone() const;
+
+    class Field: public AST
+    {
+    public:
+        Field(const std::string &_name)
+            : AST(Kind_StructField), name(_name), type(0) {}
+
+        // Takes the outer shell of an array type with the innermost
+        // element type set to null.  The fixInnerTypes() method will
+        // set the innermost element type to a meaningful value.
+        Field(const std::string &_name, Type *_type)
+            : AST(Kind_StructField), name(_name), type(_type) {}
+
+        ~Field();
+
+        virtual void accept0(Visitor *visitor);
+
+        void setInnerType(Type *innerType);
+
+        std::string name;
+        Type *type;
+    };
+
+    // Fix the inner types of a field list.  The "innerType" will
+    // be cloned into all the fields and then deleted.
+    static void fixInnerTypes(Type *innerType, std::vector<Field *> &fields);
+
+    void addFields(const std::vector<Field *> &list);
+
+public: // attributes
+    std::string name;
+    std::vector<Field *> fields;
+};
+
 } // namespace GLSL
 
 #endif // GLSLAST_H

src/libs/glsl/glslastvisitor.cpp

+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** Commercial Usage
+**
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+**
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://qt.nokia.com/contact.
+**
+**************************************************************************/
+
+#include "glslastvisitor.h"
+
+using namespace GLSL;
+
+Visitor::Visitor()
+{
+}
+
+Visitor::~Visitor()
+{
+}

src/libs/glsl/glslastvisitor.h

+/**************************************************************************
+**
+** This file is part of Qt Creator
+**
+** Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
+**
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** Commercial Usage
+**
+** Licensees holding valid Qt Commercial licenses may use this file in
+** accordance with the Qt Commercial License Agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and Nokia.
+**
+** GNU Lesser General Public License Usage
+**
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://qt.nokia.com/contact.
+**
+**************************************************************************/
+#ifndef GLSLASTVISITOR_H
+#define GLSLASTVISITOR_H
+
+#include "glslast.h"
+
+namespace GLSL {
+
+class GLSL_EXPORT Visitor
+{
+public:
+    Visitor();
+    virtual ~Visitor();
+
+    virtual bool preVisit(AST *) { return true; }
+    virtual void postVisit(AST *) {}
+
+    virtual bool visit(Operand *) { return true; }
+    virtual void endVisit(Operand *) {}
+
+    virtual bool visit(Operator *) { return true; }
+    virtual void endVisit(Operator *) {}
+
+    virtual bool visit(IdentifierExpression *) { return true; }
+    virtual void endVisit(IdentifierExpression *) {}
+
+    virtual bool visit(LiteralExpression *) { return true; }
+    virtual void endVisit(LiteralExpression *) {}
+
+    virtual bool visit(BinaryExpression *) { return true; }
+    virtual void endVisit(BinaryExpression *) {}
+
+    virtual bool visit(UnaryExpression *) { return true; }
+    virtual void endVisit(UnaryExpression *) {}
+
+    virtual bool visit(TernaryExpression *) { return true; }
+    virtual void endVisit(TernaryExpression *) {}
+
+    virtual bool visit(AssignmentExpression *) { return true; }
+    virtual void endVisit(AssignmentExpression *) {}
+
+    virtual bool visit(MemberAccessExpression *) { return true; }
+    virtual void endVisit(MemberAccessExpression *) {}
+
+    virtual bool visit(FunctionCallExpression *) { return true; }
+    virtual void endVisit(FunctionCallExpression *) {}
+
+    virtual bool visit(ExpressionStatement *) { return true; }
+    virtual void endVisit(ExpressionStatement *) {}
+
+    virtual bool visit(CompoundStatement *) { return true; }
+    virtual void endVisit(CompoundStatement *) {}
+
+    virtual bool visit(IfStatement *) { return true; }
+    virtual void endVisit(IfStatement *) {}
+
+    virtual bool visit(WhileStatement *) { return true; }
+    virtual void endVisit(WhileStatement *) {}
+
+    virtual bool visit(DoStatement *) { return true; }
+    virtual void endVisit(DoStatement *) {}
+
+    virtual bool visit(ForStatement *) { return true; }
+    virtual void endVisit(ForStatement *) {}
+
+    virtual bool visit(JumpStatement *) { return true; }
+    virtual void endVisit(JumpStatement *) {}
+
+    virtual bool visit(ReturnStatement *) { return true; }
+    virtual void endVisit(ReturnStatement *) {}
+
+    virtual bool visit(SwitchStatement *) { return true; }
+    virtual void endVisit(SwitchStatement *) {}
+
+    virtual bool visit(CaseLabelStatement *) { return true; }
+    virtual void endVisit(CaseLabelStatement *) {}
+
+    virtual bool visit(BasicType *) { return true; }
+    virtual void endVisit(BasicType *) {}
+
+    virtual bool visit(NamedType *) { return true; }
+    virtual void endVisit(NamedType *) {}
+
+    virtual bool visit(ArrayType *) { return true; }
+    virtual void endVisit(ArrayType *) {}
+
+    virtual bool visit(StructType *) { return true; }
+    virtual void endVisit(StructType *) {}
+
+    virtual bool visit(StructType::Field *) { return true; }
+    virtual void endVisit(StructType::Field *) {}
+};
+
+} // namespace GLSL
+
+#endif // GLSLASTVISITOR_H