src/libs/glsl/glslast.h

   1 /**************************************************************************
   2 **
   3 ** This file is part of Qt Creator
   4 **
   5 ** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
   6 **
   7 ** Contact: Nokia Corporation (info@qt.nokia.com)
   8 **
   9 **
  10 ** GNU Lesser General Public License Usage
  11 **
  12 ** This file may be used under the terms of the GNU Lesser General Public
  13 ** License version 2.1 as published by the Free Software Foundation and
  14 ** appearing in the file LICENSE.LGPL included in the packaging of this file.
  15 ** Please review the following information to ensure the GNU Lesser General
  16 ** Public License version 2.1 requirements will be met:
  17 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  18 **
  19 ** In addition, as a special exception, Nokia gives you certain additional
  20 ** rights. These rights are described in the Nokia Qt LGPL Exception
  21 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  22 **
  23 ** Other Usage
  24 **
  25 ** Alternatively, this file may be used in accordance with the terms and
  26 ** conditions contained in a signed written agreement between you and Nokia.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **************************************************************************/
  32
  33 #ifndef GLSLAST_H
  34 #define GLSLAST_H
  35
  36 #include "glsl.h"
  37 #include "glslmemorypool.h"
  38 #include <QtCore/qstring.h>
  39
  40 namespace GLSL {
  41
  42 class AST;
  43 class TranslationUnitAST;
  44 class ExpressionAST;
  45 class IdentifierExpressionAST;
  46 class LiteralExpressionAST;
  47 class BinaryExpressionAST;
  48 class UnaryExpressionAST;
  49 class TernaryExpressionAST;
  50 class AssignmentExpressionAST;
  51 class MemberAccessExpressionAST;
  52 class FunctionCallExpressionAST;
  53 class FunctionIdentifierAST;
  54 class DeclarationExpressionAST;
  55 class StatementAST;
  56 class ExpressionStatementAST;
  57 class CompoundStatementAST;
  58 class IfStatementAST;
  59 class WhileStatementAST;
  60 class DoStatementAST;
  61 class ForStatementAST;
  62 class JumpStatementAST;
  63 class ReturnStatementAST;
  64 class SwitchStatementAST;
  65 class CaseLabelStatementAST;
  66 class DeclarationStatementAST;
  67 class TypeAST;
  68 class BasicTypeAST;
  69 class NamedTypeAST;
  70 class ArrayTypeAST;
  71 class StructTypeAST;
  72 class QualifiedTypeAST;
  73 class DeclarationAST;
  74 class PrecisionDeclarationAST;
  75 class ParameterDeclarationAST;
  76 class VariableDeclarationAST;
  77 class TypeDeclarationAST;
  78 class TypeAndVariableDeclarationAST;
  79 class InvariantDeclarationAST;
  80 class InitDeclarationAST;
  81 class FunctionDeclarationAST;
  82 class Visitor;
  83
  84 template <typename T>
  85 class GLSL_EXPORT List: public Managed
  86 {
  87 public:
  88     List(const T &value)
  89         : value(value), next(this), lineno(0) {}
  90
  91     List(List *previous, const T &value)
  92         : value(value), lineno(0)
  93     {
  94         next = previous->next;
  95         previous->next = this;
  96     }
  97
  98     List *finish()
  99     {
 100         List *head = next;
 101         next = 0;
 102         return head;
 103     }
 104
 105     T value;
 106     List *next;
 107     int lineno;
 108 };
 109
 110 // Append two lists, which are assumed to still be circular, pre-finish.
 111 template <typename T>
 112 List<T> *appendLists(List<T> *first, List<T> *second)
 113 {
 114     if (!first)
 115         return second;
 116     else if (!second)
 117         return first;
 118     List<T> *firstHead = first->next;
 119     List<T> *secondHead = second->next;
 120     first->next = secondHead;
 121     second->next = firstHead;
 122     return second;
 123 }
 124
 125 class GLSL_EXPORT AST: public Managed
 126 {
 127 public:
 128     enum Kind {
 129         Kind_Undefined,
 130
 131         // Translation unit
 132         Kind_TranslationUnit,
 133
 134         // Primary expressions
 135         Kind_Identifier,
 136         Kind_Literal,
 137
 138         // Unary expressions
 139         Kind_PreIncrement,
 140         Kind_PostIncrement,
 141         Kind_PreDecrement,
 142         Kind_PostDecrement,
 143         Kind_UnaryPlus,
 144         Kind_UnaryMinus,
 145         Kind_LogicalNot,
 146         Kind_BitwiseNot,
 147
 148         // Binary expressions
 149         Kind_Plus,
 150         Kind_Minus,
 151         Kind_Multiply,
 152         Kind_Divide,
 153         Kind_Modulus,
 154         Kind_ShiftLeft,
 155         Kind_ShiftRight,
 156         Kind_Equal,
 157         Kind_NotEqual,
 158         Kind_LessThan,
 159         Kind_LessEqual,
 160         Kind_GreaterThan,
 161         Kind_GreaterEqual,
 162         Kind_LogicalAnd,
 163         Kind_LogicalOr,
 164         Kind_LogicalXor,
 165         Kind_BitwiseAnd,
 166         Kind_BitwiseOr,
 167         Kind_BitwiseXor,
 168         Kind_Comma,
 169         Kind_ArrayAccess,
 170
 171         // Other expressions
 172         Kind_Conditional,
 173         Kind_MemberAccess,
 174         Kind_FunctionCall,
 175         Kind_MemberFunctionCall,
 176         Kind_FunctionIdentifier,
 177         Kind_DeclarationExpression,
 178
 179         // Assignment expressions
 180         Kind_Assign,
 181         Kind_AssignPlus,
 182         Kind_AssignMinus,
 183         Kind_AssignMultiply,
 184         Kind_AssignDivide,
 185         Kind_AssignModulus,
 186         Kind_AssignShiftLeft,
 187         Kind_AssignShiftRight,
 188         Kind_AssignAnd,
 189         Kind_AssignOr,
 190         Kind_AssignXor,
 191
 192         // Statements
 193         Kind_ExpressionStatement,
 194         Kind_CompoundStatement,
 195         Kind_If,
 196         Kind_While,
 197         Kind_Do,
 198         Kind_For,
 199         Kind_Break,
 200         Kind_Continue,
 201         Kind_Discard,
 202         Kind_Return,
 203         Kind_ReturnExpression,
 204         Kind_Switch,
 205         Kind_CaseLabel,
 206         Kind_DefaultLabel,
 207         Kind_DeclarationStatement,
 208
 209         // Types
 210         Kind_BasicType,
 211         Kind_NamedType,
 212         Kind_ArrayType,
 213         Kind_OpenArrayType,
 214         Kind_StructType,
 215         Kind_AnonymousStructType,
 216         Kind_StructField,
 217         Kind_QualifiedType,
 218
 219         // Declarations
 220         Kind_PrecisionDeclaration,
 221         Kind_ParameterDeclaration,
 222         Kind_VariableDeclaration,
 223         Kind_TypeDeclaration,
 224         Kind_TypeAndVariableDeclaration,
 225         Kind_InvariantDeclaration,
 226         Kind_InitDeclaration,
 227         Kind_FunctionDeclaration
 228     };
 229
 230     virtual TranslationUnitAST *asTranslationUnit() { return 0; }
 231
 232     virtual ExpressionAST *asExpression() { return 0; }
 233     virtual IdentifierExpressionAST *asIdentifierExpression() { return 0; }
 234     virtual LiteralExpressionAST *asLiteralExpression() { return 0; }
 235     virtual BinaryExpressionAST *asBinaryExpression() { return 0; }
 236     virtual UnaryExpressionAST *asUnaryExpression() { return 0; }
 237     virtual TernaryExpressionAST *asTernaryExpression() { return 0; }
 238     virtual AssignmentExpressionAST *asAssignmentExpression() { return 0; }
 239     virtual MemberAccessExpressionAST *asMemberAccessExpression() { return 0; }
 240     virtual FunctionCallExpressionAST *asFunctionCallExpression() { return 0; }
 241     virtual FunctionIdentifierAST *asFunctionIdentifier() { return 0; }
 242     virtual DeclarationExpressionAST *asDeclarationExpression() { return 0; }
 243
 244     virtual StatementAST *asStatement() { return 0; }
 245     virtual ExpressionStatementAST *asExpressionStatement() { return 0; }
 246     virtual CompoundStatementAST *asCompoundStatement() { return 0; }
 247     virtual IfStatementAST *asIfStatement() { return 0; }
 248     virtual WhileStatementAST *asWhileStatement() { return 0; }
 249     virtual DoStatementAST *asDoStatement() { return 0; }
 250     virtual ForStatementAST *asForStatement() { return 0; }
 251     virtual JumpStatementAST *asJumpStatement() { return 0; }
 252     virtual ReturnStatementAST *asReturnStatement() { return 0; }
 253     virtual SwitchStatementAST *asSwitchStatement() { return 0; }
 254     virtual CaseLabelStatementAST *asCaseLabelStatement() { return 0; }
 255     virtual DeclarationStatementAST *asDeclarationStatement() { return 0; }
 256
 257     virtual TypeAST *asType() { return 0; }
 258     virtual BasicTypeAST *asBasicType() { return 0; }
 259     virtual NamedTypeAST *asNamedType() { return 0; }
 260     virtual ArrayTypeAST *asArrayType() { return 0; }
 261     virtual StructTypeAST *asStructType() { return 0; }
 262     virtual QualifiedTypeAST *asQualifiedType() { return 0; }
 263
 264     virtual DeclarationAST *asDeclaration() { return 0; }
 265     virtual PrecisionDeclarationAST *asPrecisionDeclaration() { return 0; }
 266     virtual ParameterDeclarationAST *asParameterDeclaration() { return 0; }
 267     virtual VariableDeclarationAST *asVariableDeclaration() { return 0; }
 268     virtual TypeDeclarationAST *asTypeDeclaration() { return 0; }
 269     virtual TypeAndVariableDeclarationAST *asTypeAndVariableDeclaration() { return 0; }
 270     virtual InvariantDeclarationAST *asInvariantDeclaration() { return 0; }
 271     virtual InitDeclarationAST *asInitDeclaration() { return 0; }
 272     virtual FunctionDeclarationAST *asFunctionDeclaration() { return 0; }
 273
 274     void accept(Visitor *visitor);
 275     static void accept(AST *ast, Visitor *visitor);
 276
 277     template <typename T>
 278     static void accept(List<T> *it, Visitor *visitor)
 279     {
 280         for (; it; it = it->next)
 281             accept(it->value, visitor);
 282     }
 283
 284     virtual void accept0(Visitor *visitor) = 0;
 285
 286 protected:
 287     AST(Kind _kind) : kind(_kind), lineno(0) {}
 288
 289     template <typename T>
 290     static List<T> *finish(List<T> *list)
 291     {
 292         if (! list)
 293             return 0;
 294         return list->finish(); // convert the circular list with a linked list.
 295     }
 296
 297 public: // attributes
 298     int kind;
 299     int lineno;
 300
 301 protected:
 302     ~AST() {}       // Managed types cannot be deleted.
 303 };
 304
 305 class GLSL_EXPORT TranslationUnitAST: public AST
 306 {
 307 public:
 308     TranslationUnitAST(List<DeclarationAST *> *declarations)
 309         : AST(Kind_TranslationUnit), declarations(finish(declarations)) {}
 310
 311     virtual TranslationUnitAST *asTranslationUnit() { return this; }
 312
 313     virtual void accept0(Visitor *visitor);
 314
 315 public: // attributes
 316     List<DeclarationAST *> *declarations;
 317 };
 318
 319 class GLSL_EXPORT ExpressionAST: public AST
 320 {
 321 protected:
 322     ExpressionAST(Kind _kind) : AST(_kind) {}
 323
 324 public:
 325     virtual ExpressionAST *asExpression() { return this; }
 326 };
 327
 328 class GLSL_EXPORT IdentifierExpressionAST: public ExpressionAST
 329 {
 330 public:
 331     IdentifierExpressionAST(const QString *_name)
 332         : ExpressionAST(Kind_Identifier), name(_name) {}
 333
 334     virtual IdentifierExpressionAST *asIdentifierExpression() { return this; }
 335
 336     virtual void accept0(Visitor *visitor);
 337
 338 public: // attributes
 339     const QString *name;
 340 };
 341
 342 class GLSL_EXPORT LiteralExpressionAST: public ExpressionAST
 343 {
 344 public:
 345     LiteralExpressionAST(const QString *_value)
 346         : ExpressionAST(Kind_Literal), value(_value) {}
 347
 348     virtual LiteralExpressionAST *asLiteralExpression() { return this; }
 349
 350     virtual void accept0(Visitor *visitor);
 351
 352 public: // attributes
 353     const QString *value;
 354 };
 355
 356 class GLSL_EXPORT BinaryExpressionAST: public ExpressionAST
 357 {
 358 public:
 359     BinaryExpressionAST(Kind _kind, ExpressionAST *_left, ExpressionAST *_right)
 360         : ExpressionAST(_kind), left(_left), right(_right) {}
 361
 362     virtual BinaryExpressionAST *asBinaryExpression() { return this; }
 363
 364     virtual void accept0(Visitor *visitor);
 365
 366 public: // attributes
 367     ExpressionAST *left;
 368     ExpressionAST *right;
 369 };
 370
 371 class GLSL_EXPORT UnaryExpressionAST: public ExpressionAST
 372 {
 373 public:
 374     UnaryExpressionAST(Kind _kind, ExpressionAST *_expr)
 375         : ExpressionAST(_kind), expr(_expr) {}
 376
 377     virtual UnaryExpressionAST *asUnaryExpression() { return this; }
 378
 379     virtual void accept0(Visitor *visitor);
 380
 381 public: // attributes
 382     ExpressionAST *expr;
 383 };
 384
 385 class GLSL_EXPORT TernaryExpressionAST: public ExpressionAST
 386 {
 387 public:
 388     TernaryExpressionAST(Kind _kind, ExpressionAST *_first, ExpressionAST *_second, ExpressionAST *_third)
 389         : ExpressionAST(_kind), first(_first), second(_second), third(_third) {}
 390
 391     virtual TernaryExpressionAST *asTernaryExpression() { return this; }
 392
 393     virtual void accept0(Visitor *visitor);
 394
 395 public: // attributes
 396     ExpressionAST *first;
 397     ExpressionAST *second;
 398     ExpressionAST *third;
 399 };
 400
 401 class GLSL_EXPORT AssignmentExpressionAST: public ExpressionAST
 402 {
 403 public:
 404     AssignmentExpressionAST(Kind _kind, ExpressionAST *_variable, ExpressionAST *_value)
 405         : ExpressionAST(_kind), variable(_variable), value(_value) {}
 406
 407     virtual AssignmentExpressionAST *asAssignmentExpression() { return this; }
 408
 409     virtual void accept0(Visitor *visitor);
 410
 411 public: // attributes
 412     ExpressionAST *variable;
 413     ExpressionAST *value;
 414 };
 415
 416 class GLSL_EXPORT MemberAccessExpressionAST: public ExpressionAST
 417 {
 418 public:
 419     MemberAccessExpressionAST(ExpressionAST *_expr, const QString *_field)
 420         : ExpressionAST(Kind_MemberAccess), expr(_expr), field(_field) {}
 421
 422     virtual MemberAccessExpressionAST *asMemberAccessExpression() { return this; }
 423
 424     virtual void accept0(Visitor *visitor);
 425
 426 public: // attributes
 427     ExpressionAST *expr;
 428     const QString *field;
 429 };
 430
 431 class GLSL_EXPORT FunctionCallExpressionAST: public ExpressionAST
 432 {
 433 public:
 434     FunctionCallExpressionAST(FunctionIdentifierAST *_id,
 435                            List<ExpressionAST *> *_arguments)
 436         : ExpressionAST(Kind_FunctionCall), expr(0), id(_id)
 437         , arguments(finish(_arguments)) {}
 438     FunctionCallExpressionAST(ExpressionAST *_expr, FunctionIdentifierAST *_id,
 439                            List<ExpressionAST *> *_arguments)
 440         : ExpressionAST(Kind_MemberFunctionCall), expr(_expr), id(_id)
 441         , arguments(finish(_arguments)) {}
 442
 443     virtual FunctionCallExpressionAST *asFunctionCallExpression() { return this; }
 444
 445     virtual void accept0(Visitor *visitor);
 446
 447 public: // attributes
 448     ExpressionAST *expr;
 449     FunctionIdentifierAST *id;
 450     List<ExpressionAST *> *arguments;
 451 };
 452
 453 class GLSL_EXPORT FunctionIdentifierAST: public AST
 454 {
 455 public:
 456     FunctionIdentifierAST(const QString *_name)
 457         : AST(Kind_FunctionIdentifier), name(_name), type(0) {}
 458     FunctionIdentifierAST(TypeAST *_type)
 459         : AST(Kind_FunctionIdentifier), name(0), type(_type) {}
 460
 461     virtual FunctionIdentifierAST *asFunctionIdentifier() { return this; }
 462
 463     virtual void accept0(Visitor *visitor);
 464
 465 public: // attributes
 466     const QString *name;
 467     TypeAST *type;
 468 };
 469
 470 class GLSL_EXPORT DeclarationExpressionAST: public ExpressionAST
 471 {
 472 public:
 473     DeclarationExpressionAST(TypeAST *_type, const QString *_name,
 474                           ExpressionAST *_initializer)
 475         : ExpressionAST(Kind_DeclarationExpression), type(_type)
 476         , name(_name), initializer(_initializer) {}
 477
 478     virtual DeclarationExpressionAST *asDeclarationExpression() { return this; }
 479
 480     virtual void accept0(Visitor *visitor);
 481
 482 public: // attributes
 483     TypeAST *type;
 484     const QString *name;
 485     ExpressionAST *initializer;
 486 };
 487
 488 class GLSL_EXPORT StatementAST: public AST
 489 {
 490 protected:
 491     StatementAST(Kind _kind) : AST(_kind) {}
 492
 493 public:
 494     virtual StatementAST *asStatement() { return this; }
 495 };
 496
 497 class GLSL_EXPORT ExpressionStatementAST: public StatementAST
 498 {
 499 public:
 500     ExpressionStatementAST(ExpressionAST *_expr)
 501         : StatementAST(Kind_ExpressionStatement), expr(_expr) {}
 502
 503     virtual ExpressionStatementAST *asExpressionStatement() { return this; }
 504
 505     virtual void accept0(Visitor *visitor);
 506
 507 public: // attributes
 508     ExpressionAST *expr;
 509 };
 510
 511 class GLSL_EXPORT CompoundStatementAST: public StatementAST
 512 {
 513 public:
 514     CompoundStatementAST()
 515         : StatementAST(Kind_CompoundStatement), statements(0)
 516         , start(0), end(0), symbol(0) {}
 517     CompoundStatementAST(List<StatementAST *> *_statements)
 518         : StatementAST(Kind_CompoundStatement), statements(finish(_statements))
 519         , start(0), end(0), symbol(0) {}
 520
 521     virtual CompoundStatementAST *asCompoundStatement() { return this; }
 522
 523     virtual void accept0(Visitor *visitor);
 524
 525 public: // attributes
 526     List<StatementAST *> *statements;
 527     int start;
 528     int end;
 529     Block *symbol; // decoration
 530 };
 531
 532 class GLSL_EXPORT IfStatementAST: public StatementAST
 533 {
 534 public:
 535     IfStatementAST(ExpressionAST *_condition, StatementAST *_thenClause, StatementAST *_elseClause)
 536         : StatementAST(Kind_If), condition(_condition)
 537         , thenClause(_thenClause), elseClause(_elseClause) {}
 538
 539     virtual IfStatementAST *asIfStatement() { return this; }
 540
 541     virtual void accept0(Visitor *visitor);
 542
 543 public: // attributes
 544     ExpressionAST *condition;
 545     StatementAST *thenClause;
 546     StatementAST *elseClause;
 547 };
 548
 549 class GLSL_EXPORT WhileStatementAST: public StatementAST
 550 {
 551 public:
 552     WhileStatementAST(ExpressionAST *_condition, StatementAST *_body)
 553         : StatementAST(Kind_While), condition(_condition), body(_body) {}
 554
 555     virtual WhileStatementAST *asWhileStatement() { return this; }
 556
 557     virtual void accept0(Visitor *visitor);
 558
 559 public: // attributes
 560     ExpressionAST *condition;
 561     StatementAST *body;
 562 };
 563
 564 class GLSL_EXPORT DoStatementAST: public StatementAST
 565 {
 566 public:
 567     DoStatementAST(StatementAST *_body, ExpressionAST *_condition)
 568         : StatementAST(Kind_Do), body(_body), condition(_condition) {}
 569
 570     virtual DoStatementAST *asDoStatement() { return this; }
 571
 572     virtual void accept0(Visitor *visitor);
 573
 574 public: // attributes
 575     StatementAST *body;
 576     ExpressionAST *condition;
 577 };
 578
 579 class GLSL_EXPORT ForStatementAST: public StatementAST
 580 {
 581 public:
 582     ForStatementAST(StatementAST *_init, ExpressionAST *_condition, ExpressionAST *_increment, StatementAST *_body)
 583         : StatementAST(Kind_For), init(_init), condition(_condition), increment(_increment), body(_body) {}
 584
 585     virtual ForStatementAST *asForStatement() { return this; }
 586
 587     virtual void accept0(Visitor *visitor);
 588
 589 public: // attributes
 590     StatementAST *init;
 591     ExpressionAST *condition;
 592     ExpressionAST *increment;
 593     StatementAST *body;
 594 };
 595
 596 class GLSL_EXPORT JumpStatementAST: public StatementAST
 597 {
 598 public:
 599     JumpStatementAST(Kind _kind) : StatementAST(_kind) {}
 600
 601     virtual JumpStatementAST *asJumpStatement() { return this; }
 602
 603     virtual void accept0(Visitor *visitor);
 604 };
 605
 606 class GLSL_EXPORT ReturnStatementAST: public StatementAST
 607 {
 608 public:
 609     ReturnStatementAST() : StatementAST(Kind_Return), expr(0) {}
 610     ReturnStatementAST(ExpressionAST *_expr)
 611         : StatementAST(Kind_ReturnExpression), expr(_expr) {}
 612
 613     virtual ReturnStatementAST *asReturnStatement() { return this; }
 614
 615     virtual void accept0(Visitor *visitor);
 616
 617 public: // attributes
 618     ExpressionAST *expr;
 619 };
 620
 621 class GLSL_EXPORT SwitchStatementAST: public StatementAST
 622 {
 623 public:
 624     SwitchStatementAST(ExpressionAST *_expr, StatementAST *_body)
 625         : StatementAST(Kind_Switch), expr(_expr), body(_body) {}
 626
 627     virtual SwitchStatementAST *asSwitchStatement() { return this; }
 628
 629     virtual void accept0(Visitor *visitor);
 630
 631 public: // attributes
 632     ExpressionAST *expr;
 633     StatementAST *body;
 634 };
 635
 636 class GLSL_EXPORT CaseLabelStatementAST: public StatementAST
 637 {
 638 public:
 639     CaseLabelStatementAST() : StatementAST(Kind_DefaultLabel), expr(0) {}
 640     CaseLabelStatementAST(ExpressionAST *_expr)
 641         : StatementAST(Kind_CaseLabel), expr(_expr) {}
 642
 643     virtual CaseLabelStatementAST *asCaseLabelStatement() { return this; }
 644
 645     virtual void accept0(Visitor *visitor);
 646
 647 public: // attributes
 648     ExpressionAST *expr;
 649 };
 650
 651 class GLSL_EXPORT DeclarationStatementAST: public StatementAST
 652 {
 653 public:
 654     DeclarationStatementAST(DeclarationAST *_decl)
 655         : StatementAST(Kind_DeclarationStatement), decl(_decl) {}
 656
 657     virtual DeclarationStatementAST *asDeclarationStatement() { return this; }
 658
 659     virtual void accept0(Visitor *visitor);
 660
 661 public: // attributes
 662     DeclarationAST *decl;
 663 };
 664
 665 class GLSL_EXPORT TypeAST: public AST
 666 {
 667 protected:
 668     TypeAST(Kind _kind) : AST(_kind) {}
 669
 670 public:
 671     enum Precision
 672     {
 673         PrecNotValid,       // Precision not valid (e.g. structs).
 674         PrecUnspecified,    // Precision not known, but can be validly set.
 675         Lowp,
 676         Mediump,
 677         Highp
 678     };
 679
 680     virtual TypeAST *asType() { return this; }
 681
 682     virtual Precision precision() const = 0;
 683
 684     // Set the precision for the innermost basic type.  Returns false if it
 685     // is not valid to set a precision (e.g. structs).
 686     virtual bool setPrecision(Precision precision) = 0;
 687 };
 688
 689 class GLSL_EXPORT BasicTypeAST: public TypeAST
 690 {
 691 public:
 692     // Pass the parser's token code: T_VOID, T_VEC4, etc.
 693     BasicTypeAST(int _token, const char *_name);
 694
 695     virtual BasicTypeAST *asBasicType() { return this; }
 696
 697     virtual void accept0(Visitor *visitor);
 698
 699     virtual Precision precision() const;
 700     virtual bool setPrecision(Precision precision);
 701
 702 public: // attributes
 703     Precision prec;
 704     int token;
 705     const char *name;
 706 };
 707
 708 class GLSL_EXPORT NamedTypeAST: public TypeAST
 709 {
 710 public:
 711     NamedTypeAST(const QString *_name) : TypeAST(Kind_NamedType), name(_name) {}
 712
 713     virtual NamedTypeAST *asNamedType() { return this; }
 714
 715     virtual void accept0(Visitor *visitor);
 716
 717     virtual Precision precision() const;
 718     virtual bool setPrecision(Precision precision);
 719
 720 public: // attributes
 721     const QString *name;
 722 };
 723
 724 class GLSL_EXPORT ArrayTypeAST: public TypeAST
 725 {
 726 public:
 727     ArrayTypeAST(TypeAST *_elementType)
 728         : TypeAST(Kind_OpenArrayType), elementType(_elementType), size(0) {}
 729     ArrayTypeAST(TypeAST *_elementType, ExpressionAST *_size)
 730         : TypeAST(Kind_ArrayType), elementType(_elementType), size(_size) {}
 731
 732     virtual ArrayTypeAST *asArrayType() { return this; }
 733
 734     virtual void accept0(Visitor *visitor);
 735
 736     virtual Precision precision() const;
 737     virtual bool setPrecision(Precision precision);
 738
 739 public: // attributes
 740     TypeAST *elementType;
 741     ExpressionAST *size;
 742 };
 743
 744 class GLSL_EXPORT StructTypeAST: public TypeAST
 745 {
 746 public:
 747     class Field: public AST
 748     {
 749     public:
 750         Field(const QString *_name)
 751             : AST(Kind_StructField), name(_name), type(0) {}
 752
 753         // Takes the outer shell of an array type with the innermost
 754         // element type set to null.  The fixInnerTypes() method will
 755         // set the innermost element type to a meaningful value.
 756         Field(const QString *_name, TypeAST *_type)
 757             : AST(Kind_StructField), name(_name), type(_type) {}
 758
 759         virtual void accept0(Visitor *visitor);
 760
 761         void setInnerType(TypeAST *innerType);
 762
 763         const QString *name;
 764         TypeAST *type;
 765     };
 766
 767     StructTypeAST(List<Field *> *_fields)
 768         : TypeAST(Kind_AnonymousStructType), fields(finish(_fields)) {}
 769     StructTypeAST(const QString *_name, List<Field *> *_fields)
 770         : TypeAST(Kind_StructType), name(_name), fields(finish(_fields)) {}
 771
 772     virtual StructTypeAST *asStructType() { return this; }
 773
 774     virtual void accept0(Visitor *visitor);
 775
 776     virtual Precision precision() const;
 777     virtual bool setPrecision(Precision precision);
 778
 779     // Fix the inner types of a field list.  The "innerType" will
 780     // be copied into the "array holes" of all fields.
 781     static List<Field *> *fixInnerTypes(TypeAST *innerType, List<Field *> *fields);
 782
 783 public: // attributes
 784     const QString *name;
 785     List<Field *> *fields;
 786 };
 787
 788 class GLSL_EXPORT LayoutQualifier
 789 {
 790 public:
 791     LayoutQualifier(const QString *_name, const QString *_number)
 792         : name(_name), number(_number), lineno(0) {}
 793
 794 public: // attributes
 795     const QString *name;
 796     const QString *number;
 797     int lineno;
 798 };
 799
 800 class GLSL_EXPORT QualifiedTypeAST: public TypeAST
 801 {
 802 public:
 803     QualifiedTypeAST(int _qualifiers, TypeAST *_type, List<LayoutQualifier *> *_layout_list)
 804         : TypeAST(Kind_QualifiedType), qualifiers(_qualifiers), type(_type)
 805         , layout_list(finish(_layout_list)) {}
 806
 807     enum
 808     {
 809         StorageMask         = 0x000000FF,
 810         NoStorage           = 0x00000000,
 811         Const               = 0x00000001,
 812         Attribute           = 0x00000002,
 813         Varying             = 0x00000003,
 814         CentroidVarying     = 0x00000004,
 815         In                  = 0x00000005,
 816         Out                 = 0x00000006,
 817         CentroidIn          = 0x00000007,
 818         CentroidOut         = 0x00000008,
 819         PatchIn             = 0x00000009,
 820         PatchOut            = 0x0000000A,
 821         SampleIn            = 0x0000000B,
 822         SampleOut           = 0x0000000C,
 823         Uniform             = 0x0000000D,
 824         InterpolationMask   = 0x00000F00,
 825         NoInterpolation     = 0x00000000,
 826         Smooth              = 0x00000100,
 827         Flat                = 0x00000200,
 828         NoPerspective       = 0x00000300,
 829         Invariant           = 0x00010000,
 830         Struct              = 0x00020000
 831     };
 832
 833     virtual QualifiedTypeAST *asQualifiedType() { return this; }
 834
 835     virtual void accept0(Visitor *visitor);
 836
 837     virtual Precision precision() const { return type->precision(); }
 838     virtual bool setPrecision(Precision precision) { return type->setPrecision(precision); }
 839
 840 public: // attributes
 841     int qualifiers;
 842     TypeAST *type;
 843     List<LayoutQualifier *> *layout_list;
 844 };
 845
 846 class GLSL_EXPORT DeclarationAST: public AST
 847 {
 848 protected:
 849     DeclarationAST(Kind _kind) : AST(_kind) {}
 850
 851 public:
 852     virtual DeclarationAST *asDeclaration() { return this; }
 853 };
 854
 855 class GLSL_EXPORT PrecisionDeclarationAST: public DeclarationAST
 856 {
 857 public:
 858     PrecisionDeclarationAST(TypeAST::Precision _precision, TypeAST *_type)
 859         : DeclarationAST(Kind_PrecisionDeclaration)
 860         , precision(_precision), type(_type) {}
 861
 862     virtual PrecisionDeclarationAST *asPrecisionDeclaration() { return this; }
 863
 864     virtual void accept0(Visitor *visitor);
 865
 866 public: // attributes
 867     TypeAST::Precision precision;
 868     TypeAST *type;
 869 };
 870
 871 class GLSL_EXPORT ParameterDeclarationAST: public DeclarationAST
 872 {
 873 public:
 874     enum Qualifier
 875     {
 876         In,
 877         Out,
 878         InOut
 879     };
 880     ParameterDeclarationAST(TypeAST *_type, Qualifier _qualifier,
 881                          const QString *_name)
 882         : DeclarationAST(Kind_ParameterDeclaration), type(_type)
 883         , qualifier(_qualifier), name(_name) {}
 884
 885     virtual ParameterDeclarationAST *asParameterDeclaration() { return this; }
 886
 887     virtual void accept0(Visitor *visitor);
 888
 889 public: // attributes
 890     TypeAST *type;
 891     Qualifier qualifier;
 892     const QString *name;
 893 };
 894
 895 class GLSL_EXPORT VariableDeclarationAST: public DeclarationAST
 896 {
 897 public:
 898     VariableDeclarationAST(TypeAST *_type, const QString *_name,
 899                         ExpressionAST *_initializer = 0)
 900         : DeclarationAST(Kind_VariableDeclaration), type(_type)
 901         , name(_name), initializer(_initializer) {}
 902
 903     virtual VariableDeclarationAST *asVariableDeclaration() { return this; }
 904
 905     virtual void accept0(Visitor *visitor);
 906
 907     static TypeAST *declarationType(List<DeclarationAST *> *decls);
 908
 909 public: // attributes
 910     TypeAST *type;
 911     const QString *name;
 912     ExpressionAST *initializer;
 913 };
 914
 915 class GLSL_EXPORT TypeDeclarationAST: public DeclarationAST
 916 {
 917 public:
 918     TypeDeclarationAST(TypeAST *_type)
 919         : DeclarationAST(Kind_TypeDeclaration), type(_type) {}
 920
 921     virtual TypeDeclarationAST *asTypeDeclaration() { return this; }
 922
 923     virtual void accept0(Visitor *visitor);
 924
 925 public: // attributes
 926     TypeAST *type;
 927 };
 928
 929 class GLSL_EXPORT TypeAndVariableDeclarationAST: public DeclarationAST
 930 {
 931 public:
 932     TypeAndVariableDeclarationAST(TypeDeclarationAST *_typeDecl,
 933                                VariableDeclarationAST *_varDecl)
 934         : DeclarationAST(Kind_TypeAndVariableDeclaration)
 935         , typeDecl(_typeDecl), varDecl(_varDecl) {}
 936
 937     virtual TypeAndVariableDeclarationAST *asTypeAndVariableDeclaration() { return this; }
 938
 939     virtual void accept0(Visitor *visitor);
 940
 941 public: // attributes
 942     TypeDeclarationAST *typeDecl;
 943     VariableDeclarationAST *varDecl;
 944 };
 945
 946 class GLSL_EXPORT InvariantDeclarationAST: public DeclarationAST
 947 {
 948 public:
 949     InvariantDeclarationAST(const QString *_name)
 950         : DeclarationAST(Kind_InvariantDeclaration), name(_name) {}
 951
 952     virtual InvariantDeclarationAST *asInvariantDeclaration() { return this; }
 953
 954     virtual void accept0(Visitor *visitor);
 955
 956 public: // attributes
 957     const QString *name;
 958 };
 959
 960 class GLSL_EXPORT InitDeclarationAST: public DeclarationAST
 961 {
 962 public:
 963     InitDeclarationAST(List<DeclarationAST *> *_decls)
 964         : DeclarationAST(Kind_InitDeclaration), decls(finish(_decls)) {}
 965
 966     virtual InitDeclarationAST *asInitDeclaration() { return this; }
 967
 968     virtual void accept0(Visitor *visitor);
 969
 970 public: // attributes
 971     List<DeclarationAST *> *decls;
 972 };
 973
 974 class GLSL_EXPORT FunctionDeclarationAST : public DeclarationAST
 975 {
 976 public:
 977     FunctionDeclarationAST(TypeAST *_returnType, const QString *_name)
 978         : DeclarationAST(Kind_FunctionDeclaration), returnType(_returnType)
 979         , name(_name), params(0), body(0) {}
 980
 981     virtual FunctionDeclarationAST *asFunctionDeclaration() { return this; }
 982
 983     virtual void accept0(Visitor *visitor);
 984
 985     void finishParams() { params = finish(params); }
 986
 987     bool isPrototype() const { return body == 0; }
 988
 989 public: // attributes
 990     TypeAST *returnType;
 991     const QString *name;
 992     List<ParameterDeclarationAST *> *params;
 993     StatementAST *body;
 994 };
 995
 996 } // namespace GLSL
 997
 998 #endif // GLSLAST_H