----------------------------------------------------------------------------

--

-- Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

-- All rights reserved.

-- Contact: Nokia Corporation (qt-info@nokia.com)

--

-- This file is part of the QtCore module of the Qt Toolkit.

--

-- $QT_BEGIN_LICENSE:LGPL$

-- No Commercial Usage

-- This file contains pre-release code and may not be distributed.

-- You may use this file in accordance with the terms and conditions

-- contained in the Technology Preview License Agreement accompanying

-- this package.

--

-- 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.

--

-- In addition, as a special exception, Nokia gives you certain additional

-- rights.  These rights are described in the Nokia Qt LGPL Exception

-- version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

--

-- If you have questions regarding the use of this file, please contact

-- Nokia at qt-info@nokia.com.

--

--

--

--

--

--

--

--

-- $QT_END_LICENSE$

--

----------------------------------------------------------------------------

%parser GLSLParserTable

%merged_output glsl.cpp

%token ADD_ASSIGN

%token AMPERSAND

%token AND_ASSIGN

%token AND_OP

%token ATTRIBUTE

%token BANG

%token BOOL

%token BOOLCONSTANT

%token BREAK

%token BVEC2

%token BVEC3

%token BVEC4

%token CARET

%token COLON

%token COMMA

%token CONST

%token CONTINUE

%token DASH

%token DEC_OP

%token DISCARD

%token DIV_ASSIGN

%token DO

%token DOT

%token ELSE

%token EQUAL

%token EQ_OP

%token FLOAT

%token FLOATCONSTANT

%token FOR

%token GE_OP

%token IDENTIFIER

%token IF

%token IN

%token INC_OP

%token INOUT

%token INT

%token INTCONSTANT

%token IVEC2

%token IVEC3

%token IVEC4

%token LEFT_ANGLE

%token LEFT_ASSIGN

%token LEFT_BRACE

%token LEFT_BRACKET

%token LEFT_OP

%token LEFT_PAREN

%token LE_OP

%token MAT2

%token MAT3

%token MAT4

%token MOD_ASSIGN

%token MUL_ASSIGN

%token NE_OP

%token OR_ASSIGN

%token OR_OP

%token OUT

%token PERCENT

%token PLUS

%token QUESTION

%token RETURN

%token RIGHT_ANGLE

%token RIGHT_ASSIGN

%token RIGHT_BRACE

%token RIGHT_BRACKET

%token RIGHT_OP

%token RIGHT_PAREN

%token SAMPLER1D

%token SAMPLER1DSHADOW

%token SAMPLER2D

%token SAMPLER2DSHADOW

%token SAMPLER3D

%token SAMPLERCUBE

%token SEMICOLON

%token SLASH

%token STAR

%token STRUCT

%token SUB_ASSIGN

%token TILDE

%token TYPE_NAME

%token UNIFORM

%token VARYING

%token VEC2

%token VEC3

%token VEC4

%token VERTICAL_BAR

%token VOID

%token WHILE

%token XOR_ASSIGN

%token XOR_OP

%token ERROR

%token HIGH_PRECISION

%token MEDIUM_PRECISION

%token LOW_PRECISION

%start translation_unit

/:

#include <QtCore>

class GLSLParser: protected $table

{

public:

    union Value {

      int i;

      unsigned u;

      unsigned long ul;

      unsigned long long ull;

      long l;

      double d;

      float f;

      const QString *s;

      // ### more...

    };

public:

    GLSLParser();

    ~GLSLParser();

    bool parse();

protected:

    inline void reallocateStack();

    inline Value &sym(int index)

    { return sym_stack [tos + index - 1]; }

    int nextToken();

    bool isTypename(const QString *s) const

    {

      return types.contains(s);

    }

    inline const QString *intern(const QString &s)

    { return &*string_repository.insert(s); }

protected:

    int tos;

    int stack_size;

    Value *sym_stack;

    int *state_stack;

    Value yylval;

    QSet<QString> string_repository;

    QSet<const QString*> types;

    struct /*Context*/ {

      int line;

      const QString *function_name;

      QString fileName;

      void init()

      {

        line = 1;

        function_name = 0;

        fileName.clear();

      }

    } context;

};

inline void GLSLParser::reallocateStack()

{

    if (! stack_size)

        stack_size = 128;

    else

        stack_size <<= 1;

    sym_stack = reinterpret_cast<Value*> (qRealloc(sym_stack, stack_size * sizeof(Value)));

    state_stack = reinterpret_cast<int*> (qRealloc(state_stack, stack_size * sizeof(int)));

}

:/

/.

GLSLParser::GLSLParser():

    tos(0),

    stack_size(0),

    sym_stack(0),

    state_stack(0)

{

}

GLSLParser::~GLSLParser()

{

    if (stack_size) {

        qFree(sym_stack);

        qFree(state_stack);

    }

}

bool GLSLParser::parse()

{

  const int INITIAL_STATE = 0;

  int yytoken = -1;

  reallocateStack();

  context.init();

  tos = 0;

  state_stack[++tos] = INITIAL_STATE;

  while (true)

    {

      if (yytoken == -1 && - TERMINAL_COUNT != action_index [state_stack [tos]])

        yytoken = nextToken();

      int act = t_action (state_stack [tos], yytoken);

      if (act == ACCEPT_STATE) {

        return true;

      }

      else if (act > 0)

        {

          if (++tos == stack_size)

            reallocateStack();

          sym_stack [tos] = yylval;

          state_stack [tos] = act;

          yytoken = -1;

        }

      else if (act < 0)

        {

          int r = - act - 1;

          int ridx = rule_index [r];

          printf ("*** reduce using rule %d %s ::=", r + 1, spell[rule_info [ridx]]);

          ++ridx;

          for (int i = ridx; i < ridx + rhs [r]; ++i)

            {

              int symbol = rule_info [i];

              if (const char *name = spell [symbol])

                printf (" %s", name);

              else

                printf (" #%d", symbol);

            }

          printf ("\n");

          tos -= rhs [r];

          act = state_stack [tos++];

          switch (r) {

./

translation_unit ::= external_declaration ;

translation_unit ::= translation_unit external_declaration ;

variable_identifier ::= IDENTIFIER ;

primary_expression ::= variable_identifier ;

primary_expression ::= INTCONSTANT ;

primary_expression ::= FLOATCONSTANT ;

primary_expression ::= BOOLCONSTANT ;

primary_expression ::= LEFT_PAREN expression RIGHT_PAREN ;

postfix_expression ::= primary_expression ;

postfix_expression ::= postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET ;

postfix_expression ::= function_call ;

postfix_expression ::= postfix_expression DOT IDENTIFIER ;

postfix_expression ::= postfix_expression DOT TYPE_NAME ;

postfix_expression ::= postfix_expression INC_OP ;

postfix_expression ::= postfix_expression DEC_OP ;

integer_expression ::= expression ;

function_call ::= function_call_generic ;

function_call_generic ::= function_call_header_with_parameters RIGHT_PAREN ;

function_call_generic ::= function_call_header_no_parameters RIGHT_PAREN ;

function_call_header_no_parameters ::= function_call_header VOID ;

function_call_header_no_parameters ::= function_call_header ;

function_call_header_with_parameters ::= function_call_header assignment_expression ;

function_call_header_with_parameters ::= function_call_header_with_parameters COMMA assignment_expression ;

function_call_header ::=  function_identifier LEFT_PAREN ;

function_identifier ::= constructor_identifier ;

function_identifier ::= IDENTIFIER ;

constructor_identifier ::= FLOAT ;

constructor_identifier ::= INT ;

constructor_identifier ::= BOOL ;

constructor_identifier ::= VEC2 ;

constructor_identifier ::= VEC3 ;

constructor_identifier ::= VEC4 ;

constructor_identifier ::= BVEC2 ;

constructor_identifier ::= BVEC3 ;

constructor_identifier ::= BVEC4 ;

constructor_identifier ::= IVEC2 ;

constructor_identifier ::= IVEC3 ;

constructor_identifier ::= IVEC4 ;

constructor_identifier ::= MAT2 ;

constructor_identifier ::= MAT3 ;

constructor_identifier ::= MAT4 ;

constructor_identifier ::= TYPE_NAME ;

unary_expression ::= postfix_expression ;

unary_expression ::= INC_OP unary_expression ;

unary_expression ::= DEC_OP unary_expression ;

unary_expression ::= unary_operator unary_expression ;

-- Grammar Note:  No traditional style type casts.

unary_operator ::= PLUS ;

unary_operator ::= DASH ;

unary_operator ::= BANG ;

unary_operator ::= TILDE  ;    -- reserved

-- Grammar Note:  No '*' or '&' unary ops. Pointers are not supported.

multiplicative_expression ::= unary_expression ;

multiplicative_expression ::= multiplicative_expression STAR unary_expression ;

multiplicative_expression ::= multiplicative_expression SLASH unary_expression ;

multiplicative_expression ::= multiplicative_expression PERCENT unary_expression ;          -- reserved

additive_expression ::= multiplicative_expression ;

additive_expression ::= additive_expression PLUS multiplicative_expression ;

additive_expression ::= additive_expression DASH multiplicative_expression ;

shift_expression ::= additive_expression ;

shift_expression ::= shift_expression LEFT_OP additive_expression ;  -- reserved

shift_expression ::= shift_expression RIGHT_OP additive_expression ;  -- reserved

relational_expression ::= shift_expression ;

relational_expression ::= relational_expression LEFT_ANGLE shift_expression ;

relational_expression ::= relational_expression RIGHT_ANGLE shift_expression ;

relational_expression ::= relational_expression LE_OP shift_expression ;

relational_expression ::= relational_expression GE_OP shift_expression ;

equality_expression ::= relational_expression ;

equality_expression ::= equality_expression EQ_OP relational_expression ;

equality_expression ::= equality_expression NE_OP relational_expression ;

and_expression ::= equality_expression ;

and_expression ::= and_expression AMPERSAND equality_expression ; -- reserved

exclusive_or_expression ::= and_expression ;

exclusive_or_expression ::= exclusive_or_expression CARET and_expression ; -- reserved

inclusive_or_expression ::= exclusive_or_expression ;

inclusive_or_expression ::= inclusive_or_expression VERTICAL_BAR exclusive_or_expression ; -- reserved

logical_and_expression ::= inclusive_or_expression ;

logical_and_expression ::= logical_and_expression AND_OP inclusive_or_expression ;

logical_xor_expression ::= logical_and_expression ;

logical_xor_expression ::= logical_xor_expression XOR_OP logical_and_expression ;

logical_or_expression ::= logical_xor_expression ;

logical_or_expression ::= logical_or_expression OR_OP logical_xor_expression ;

conditional_expression ::= logical_or_expression ;

conditional_expression ::= logical_or_expression QUESTION expression COLON conditional_expression ;

assignment_expression ::= conditional_expression ;

assignment_expression ::= unary_expression assignment_operator assignment_expression ;

assignment_operator ::= EQUAL ;

assignment_operator ::= MUL_ASSIGN ;

assignment_operator ::= DIV_ASSIGN ;

assignment_operator ::= MOD_ASSIGN ; -- reserved