forked from qt-creator/qt-creator
f15646622a
"switch(" was recovered with number, ), ), ), ...
Task-number: QTCREATORBUG-18967
Change-Id: I12ccea0925fb2956de7405d9c8afea5dddeaf4f9
Reviewed-by: David Schulz <david.schulz@qt.io>
Reviewed-by: Erik Verbruggen <erik.verbruggen@qt.io>
2284 lines
45 KiB
C++
2284 lines
45 KiB
C++
|
|
#line 413 "./glsl.g"
|
|
|
|
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of Qt Creator.
|
|
**
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "glslparser.h"
|
|
#include "glslengine.h"
|
|
#include <iostream>
|
|
#include <cstdio>
|
|
#include <cassert>
|
|
#include <QDebug>
|
|
|
|
using namespace GLSL;
|
|
|
|
Parser::Parser(Engine *engine, const char *source, unsigned size, int variant)
|
|
: _engine(engine), _tos(-1), _index(0), yyloc(-1), yytoken(-1), yyrecovering(0), _recovered(false)
|
|
{
|
|
_tokens.reserve(1024);
|
|
|
|
_stateStack.resize(128);
|
|
_locationStack.resize(128);
|
|
_symStack.resize(128);
|
|
|
|
_tokens.push_back(Token()); // invalid token
|
|
|
|
std::stack<int> parenStack;
|
|
std::stack<int> bracketStack;
|
|
std::stack<int> braceStack;
|
|
|
|
Lexer lexer(engine, source, size);
|
|
lexer.setVariant(variant);
|
|
Token tk;
|
|
do {
|
|
lexer.yylex(&tk);
|
|
|
|
switch (tk.kind) {
|
|
case T_LEFT_PAREN:
|
|
parenStack.push(static_cast<int>(_tokens.size()));
|
|
break;
|
|
case T_LEFT_BRACKET:
|
|
bracketStack.push(static_cast<int>(_tokens.size()));
|
|
break;
|
|
case T_LEFT_BRACE:
|
|
braceStack.push(static_cast<int>(_tokens.size()));
|
|
break;
|
|
|
|
case T_RIGHT_PAREN:
|
|
if (! parenStack.empty()) {
|
|
_tokens[parenStack.top()].matchingBrace = static_cast<int>(_tokens.size());
|
|
parenStack.pop();
|
|
}
|
|
break;
|
|
case T_RIGHT_BRACKET:
|
|
if (! bracketStack.empty()) {
|
|
_tokens[bracketStack.top()].matchingBrace = static_cast<int>(_tokens.size());
|
|
bracketStack.pop();
|
|
}
|
|
break;
|
|
case T_RIGHT_BRACE:
|
|
if (! braceStack.empty()) {
|
|
_tokens[braceStack.top()].matchingBrace = static_cast<int>(_tokens.size());
|
|
braceStack.pop();
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
_tokens.push_back(tk);
|
|
} while (tk.isNot(EOF_SYMBOL));
|
|
|
|
_index = 0;
|
|
}
|
|
|
|
Parser::~Parser()
|
|
{
|
|
}
|
|
|
|
AST *Parser::parse(int startToken)
|
|
{
|
|
int action = 0;
|
|
yytoken = -1;
|
|
yyloc = -1;
|
|
void *yyval = 0; // value of the current token.
|
|
|
|
_recovered = false;
|
|
_tos = -1;
|
|
_startToken.kind = startToken;
|
|
int recoveryAttempts = 0;
|
|
|
|
|
|
do {
|
|
recoveryAttempts = 0;
|
|
|
|
againAfterRecovery:
|
|
if (unsigned(++_tos) == _stateStack.size()) {
|
|
_stateStack.resize(_tos * 2);
|
|
_locationStack.resize(_tos * 2);
|
|
_symStack.resize(_tos * 2);
|
|
}
|
|
|
|
_stateStack[_tos] = action;
|
|
|
|
if (yytoken == -1 && -TERMINAL_COUNT != action_index[action]) {
|
|
yyloc = consumeToken();
|
|
yytoken = tokenKind(yyloc);
|
|
if (yyrecovering)
|
|
--yyrecovering;
|
|
if (yytoken == T_IDENTIFIER && t_action(action, T_TYPE_NAME) != 0) {
|
|
const Token &la = tokenAt(_index);
|
|
|
|
if (la.is(T_IDENTIFIER)) {
|
|
yytoken = T_TYPE_NAME;
|
|
} else if (la.is(T_LEFT_BRACKET) && la.matchingBrace != 0 &&
|
|
tokenAt(la.matchingBrace + 1).is(T_IDENTIFIER)) {
|
|
yytoken = T_TYPE_NAME;
|
|
}
|
|
}
|
|
yyval = _tokens.at(yyloc).ptr;
|
|
}
|
|
|
|
action = t_action(action, yytoken);
|
|
if (action > 0) {
|
|
if (action == ACCEPT_STATE) {
|
|
--_tos;
|
|
return _symStack[0].translation_unit;
|
|
}
|
|
_symStack[_tos].ptr = yyval;
|
|
_locationStack[_tos] = yyloc;
|
|
yytoken = -1;
|
|
} else if (action < 0) {
|
|
const int ruleno = -action - 1;
|
|
const int N = rhs[ruleno];
|
|
_tos -= N;
|
|
reduce(ruleno);
|
|
action = nt_action(_stateStack[_tos], lhs[ruleno] - TERMINAL_COUNT);
|
|
} else if (action == 0) {
|
|
++recoveryAttempts;
|
|
if (recoveryAttempts > 10)
|
|
break;
|
|
const int line = _tokens[yyloc].line + 1;
|
|
QString message = QLatin1String("Syntax error");
|
|
if (yytoken != -1) {
|
|
const QLatin1String s(spell[yytoken]);
|
|
message = QString::fromLatin1("Unexpected token `%1'").arg(s);
|
|
}
|
|
|
|
for (; _tos; --_tos) {
|
|
const int state = _stateStack[_tos];
|
|
|
|
static int tks1[] = {
|
|
T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
|
|
T_SEMICOLON, T_COLON, T_COMMA,
|
|
T_NUMBER, T_TYPE_NAME, T_IDENTIFIER,
|
|
T_LEFT_BRACE, T_LEFT_PAREN, T_LEFT_BRACKET,
|
|
T_WHILE,
|
|
0
|
|
};
|
|
static int tks2[] = {
|
|
T_RIGHT_BRACE, T_RIGHT_PAREN, T_RIGHT_BRACKET,
|
|
T_SEMICOLON, T_COLON, T_COMMA,
|
|
0
|
|
};
|
|
int *tks;
|
|
if (recoveryAttempts < 2)
|
|
tks = tks1;
|
|
else
|
|
tks = tks2; // Avoid running into an endless loop for e.g.: for(int x=0; x y
|
|
|
|
for (int *tptr = tks; *tptr; ++tptr) {
|
|
const int next = t_action(state, *tptr);
|
|
if (next > 0) {
|
|
if (! yyrecovering && ! _recovered) {
|
|
_recovered = true;
|
|
error(line, QString::fromLatin1("Expected `%1'").arg(QLatin1String(spell[*tptr])));
|
|
}
|
|
|
|
yyrecovering = 3;
|
|
if (*tptr == T_IDENTIFIER)
|
|
yyval = (void *) _engine->identifier(QLatin1String("$identifier"));
|
|
else if (*tptr == T_NUMBER || *tptr == T_TYPE_NAME)
|
|
yyval = (void *) _engine->identifier(QLatin1String("$0"));
|
|
else
|
|
yyval = 0;
|
|
|
|
_symStack[_tos].ptr = yyval;
|
|
_locationStack[_tos] = yyloc;
|
|
yytoken = -1;
|
|
|
|
action = next;
|
|
goto againAfterRecovery;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (! _recovered) {
|
|
_recovered = true;
|
|
error(line, message);
|
|
}
|
|
}
|
|
|
|
} while (action);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#line 643 "./glsl.g"
|
|
|
|
void Parser::reduce(int ruleno)
|
|
{
|
|
switch(ruleno) {
|
|
|
|
#line 652 "./glsl.g"
|
|
|
|
case 0: {
|
|
ast(1) = makeAstNode<IdentifierExpressionAST>(string(1));
|
|
} break;
|
|
|
|
#line 659 "./glsl.g"
|
|
|
|
case 1: {
|
|
ast(1) = makeAstNode<LiteralExpressionAST>(string(1));
|
|
} break;
|
|
|
|
#line 666 "./glsl.g"
|
|
|
|
case 2: {
|
|
ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("true", 4));
|
|
} break;
|
|
|
|
#line 673 "./glsl.g"
|
|
|
|
case 3: {
|
|
ast(1) = makeAstNode<LiteralExpressionAST>(_engine->identifier("false", 5));
|
|
} break;
|
|
|
|
#line 680 "./glsl.g"
|
|
|
|
case 4: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 687 "./glsl.g"
|
|
|
|
case 5: {
|
|
ast(1) = ast(2);
|
|
} break;
|
|
|
|
#line 694 "./glsl.g"
|
|
|
|
case 6: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 701 "./glsl.g"
|
|
|
|
case 7: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ArrayAccess, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 708 "./glsl.g"
|
|
|
|
case 8: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 715 "./glsl.g"
|
|
|
|
case 9: {
|
|
ast(1) = makeAstNode<MemberAccessExpressionAST>(expression(1), string(3));
|
|
} break;
|
|
|
|
#line 722 "./glsl.g"
|
|
|
|
case 10: {
|
|
ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostIncrement, expression(1));
|
|
} break;
|
|
|
|
#line 729 "./glsl.g"
|
|
|
|
case 11: {
|
|
ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PostDecrement, expression(1));
|
|
} break;
|
|
|
|
#line 736 "./glsl.g"
|
|
|
|
case 12: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 743 "./glsl.g"
|
|
|
|
case 13: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 750 "./glsl.g"
|
|
|
|
case 14: {
|
|
ast(1) = makeAstNode<FunctionCallExpressionAST>
|
|
(sym(1).function.id, sym(1).function.arguments);
|
|
} break;
|
|
|
|
#line 758 "./glsl.g"
|
|
|
|
case 15: {
|
|
ast(1) = makeAstNode<FunctionCallExpressionAST>
|
|
(expression(1), sym(3).function.id, sym(3).function.arguments);
|
|
} break;
|
|
|
|
#line 766 "./glsl.g"
|
|
|
|
case 16: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 773 "./glsl.g"
|
|
|
|
case 17: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 780 "./glsl.g"
|
|
|
|
case 18: {
|
|
sym(1).function.id = sym(1).function_identifier;
|
|
sym(1).function.arguments = 0;
|
|
} break;
|
|
|
|
#line 788 "./glsl.g"
|
|
|
|
case 19: {
|
|
sym(1).function.id = sym(1).function_identifier;
|
|
sym(1).function.arguments = 0;
|
|
} break;
|
|
|
|
#line 796 "./glsl.g"
|
|
|
|
case 20: {
|
|
sym(1).function.id = sym(1).function_identifier;
|
|
sym(1).function.arguments =
|
|
makeAstNode< List<ExpressionAST *> >(expression(2));
|
|
} break;
|
|
|
|
#line 805 "./glsl.g"
|
|
|
|
case 21: {
|
|
sym(1).function.arguments =
|
|
makeAstNode< List<ExpressionAST *> >
|
|
(sym(1).function.arguments, expression(3));
|
|
} break;
|
|
|
|
#line 814 "./glsl.g"
|
|
|
|
case 22: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 821 "./glsl.g"
|
|
|
|
case 23: {
|
|
ast(1) = makeAstNode<FunctionIdentifierAST>(type(1));
|
|
} break;
|
|
|
|
#line 828 "./glsl.g"
|
|
|
|
case 24: {
|
|
ast(1) = makeAstNode<FunctionIdentifierAST>(string(1));
|
|
} break;
|
|
|
|
#line 835 "./glsl.g"
|
|
|
|
case 25: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 842 "./glsl.g"
|
|
|
|
case 26: {
|
|
ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreIncrement, expression(2));
|
|
} break;
|
|
|
|
#line 849 "./glsl.g"
|
|
|
|
case 27: {
|
|
ast(1) = makeAstNode<UnaryExpressionAST>(AST::Kind_PreDecrement, expression(2));
|
|
} break;
|
|
|
|
#line 856 "./glsl.g"
|
|
|
|
case 28: {
|
|
ast(1) = makeAstNode<UnaryExpressionAST>(sym(1).kind, expression(2));
|
|
} break;
|
|
|
|
#line 863 "./glsl.g"
|
|
|
|
case 29: {
|
|
sym(1).kind = AST::Kind_UnaryPlus;
|
|
} break;
|
|
|
|
#line 870 "./glsl.g"
|
|
|
|
case 30: {
|
|
sym(1).kind = AST::Kind_UnaryMinus;
|
|
} break;
|
|
|
|
#line 877 "./glsl.g"
|
|
|
|
case 31: {
|
|
sym(1).kind = AST::Kind_LogicalNot;
|
|
} break;
|
|
|
|
#line 884 "./glsl.g"
|
|
|
|
case 32: {
|
|
sym(1).kind = AST::Kind_BitwiseNot;
|
|
} break;
|
|
|
|
#line 891 "./glsl.g"
|
|
|
|
case 33: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 898 "./glsl.g"
|
|
|
|
case 34: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Multiply, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 905 "./glsl.g"
|
|
|
|
case 35: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Divide, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 912 "./glsl.g"
|
|
|
|
case 36: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Modulus, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 919 "./glsl.g"
|
|
|
|
case 37: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 926 "./glsl.g"
|
|
|
|
case 38: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Plus, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 933 "./glsl.g"
|
|
|
|
case 39: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Minus, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 940 "./glsl.g"
|
|
|
|
case 40: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 947 "./glsl.g"
|
|
|
|
case 41: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftLeft, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 954 "./glsl.g"
|
|
|
|
case 42: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_ShiftRight, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 961 "./glsl.g"
|
|
|
|
case 43: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 968 "./glsl.g"
|
|
|
|
case 44: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessThan, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 975 "./glsl.g"
|
|
|
|
case 45: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterThan, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 982 "./glsl.g"
|
|
|
|
case 46: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LessEqual, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 989 "./glsl.g"
|
|
|
|
case 47: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_GreaterEqual, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 996 "./glsl.g"
|
|
|
|
case 48: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1003 "./glsl.g"
|
|
|
|
case 49: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Equal, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1010 "./glsl.g"
|
|
|
|
case 50: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_NotEqual, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1017 "./glsl.g"
|
|
|
|
case 51: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1024 "./glsl.g"
|
|
|
|
case 52: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseAnd, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1031 "./glsl.g"
|
|
|
|
case 53: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1038 "./glsl.g"
|
|
|
|
case 54: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseXor, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1045 "./glsl.g"
|
|
|
|
case 55: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1052 "./glsl.g"
|
|
|
|
case 56: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_BitwiseOr, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1059 "./glsl.g"
|
|
|
|
case 57: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1066 "./glsl.g"
|
|
|
|
case 58: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalAnd, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1073 "./glsl.g"
|
|
|
|
case 59: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1080 "./glsl.g"
|
|
|
|
case 60: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalXor, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1087 "./glsl.g"
|
|
|
|
case 61: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1094 "./glsl.g"
|
|
|
|
case 62: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_LogicalOr, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1101 "./glsl.g"
|
|
|
|
case 63: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1108 "./glsl.g"
|
|
|
|
case 64: {
|
|
ast(1) = makeAstNode<TernaryExpressionAST>(AST::Kind_Conditional, expression(1), expression(3), expression(5));
|
|
} break;
|
|
|
|
#line 1115 "./glsl.g"
|
|
|
|
case 65: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1122 "./glsl.g"
|
|
|
|
case 66: {
|
|
ast(1) = makeAstNode<AssignmentExpressionAST>(sym(2).kind, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1129 "./glsl.g"
|
|
|
|
case 67: {
|
|
sym(1).kind = AST::Kind_Assign;
|
|
} break;
|
|
|
|
#line 1136 "./glsl.g"
|
|
|
|
case 68: {
|
|
sym(1).kind = AST::Kind_AssignMultiply;
|
|
} break;
|
|
|
|
#line 1143 "./glsl.g"
|
|
|
|
case 69: {
|
|
sym(1).kind = AST::Kind_AssignDivide;
|
|
} break;
|
|
|
|
#line 1150 "./glsl.g"
|
|
|
|
case 70: {
|
|
sym(1).kind = AST::Kind_AssignModulus;
|
|
} break;
|
|
|
|
#line 1157 "./glsl.g"
|
|
|
|
case 71: {
|
|
sym(1).kind = AST::Kind_AssignPlus;
|
|
} break;
|
|
|
|
#line 1164 "./glsl.g"
|
|
|
|
case 72: {
|
|
sym(1).kind = AST::Kind_AssignMinus;
|
|
} break;
|
|
|
|
#line 1171 "./glsl.g"
|
|
|
|
case 73: {
|
|
sym(1).kind = AST::Kind_AssignShiftLeft;
|
|
} break;
|
|
|
|
#line 1178 "./glsl.g"
|
|
|
|
case 74: {
|
|
sym(1).kind = AST::Kind_AssignShiftRight;
|
|
} break;
|
|
|
|
#line 1185 "./glsl.g"
|
|
|
|
case 75: {
|
|
sym(1).kind = AST::Kind_AssignAnd;
|
|
} break;
|
|
|
|
#line 1192 "./glsl.g"
|
|
|
|
case 76: {
|
|
sym(1).kind = AST::Kind_AssignXor;
|
|
} break;
|
|
|
|
#line 1199 "./glsl.g"
|
|
|
|
case 77: {
|
|
sym(1).kind = AST::Kind_AssignOr;
|
|
} break;
|
|
|
|
#line 1206 "./glsl.g"
|
|
|
|
case 78: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1213 "./glsl.g"
|
|
|
|
case 79: {
|
|
ast(1) = makeAstNode<BinaryExpressionAST>(AST::Kind_Comma, expression(1), expression(3));
|
|
} break;
|
|
|
|
#line 1220 "./glsl.g"
|
|
|
|
case 80: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1227 "./glsl.g"
|
|
|
|
case 81: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1234 "./glsl.g"
|
|
|
|
case 82: {
|
|
ast(1) = makeAstNode<InitDeclarationAST>(sym(1).declaration_list);
|
|
} break;
|
|
|
|
#line 1241 "./glsl.g"
|
|
|
|
case 83: {
|
|
ast(1) = makeAstNode<PrecisionDeclarationAST>(sym(2).precision, type(3));
|
|
} break;
|
|
|
|
#line 1248 "./glsl.g"
|
|
|
|
case 84: {
|
|
if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
|
|
// TODO: issue an error if the qualifier is not "struct".
|
|
}
|
|
TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
|
|
ast(1) = makeAstNode<TypeDeclarationAST>(type);
|
|
} break;
|
|
|
|
#line 1259 "./glsl.g"
|
|
|
|
case 85: {
|
|
if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
|
|
// TODO: issue an error if the qualifier does not contain "struct".
|
|
}
|
|
TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
|
|
TypeAST *qualtype = type;
|
|
if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
|
|
qualtype = makeAstNode<QualifiedTypeAST>
|
|
(sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype,
|
|
sym(1).type_qualifier.layout_list);
|
|
}
|
|
ast(1) = makeAstNode<TypeAndVariableDeclarationAST>
|
|
(makeAstNode<TypeDeclarationAST>(type),
|
|
makeAstNode<VariableDeclarationAST>(qualtype, string(6)));
|
|
} break;
|
|
|
|
#line 1278 "./glsl.g"
|
|
|
|
case 86: {
|
|
if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
|
|
// TODO: issue an error if the qualifier does not contain "struct".
|
|
}
|
|
TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
|
|
TypeAST *qualtype = type;
|
|
if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
|
|
qualtype = makeAstNode<QualifiedTypeAST>
|
|
(sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype,
|
|
sym(1).type_qualifier.layout_list);
|
|
}
|
|
ast(1) = makeAstNode<TypeAndVariableDeclarationAST>
|
|
(makeAstNode<TypeDeclarationAST>(type),
|
|
makeAstNode<VariableDeclarationAST>
|
|
(makeAstNode<ArrayTypeAST>(qualtype), string(6)));
|
|
} break;
|
|
|
|
#line 1298 "./glsl.g"
|
|
|
|
case 87: {
|
|
if ((sym(1).type_qualifier.qualifier & QualifiedTypeAST::Struct) == 0) {
|
|
// TODO: issue an error if the qualifier does not contain "struct".
|
|
}
|
|
TypeAST *type = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
|
|
TypeAST *qualtype = type;
|
|
if (sym(1).type_qualifier.qualifier != QualifiedTypeAST::Struct) {
|
|
qualtype = makeAstNode<QualifiedTypeAST>
|
|
(sym(1).type_qualifier.qualifier & ~QualifiedTypeAST::Struct, qualtype,
|
|
sym(1).type_qualifier.layout_list);
|
|
}
|
|
ast(1) = makeAstNode<TypeAndVariableDeclarationAST>
|
|
(makeAstNode<TypeDeclarationAST>(type),
|
|
makeAstNode<VariableDeclarationAST>
|
|
(makeAstNode<ArrayTypeAST>(qualtype, expression(8)), string(6)));
|
|
} break;
|
|
|
|
#line 1318 "./glsl.g"
|
|
|
|
case 88: {
|
|
TypeAST *type = makeAstNode<QualifiedTypeAST>
|
|
(sym(1).type_qualifier.qualifier, (TypeAST *)0,
|
|
sym(1).type_qualifier.layout_list);
|
|
ast(1) = makeAstNode<TypeDeclarationAST>(type);
|
|
} break;
|
|
|
|
#line 1328 "./glsl.g"
|
|
|
|
case 89: {
|
|
function(1)->finishParams();
|
|
} break;
|
|
|
|
#line 1335 "./glsl.g"
|
|
|
|
case 90: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1342 "./glsl.g"
|
|
|
|
case 91: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1349 "./glsl.g"
|
|
|
|
case 92: {
|
|
function(1)->params = makeAstNode< List<ParameterDeclarationAST *> >
|
|
(sym(2).param_declaration);
|
|
} break;
|
|
|
|
#line 1357 "./glsl.g"
|
|
|
|
case 93: {
|
|
function(1)->params = makeAstNode< List<ParameterDeclarationAST *> >
|
|
(function(1)->params, sym(3).param_declaration);
|
|
} break;
|
|
|
|
#line 1365 "./glsl.g"
|
|
|
|
case 94: {
|
|
function(1) = makeAstNode<FunctionDeclarationAST>(type(1), string(2));
|
|
} break;
|
|
|
|
#line 1372 "./glsl.g"
|
|
|
|
case 95: {
|
|
sym(1).param_declarator.type = type(1);
|
|
sym(1).param_declarator.name = string(2);
|
|
} break;
|
|
|
|
#line 1380 "./glsl.g"
|
|
|
|
case 96: {
|
|
sym(1).param_declarator.type = makeAstNode<ArrayTypeAST>(type(1), expression(4));
|
|
sym(1).param_declarator.name = string(2);
|
|
} break;
|
|
|
|
#line 1388 "./glsl.g"
|
|
|
|
case 97: {
|
|
ast(1) = makeAstNode<ParameterDeclarationAST>
|
|
(makeAstNode<QualifiedTypeAST>
|
|
(sym(1).qualifier, sym(3).param_declarator.type,
|
|
(List<LayoutQualifierAST *> *)0),
|
|
ParameterDeclarationAST::Qualifier(sym(2).qualifier),
|
|
sym(3).param_declarator.name);
|
|
} break;
|
|
|
|
#line 1400 "./glsl.g"
|
|
|
|
case 98: {
|
|
ast(1) = makeAstNode<ParameterDeclarationAST>
|
|
(sym(2).param_declarator.type,
|
|
ParameterDeclarationAST::Qualifier(sym(1).qualifier),
|
|
sym(2).param_declarator.name);
|
|
} break;
|
|
|
|
#line 1410 "./glsl.g"
|
|
|
|
case 99: {
|
|
ast(1) = makeAstNode<ParameterDeclarationAST>
|
|
(makeAstNode<QualifiedTypeAST>
|
|
(sym(1).qualifier, type(3), (List<LayoutQualifierAST *> *)0),
|
|
ParameterDeclarationAST::Qualifier(sym(2).qualifier),
|
|
(const QString *)0);
|
|
} break;
|
|
|
|
#line 1421 "./glsl.g"
|
|
|
|
case 100: {
|
|
ast(1) = makeAstNode<ParameterDeclarationAST>
|
|
(type(2), ParameterDeclarationAST::Qualifier(sym(1).qualifier),
|
|
(const QString *)0);
|
|
} break;
|
|
|
|
#line 1430 "./glsl.g"
|
|
|
|
case 101: {
|
|
sym(1).qualifier = ParameterDeclarationAST::In;
|
|
} break;
|
|
|
|
#line 1437 "./glsl.g"
|
|
|
|
case 102: {
|
|
sym(1).qualifier = ParameterDeclarationAST::In;
|
|
} break;
|
|
|
|
#line 1444 "./glsl.g"
|
|
|
|
case 103: {
|
|
sym(1).qualifier = ParameterDeclarationAST::Out;
|
|
} break;
|
|
|
|
#line 1451 "./glsl.g"
|
|
|
|
case 104: {
|
|
sym(1).qualifier = ParameterDeclarationAST::InOut;
|
|
} break;
|
|
|
|
#line 1458 "./glsl.g"
|
|
|
|
case 105: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1465 "./glsl.g"
|
|
|
|
case 106: {
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration);
|
|
} break;
|
|
|
|
#line 1473 "./glsl.g"
|
|
|
|
case 107: {
|
|
TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
|
|
DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3));
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, decl);
|
|
} break;
|
|
|
|
#line 1483 "./glsl.g"
|
|
|
|
case 108: {
|
|
TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
|
|
type = makeAstNode<ArrayTypeAST>(type);
|
|
DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3));
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, decl);
|
|
} break;
|
|
|
|
#line 1494 "./glsl.g"
|
|
|
|
case 109: {
|
|
TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
|
|
type = makeAstNode<ArrayTypeAST>(type, expression(5));
|
|
DeclarationAST *decl = makeAstNode<VariableDeclarationAST>(type, string(3));
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, decl);
|
|
} break;
|
|
|
|
#line 1505 "./glsl.g"
|
|
|
|
case 110: {
|
|
TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
|
|
type = makeAstNode<ArrayTypeAST>(type);
|
|
DeclarationAST *decl = makeAstNode<VariableDeclarationAST>
|
|
(type, string(3), expression(7));
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, decl);
|
|
} break;
|
|
|
|
#line 1517 "./glsl.g"
|
|
|
|
case 111: {
|
|
TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
|
|
type = makeAstNode<ArrayTypeAST>(type, expression(5));
|
|
DeclarationAST *decl = makeAstNode<VariableDeclarationAST>
|
|
(type, string(3), expression(8));
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, decl);
|
|
} break;
|
|
|
|
#line 1529 "./glsl.g"
|
|
|
|
case 112: {
|
|
TypeAST *type = VariableDeclarationAST::declarationType(sym(1).declaration_list);
|
|
DeclarationAST *decl = makeAstNode<VariableDeclarationAST>
|
|
(type, string(3), expression(5));
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, decl);
|
|
} break;
|
|
|
|
#line 1540 "./glsl.g"
|
|
|
|
case 113: {
|
|
ast(1) = makeAstNode<TypeDeclarationAST>(type(1));
|
|
} break;
|
|
|
|
#line 1547 "./glsl.g"
|
|
|
|
case 114: {
|
|
ast(1) = makeAstNode<VariableDeclarationAST>(type(1), string(2));
|
|
} break;
|
|
|
|
#line 1554 "./glsl.g"
|
|
|
|
case 115: {
|
|
ast(1) = makeAstNode<VariableDeclarationAST>
|
|
(makeAstNode<ArrayTypeAST>(type(1)), string(2));
|
|
} break;
|
|
|
|
#line 1562 "./glsl.g"
|
|
|
|
case 116: {
|
|
ast(1) = makeAstNode<VariableDeclarationAST>
|
|
(makeAstNode<ArrayTypeAST>(type(1), expression(4)), string(2));
|
|
} break;
|
|
|
|
#line 1570 "./glsl.g"
|
|
|
|
case 117: {
|
|
ast(1) = makeAstNode<VariableDeclarationAST>
|
|
(makeAstNode<ArrayTypeAST>(type(1)), string(2), expression(6));
|
|
} break;
|
|
|
|
#line 1578 "./glsl.g"
|
|
|
|
case 118: {
|
|
ast(1) = makeAstNode<VariableDeclarationAST>
|
|
(makeAstNode<ArrayTypeAST>(type(1), expression(4)),
|
|
string(2), expression(7));
|
|
} break;
|
|
|
|
#line 1587 "./glsl.g"
|
|
|
|
case 119: {
|
|
ast(1) = makeAstNode<VariableDeclarationAST>
|
|
(type(1), string(2), expression(4));
|
|
} break;
|
|
|
|
#line 1595 "./glsl.g"
|
|
|
|
case 120: {
|
|
ast(1) = makeAstNode<InvariantDeclarationAST>(string(2));
|
|
} break;
|
|
|
|
#line 1602 "./glsl.g"
|
|
|
|
case 121: {
|
|
ast(1) = makeAstNode<QualifiedTypeAST>(0, type(1), (List<LayoutQualifierAST *> *)0);
|
|
} break;
|
|
|
|
#line 1609 "./glsl.g"
|
|
|
|
case 122: {
|
|
ast(1) = makeAstNode<QualifiedTypeAST>
|
|
(sym(1).type_qualifier.qualifier, type(2),
|
|
sym(1).type_qualifier.layout_list);
|
|
} break;
|
|
|
|
#line 1618 "./glsl.g"
|
|
|
|
case 123: {
|
|
sym(1).qualifier = QualifiedTypeAST::Invariant;
|
|
} break;
|
|
|
|
#line 1625 "./glsl.g"
|
|
|
|
case 124: {
|
|
sym(1).qualifier = QualifiedTypeAST::Smooth;
|
|
} break;
|
|
|
|
#line 1632 "./glsl.g"
|
|
|
|
case 125: {
|
|
sym(1).qualifier = QualifiedTypeAST::Flat;
|
|
} break;
|
|
|
|
#line 1639 "./glsl.g"
|
|
|
|
case 126: {
|
|
sym(1).qualifier = QualifiedTypeAST::NoPerspective;
|
|
} break;
|
|
|
|
#line 1646 "./glsl.g"
|
|
|
|
case 127: {
|
|
sym(1) = sym(3);
|
|
} break;
|
|
|
|
#line 1653 "./glsl.g"
|
|
|
|
case 128: {
|
|
sym(1).layout_list = makeAstNode< List<LayoutQualifierAST *> >(sym(1).layout);
|
|
} break;
|
|
|
|
#line 1660 "./glsl.g"
|
|
|
|
case 129: {
|
|
sym(1).layout_list = makeAstNode< List<LayoutQualifierAST *> >(sym(1).layout_list, sym(3).layout);
|
|
} break;
|
|
|
|
#line 1667 "./glsl.g"
|
|
|
|
case 130: {
|
|
sym(1).layout = makeAstNode<LayoutQualifierAST>(string(1), (const QString *)0);
|
|
} break;
|
|
|
|
#line 1674 "./glsl.g"
|
|
|
|
case 131: {
|
|
sym(1).layout = makeAstNode<LayoutQualifierAST>(string(1), string(3));
|
|
} break;
|
|
|
|
#line 1681 "./glsl.g"
|
|
|
|
case 132: {
|
|
sym(1).qualifier = QualifiedTypeAST::Const;
|
|
} break;
|
|
|
|
#line 1688 "./glsl.g"
|
|
|
|
case 133: {
|
|
sym(1).type_qualifier.qualifier = sym(1).qualifier;
|
|
sym(1).type_qualifier.layout_list = 0;
|
|
} break;
|
|
|
|
#line 1696 "./glsl.g"
|
|
|
|
case 134: {
|
|
sym(1).type_qualifier.layout_list = sym(1).layout_list;
|
|
sym(1).type_qualifier.qualifier = 0;
|
|
} break;
|
|
|
|
#line 1704 "./glsl.g"
|
|
|
|
case 135: {
|
|
sym(1).type_qualifier.layout_list = sym(1).layout_list;
|
|
sym(1).type_qualifier.qualifier = sym(2).qualifier;
|
|
} break;
|
|
|
|
#line 1712 "./glsl.g"
|
|
|
|
case 136: {
|
|
sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier;
|
|
sym(1).type_qualifier.layout_list = 0;
|
|
} break;
|
|
|
|
#line 1720 "./glsl.g"
|
|
|
|
case 137: {
|
|
sym(1).type_qualifier.qualifier = sym(1).qualifier;
|
|
sym(1).type_qualifier.layout_list = 0;
|
|
} break;
|
|
|
|
#line 1728 "./glsl.g"
|
|
|
|
case 138: {
|
|
sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier;
|
|
sym(1).type_qualifier.layout_list = 0;
|
|
} break;
|
|
|
|
#line 1736 "./glsl.g"
|
|
|
|
case 139: {
|
|
sym(1).type_qualifier.qualifier = sym(1).qualifier | sym(2).qualifier | sym(3).qualifier;
|
|
sym(1).type_qualifier.layout_list = 0;
|
|
} break;
|
|
|
|
#line 1744 "./glsl.g"
|
|
|
|
case 140: {
|
|
sym(1).type_qualifier.qualifier = QualifiedTypeAST::Invariant;
|
|
sym(1).type_qualifier.layout_list = 0;
|
|
} break;
|
|
|
|
#line 1752 "./glsl.g"
|
|
|
|
case 141: {
|
|
sym(1).qualifier = QualifiedTypeAST::Const;
|
|
} break;
|
|
|
|
#line 1759 "./glsl.g"
|
|
|
|
case 142: {
|
|
sym(1).qualifier = QualifiedTypeAST::Attribute;
|
|
} break;
|
|
|
|
#line 1766 "./glsl.g"
|
|
|
|
case 143: {
|
|
sym(1).qualifier = QualifiedTypeAST::Varying;
|
|
} break;
|
|
|
|
#line 1773 "./glsl.g"
|
|
|
|
case 144: {
|
|
sym(1).qualifier = QualifiedTypeAST::CentroidVarying;
|
|
} break;
|
|
|
|
#line 1780 "./glsl.g"
|
|
|
|
case 145: {
|
|
sym(1).qualifier = QualifiedTypeAST::In;
|
|
} break;
|
|
|
|
#line 1787 "./glsl.g"
|
|
|
|
case 146: {
|
|
sym(1).qualifier = QualifiedTypeAST::Out;
|
|
} break;
|
|
|
|
#line 1794 "./glsl.g"
|
|
|
|
case 147: {
|
|
sym(1).qualifier = QualifiedTypeAST::CentroidIn;
|
|
} break;
|
|
|
|
#line 1801 "./glsl.g"
|
|
|
|
case 148: {
|
|
sym(1).qualifier = QualifiedTypeAST::CentroidOut;
|
|
} break;
|
|
|
|
#line 1808 "./glsl.g"
|
|
|
|
case 149: {
|
|
sym(1).qualifier = QualifiedTypeAST::PatchIn;
|
|
} break;
|
|
|
|
#line 1815 "./glsl.g"
|
|
|
|
case 150: {
|
|
sym(1).qualifier = QualifiedTypeAST::PatchOut;
|
|
} break;
|
|
|
|
#line 1822 "./glsl.g"
|
|
|
|
case 151: {
|
|
sym(1).qualifier = QualifiedTypeAST::SampleIn;
|
|
} break;
|
|
|
|
#line 1829 "./glsl.g"
|
|
|
|
case 152: {
|
|
sym(1).qualifier = QualifiedTypeAST::SampleOut;
|
|
} break;
|
|
|
|
#line 1836 "./glsl.g"
|
|
|
|
case 153: {
|
|
sym(1).qualifier = QualifiedTypeAST::Uniform;
|
|
} break;
|
|
|
|
#line 1843 "./glsl.g"
|
|
|
|
case 154: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1850 "./glsl.g"
|
|
|
|
case 155: {
|
|
if (!type(2)->setPrecision(sym(1).precision)) {
|
|
// TODO: issue an error about precision not allowed on this type.
|
|
}
|
|
ast(1) = type(2);
|
|
} break;
|
|
|
|
#line 1860 "./glsl.g"
|
|
|
|
case 156: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 1867 "./glsl.g"
|
|
|
|
case 157: {
|
|
ast(1) = makeAstNode<ArrayTypeAST>(type(1));
|
|
} break;
|
|
|
|
#line 1874 "./glsl.g"
|
|
|
|
case 158: {
|
|
ast(1) = makeAstNode<ArrayTypeAST>(type(1), expression(3));
|
|
} break;
|
|
|
|
#line 1881 "./glsl.g"
|
|
|
|
case 159: {
|
|
ast(1) = makeBasicType(T_VOID);
|
|
} break;
|
|
|
|
#line 1888 "./glsl.g"
|
|
|
|
case 160: {
|
|
ast(1) = makeBasicType(T_FLOAT);
|
|
} break;
|
|
|
|
#line 1895 "./glsl.g"
|
|
|
|
case 161: {
|
|
ast(1) = makeBasicType(T_DOUBLE);
|
|
} break;
|
|
|
|
#line 1902 "./glsl.g"
|
|
|
|
case 162: {
|
|
ast(1) = makeBasicType(T_INT);
|
|
} break;
|
|
|
|
#line 1909 "./glsl.g"
|
|
|
|
case 163: {
|
|
ast(1) = makeBasicType(T_UINT);
|
|
} break;
|
|
|
|
#line 1916 "./glsl.g"
|
|
|
|
case 164: {
|
|
ast(1) = makeBasicType(T_BOOL);
|
|
} break;
|
|
|
|
#line 1923 "./glsl.g"
|
|
|
|
case 165: {
|
|
ast(1) = makeBasicType(T_VEC2);
|
|
} break;
|
|
|
|
#line 1930 "./glsl.g"
|
|
|
|
case 166: {
|
|
ast(1) = makeBasicType(T_VEC3);
|
|
} break;
|
|
|
|
#line 1937 "./glsl.g"
|
|
|
|
case 167: {
|
|
ast(1) = makeBasicType(T_VEC4);
|
|
} break;
|
|
|
|
#line 1944 "./glsl.g"
|
|
|
|
case 168: {
|
|
ast(1) = makeBasicType(T_DVEC2);
|
|
} break;
|
|
|
|
#line 1951 "./glsl.g"
|
|
|
|
case 169: {
|
|
ast(1) = makeBasicType(T_DVEC3);
|
|
} break;
|
|
|
|
#line 1958 "./glsl.g"
|
|
|
|
case 170: {
|
|
ast(1) = makeBasicType(T_DVEC4);
|
|
} break;
|
|
|
|
#line 1965 "./glsl.g"
|
|
|
|
case 171: {
|
|
ast(1) = makeBasicType(T_BVEC2);
|
|
} break;
|
|
|
|
#line 1972 "./glsl.g"
|
|
|
|
case 172: {
|
|
ast(1) = makeBasicType(T_BVEC3);
|
|
} break;
|
|
|
|
#line 1979 "./glsl.g"
|
|
|
|
case 173: {
|
|
ast(1) = makeBasicType(T_BVEC4);
|
|
} break;
|
|
|
|
#line 1986 "./glsl.g"
|
|
|
|
case 174: {
|
|
ast(1) = makeBasicType(T_IVEC2);
|
|
} break;
|
|
|
|
#line 1993 "./glsl.g"
|
|
|
|
case 175: {
|
|
ast(1) = makeBasicType(T_IVEC3);
|
|
} break;
|
|
|
|
#line 2000 "./glsl.g"
|
|
|
|
case 176: {
|
|
ast(1) = makeBasicType(T_IVEC4);
|
|
} break;
|
|
|
|
#line 2007 "./glsl.g"
|
|
|
|
case 177: {
|
|
ast(1) = makeBasicType(T_UVEC2);
|
|
} break;
|
|
|
|
#line 2014 "./glsl.g"
|
|
|
|
case 178: {
|
|
ast(1) = makeBasicType(T_UVEC3);
|
|
} break;
|
|
|
|
#line 2021 "./glsl.g"
|
|
|
|
case 179: {
|
|
ast(1) = makeBasicType(T_UVEC4);
|
|
} break;
|
|
|
|
#line 2028 "./glsl.g"
|
|
|
|
case 180: {
|
|
ast(1) = makeBasicType(T_MAT2);
|
|
} break;
|
|
|
|
#line 2035 "./glsl.g"
|
|
|
|
case 181: {
|
|
ast(1) = makeBasicType(T_MAT3);
|
|
} break;
|
|
|
|
#line 2042 "./glsl.g"
|
|
|
|
case 182: {
|
|
ast(1) = makeBasicType(T_MAT4);
|
|
} break;
|
|
|
|
#line 2049 "./glsl.g"
|
|
|
|
case 183: {
|
|
ast(1) = makeBasicType(T_MAT2);
|
|
} break;
|
|
|
|
#line 2056 "./glsl.g"
|
|
|
|
case 184: {
|
|
ast(1) = makeBasicType(T_MAT2X3);
|
|
} break;
|
|
|
|
#line 2063 "./glsl.g"
|
|
|
|
case 185: {
|
|
ast(1) = makeBasicType(T_MAT2X4);
|
|
} break;
|
|
|
|
#line 2070 "./glsl.g"
|
|
|
|
case 186: {
|
|
ast(1) = makeBasicType(T_MAT3X2);
|
|
} break;
|
|
|
|
#line 2077 "./glsl.g"
|
|
|
|
case 187: {
|
|
ast(1) = makeBasicType(T_MAT3);
|
|
} break;
|
|
|
|
#line 2084 "./glsl.g"
|
|
|
|
case 188: {
|
|
ast(1) = makeBasicType(T_MAT3X4);
|
|
} break;
|
|
|
|
#line 2091 "./glsl.g"
|
|
|
|
case 189: {
|
|
ast(1) = makeBasicType(T_MAT4X2);
|
|
} break;
|
|
|
|
#line 2098 "./glsl.g"
|
|
|
|
case 190: {
|
|
ast(1) = makeBasicType(T_MAT4X3);
|
|
} break;
|
|
|
|
#line 2105 "./glsl.g"
|
|
|
|
case 191: {
|
|
ast(1) = makeBasicType(T_MAT4);
|
|
} break;
|
|
|
|
#line 2112 "./glsl.g"
|
|
|
|
case 192: {
|
|
ast(1) = makeBasicType(T_DMAT2);
|
|
} break;
|
|
|
|
#line 2119 "./glsl.g"
|
|
|
|
case 193: {
|
|
ast(1) = makeBasicType(T_DMAT3);
|
|
} break;
|
|
|
|
#line 2126 "./glsl.g"
|
|
|
|
case 194: {
|
|
ast(1) = makeBasicType(T_DMAT4);
|
|
} break;
|
|
|
|
#line 2133 "./glsl.g"
|
|
|
|
case 195: {
|
|
ast(1) = makeBasicType(T_DMAT2);
|
|
} break;
|
|
|
|
#line 2140 "./glsl.g"
|
|
|
|
case 196: {
|
|
ast(1) = makeBasicType(T_DMAT2X3);
|
|
} break;
|
|
|
|
#line 2147 "./glsl.g"
|
|
|
|
case 197: {
|
|
ast(1) = makeBasicType(T_DMAT2X4);
|
|
} break;
|
|
|
|
#line 2154 "./glsl.g"
|
|
|
|
case 198: {
|
|
ast(1) = makeBasicType(T_DMAT3X2);
|
|
} break;
|
|
|
|
#line 2161 "./glsl.g"
|
|
|
|
case 199: {
|
|
ast(1) = makeBasicType(T_DMAT3);
|
|
} break;
|
|
|
|
#line 2168 "./glsl.g"
|
|
|
|
case 200: {
|
|
ast(1) = makeBasicType(T_DMAT3X4);
|
|
} break;
|
|
|
|
#line 2175 "./glsl.g"
|
|
|
|
case 201: {
|
|
ast(1) = makeBasicType(T_DMAT4X2);
|
|
} break;
|
|
|
|
#line 2182 "./glsl.g"
|
|
|
|
case 202: {
|
|
ast(1) = makeBasicType(T_DMAT4X3);
|
|
} break;
|
|
|
|
#line 2189 "./glsl.g"
|
|
|
|
case 203: {
|
|
ast(1) = makeBasicType(T_DMAT4);
|
|
} break;
|
|
|
|
#line 2196 "./glsl.g"
|
|
|
|
case 204: {
|
|
ast(1) = makeBasicType(T_SAMPLER1D);
|
|
} break;
|
|
|
|
#line 2203 "./glsl.g"
|
|
|
|
case 205: {
|
|
ast(1) = makeBasicType(T_SAMPLER2D);
|
|
} break;
|
|
|
|
#line 2210 "./glsl.g"
|
|
|
|
case 206: {
|
|
ast(1) = makeBasicType(T_SAMPLER3D);
|
|
} break;
|
|
|
|
#line 2217 "./glsl.g"
|
|
|
|
case 207: {
|
|
ast(1) = makeBasicType(T_SAMPLERCUBE);
|
|
} break;
|
|
|
|
#line 2224 "./glsl.g"
|
|
|
|
case 208: {
|
|
ast(1) = makeBasicType(T_SAMPLER1DSHADOW);
|
|
} break;
|
|
|
|
#line 2231 "./glsl.g"
|
|
|
|
case 209: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DSHADOW);
|
|
} break;
|
|
|
|
#line 2238 "./glsl.g"
|
|
|
|
case 210: {
|
|
ast(1) = makeBasicType(T_SAMPLERCUBESHADOW);
|
|
} break;
|
|
|
|
#line 2245 "./glsl.g"
|
|
|
|
case 211: {
|
|
ast(1) = makeBasicType(T_SAMPLER1DARRAY);
|
|
} break;
|
|
|
|
#line 2252 "./glsl.g"
|
|
|
|
case 212: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DARRAY);
|
|
} break;
|
|
|
|
#line 2259 "./glsl.g"
|
|
|
|
case 213: {
|
|
ast(1) = makeBasicType(T_SAMPLER1DARRAYSHADOW);
|
|
} break;
|
|
|
|
#line 2266 "./glsl.g"
|
|
|
|
case 214: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DARRAYSHADOW);
|
|
} break;
|
|
|
|
#line 2273 "./glsl.g"
|
|
|
|
case 215: {
|
|
ast(1) = makeBasicType(T_SAMPLERCUBEARRAY);
|
|
} break;
|
|
|
|
#line 2280 "./glsl.g"
|
|
|
|
case 216: {
|
|
ast(1) = makeBasicType(T_SAMPLERCUBEARRAYSHADOW);
|
|
} break;
|
|
|
|
#line 2287 "./glsl.g"
|
|
|
|
case 217: {
|
|
ast(1) = makeBasicType(T_ISAMPLER1D);
|
|
} break;
|
|
|
|
#line 2294 "./glsl.g"
|
|
|
|
case 218: {
|
|
ast(1) = makeBasicType(T_ISAMPLER2D);
|
|
} break;
|
|
|
|
#line 2301 "./glsl.g"
|
|
|
|
case 219: {
|
|
ast(1) = makeBasicType(T_ISAMPLER3D);
|
|
} break;
|
|
|
|
#line 2308 "./glsl.g"
|
|
|
|
case 220: {
|
|
ast(1) = makeBasicType(T_ISAMPLERCUBE);
|
|
} break;
|
|
|
|
#line 2315 "./glsl.g"
|
|
|
|
case 221: {
|
|
ast(1) = makeBasicType(T_ISAMPLER1DARRAY);
|
|
} break;
|
|
|
|
#line 2322 "./glsl.g"
|
|
|
|
case 222: {
|
|
ast(1) = makeBasicType(T_ISAMPLER2DARRAY);
|
|
} break;
|
|
|
|
#line 2329 "./glsl.g"
|
|
|
|
case 223: {
|
|
ast(1) = makeBasicType(T_ISAMPLERCUBEARRAY);
|
|
} break;
|
|
|
|
#line 2336 "./glsl.g"
|
|
|
|
case 224: {
|
|
ast(1) = makeBasicType(T_USAMPLER1D);
|
|
} break;
|
|
|
|
#line 2343 "./glsl.g"
|
|
|
|
case 225: {
|
|
ast(1) = makeBasicType(T_USAMPLER2D);
|
|
} break;
|
|
|
|
#line 2350 "./glsl.g"
|
|
|
|
case 226: {
|
|
ast(1) = makeBasicType(T_USAMPLER3D);
|
|
} break;
|
|
|
|
#line 2357 "./glsl.g"
|
|
|
|
case 227: {
|
|
ast(1) = makeBasicType(T_USAMPLERCUBE);
|
|
} break;
|
|
|
|
#line 2364 "./glsl.g"
|
|
|
|
case 228: {
|
|
ast(1) = makeBasicType(T_USAMPLER1DARRAY);
|
|
} break;
|
|
|
|
#line 2371 "./glsl.g"
|
|
|
|
case 229: {
|
|
ast(1) = makeBasicType(T_USAMPLER2DARRAY);
|
|
} break;
|
|
|
|
#line 2378 "./glsl.g"
|
|
|
|
case 230: {
|
|
ast(1) = makeBasicType(T_USAMPLERCUBEARRAY);
|
|
} break;
|
|
|
|
#line 2385 "./glsl.g"
|
|
|
|
case 231: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DRECT);
|
|
} break;
|
|
|
|
#line 2392 "./glsl.g"
|
|
|
|
case 232: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DRECTSHADOW);
|
|
} break;
|
|
|
|
#line 2399 "./glsl.g"
|
|
|
|
case 233: {
|
|
ast(1) = makeBasicType(T_ISAMPLER2DRECT);
|
|
} break;
|
|
|
|
#line 2406 "./glsl.g"
|
|
|
|
case 234: {
|
|
ast(1) = makeBasicType(T_USAMPLER2DRECT);
|
|
} break;
|
|
|
|
#line 2413 "./glsl.g"
|
|
|
|
case 235: {
|
|
ast(1) = makeBasicType(T_SAMPLERBUFFER);
|
|
} break;
|
|
|
|
#line 2420 "./glsl.g"
|
|
|
|
case 236: {
|
|
ast(1) = makeBasicType(T_ISAMPLERBUFFER);
|
|
} break;
|
|
|
|
#line 2427 "./glsl.g"
|
|
|
|
case 237: {
|
|
ast(1) = makeBasicType(T_USAMPLERBUFFER);
|
|
} break;
|
|
|
|
#line 2434 "./glsl.g"
|
|
|
|
case 238: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DMS);
|
|
} break;
|
|
|
|
#line 2441 "./glsl.g"
|
|
|
|
case 239: {
|
|
ast(1) = makeBasicType(T_ISAMPLER2DMS);
|
|
} break;
|
|
|
|
#line 2448 "./glsl.g"
|
|
|
|
case 240: {
|
|
ast(1) = makeBasicType(T_USAMPLER2DMS);
|
|
} break;
|
|
|
|
#line 2455 "./glsl.g"
|
|
|
|
case 241: {
|
|
ast(1) = makeBasicType(T_SAMPLER2DMSARRAY);
|
|
} break;
|
|
|
|
#line 2462 "./glsl.g"
|
|
|
|
case 242: {
|
|
ast(1) = makeBasicType(T_ISAMPLER2DMSARRAY);
|
|
} break;
|
|
|
|
#line 2469 "./glsl.g"
|
|
|
|
case 243: {
|
|
ast(1) = makeBasicType(T_USAMPLER2DMSARRAY);
|
|
} break;
|
|
|
|
#line 2476 "./glsl.g"
|
|
|
|
case 244: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2483 "./glsl.g"
|
|
|
|
case 245: {
|
|
ast(1) = makeAstNode<NamedTypeAST>(string(1));
|
|
} break;
|
|
|
|
#line 2490 "./glsl.g"
|
|
|
|
case 246: {
|
|
sym(1).precision = TypeAST::Highp;
|
|
} break;
|
|
|
|
#line 2497 "./glsl.g"
|
|
|
|
case 247: {
|
|
sym(1).precision = TypeAST::Mediump;
|
|
} break;
|
|
|
|
#line 2504 "./glsl.g"
|
|
|
|
case 248: {
|
|
sym(1).precision = TypeAST::Lowp;
|
|
} break;
|
|
|
|
#line 2511 "./glsl.g"
|
|
|
|
case 249: {
|
|
ast(1) = makeAstNode<StructTypeAST>(string(2), sym(4).field_list);
|
|
} break;
|
|
|
|
#line 2518 "./glsl.g"
|
|
|
|
case 250: {
|
|
ast(1) = makeAstNode<StructTypeAST>(sym(3).field_list);
|
|
} break;
|
|
|
|
#line 2525 "./glsl.g"
|
|
|
|
case 251: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2532 "./glsl.g"
|
|
|
|
case 252: {
|
|
sym(1).field_list = appendLists(sym(1).field_list, sym(2).field_list);
|
|
} break;
|
|
|
|
#line 2539 "./glsl.g"
|
|
|
|
case 253: {
|
|
sym(1).field_list = StructTypeAST::fixInnerTypes(type(1), sym(2).field_list);
|
|
} break;
|
|
|
|
#line 2546 "./glsl.g"
|
|
|
|
case 254: {
|
|
sym(1).field_list = StructTypeAST::fixInnerTypes
|
|
(makeAstNode<QualifiedTypeAST>
|
|
(sym(1).type_qualifier.qualifier, type(2),
|
|
sym(1).type_qualifier.layout_list), sym(3).field_list);
|
|
} break;
|
|
|
|
#line 2556 "./glsl.g"
|
|
|
|
case 255: {
|
|
// nothing to do.
|
|
sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field);
|
|
} break;
|
|
|
|
#line 2564 "./glsl.g"
|
|
|
|
case 256: {
|
|
sym(1).field_list = makeAstNode< List<StructTypeAST::Field *> >(sym(1).field_list, sym(3).field);
|
|
} break;
|
|
|
|
#line 2571 "./glsl.g"
|
|
|
|
case 257: {
|
|
sym(1).field = makeAstNode<StructTypeAST::Field>(string(1));
|
|
} break;
|
|
|
|
#line 2578 "./glsl.g"
|
|
|
|
case 258: {
|
|
sym(1).field = makeAstNode<StructTypeAST::Field>
|
|
(string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0));
|
|
} break;
|
|
|
|
#line 2586 "./glsl.g"
|
|
|
|
case 259: {
|
|
sym(1).field = makeAstNode<StructTypeAST::Field>
|
|
(string(1), makeAstNode<ArrayTypeAST>((TypeAST *)0, expression(3)));
|
|
} break;
|
|
|
|
#line 2594 "./glsl.g"
|
|
|
|
case 260: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2601 "./glsl.g"
|
|
|
|
case 261: {
|
|
ast(1) = makeAstNode<DeclarationStatementAST>(sym(1).declaration);
|
|
} break;
|
|
|
|
#line 2608 "./glsl.g"
|
|
|
|
case 262: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2615 "./glsl.g"
|
|
|
|
case 263: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2622 "./glsl.g"
|
|
|
|
case 264: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2629 "./glsl.g"
|
|
|
|
case 265: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2636 "./glsl.g"
|
|
|
|
case 266: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2643 "./glsl.g"
|
|
|
|
case 267: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2650 "./glsl.g"
|
|
|
|
case 268: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2657 "./glsl.g"
|
|
|
|
case 269: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2664 "./glsl.g"
|
|
|
|
case 270: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2671 "./glsl.g"
|
|
|
|
case 271: {
|
|
CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>();
|
|
stmt->start = tokenAt(location(1)).begin();
|
|
stmt->end = tokenAt(location(2)).end();
|
|
ast(1) = stmt;
|
|
} break;
|
|
|
|
#line 2681 "./glsl.g"
|
|
|
|
case 272: {
|
|
CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list);
|
|
stmt->start = tokenAt(location(1)).begin();
|
|
stmt->end = tokenAt(location(3)).end();
|
|
ast(1) = stmt;
|
|
} break;
|
|
|
|
#line 2691 "./glsl.g"
|
|
|
|
case 273: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2698 "./glsl.g"
|
|
|
|
case 274: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2705 "./glsl.g"
|
|
|
|
case 275: {
|
|
CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>();
|
|
stmt->start = tokenAt(location(1)).begin();
|
|
stmt->end = tokenAt(location(2)).end();
|
|
ast(1) = stmt;
|
|
} break;
|
|
|
|
#line 2715 "./glsl.g"
|
|
|
|
case 276: {
|
|
CompoundStatementAST *stmt = makeAstNode<CompoundStatementAST>(sym(2).statement_list);
|
|
stmt->start = tokenAt(location(1)).begin();
|
|
stmt->end = tokenAt(location(3)).end();
|
|
ast(1) = stmt;
|
|
} break;
|
|
|
|
#line 2725 "./glsl.g"
|
|
|
|
case 277: {
|
|
sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement);
|
|
} break;
|
|
|
|
#line 2732 "./glsl.g"
|
|
|
|
case 278: {
|
|
sym(1).statement_list = makeAstNode< List<StatementAST *> >(sym(1).statement_list, sym(2).statement);
|
|
} break;
|
|
|
|
#line 2739 "./glsl.g"
|
|
|
|
case 279: {
|
|
ast(1) = makeAstNode<CompoundStatementAST>(); // Empty statement
|
|
} break;
|
|
|
|
#line 2746 "./glsl.g"
|
|
|
|
case 280: {
|
|
ast(1) = makeAstNode<ExpressionStatementAST>(expression(1));
|
|
} break;
|
|
|
|
#line 2753 "./glsl.g"
|
|
|
|
case 281: {
|
|
ast(1) = makeAstNode<IfStatementAST>(expression(3), sym(5).ifstmt.thenClause, sym(5).ifstmt.elseClause);
|
|
} break;
|
|
|
|
#line 2760 "./glsl.g"
|
|
|
|
case 282: {
|
|
sym(1).ifstmt.thenClause = statement(1);
|
|
sym(1).ifstmt.elseClause = statement(3);
|
|
} break;
|
|
|
|
#line 2768 "./glsl.g"
|
|
|
|
case 283: {
|
|
sym(1).ifstmt.thenClause = statement(1);
|
|
sym(1).ifstmt.elseClause = 0;
|
|
} break;
|
|
|
|
#line 2776 "./glsl.g"
|
|
|
|
case 284: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2783 "./glsl.g"
|
|
|
|
case 285: {
|
|
ast(1) = makeAstNode<DeclarationExpressionAST>
|
|
(type(1), string(2), expression(4));
|
|
} break;
|
|
|
|
#line 2791 "./glsl.g"
|
|
|
|
case 286: {
|
|
ast(1) = makeAstNode<SwitchStatementAST>(expression(3), statement(6));
|
|
} break;
|
|
|
|
#line 2798 "./glsl.g"
|
|
|
|
case 287: {
|
|
ast(1) = makeAstNode<CompoundStatementAST>();
|
|
} break;
|
|
|
|
#line 2805 "./glsl.g"
|
|
|
|
case 288: {
|
|
ast(1) = makeAstNode<CompoundStatementAST>(sym(1).statement_list);
|
|
} break;
|
|
|
|
#line 2812 "./glsl.g"
|
|
|
|
case 289: {
|
|
ast(1) = makeAstNode<CaseLabelStatementAST>(expression(2));
|
|
} break;
|
|
|
|
#line 2819 "./glsl.g"
|
|
|
|
case 290: {
|
|
ast(1) = makeAstNode<CaseLabelStatementAST>();
|
|
} break;
|
|
|
|
#line 2826 "./glsl.g"
|
|
|
|
case 291: {
|
|
ast(1) = makeAstNode<WhileStatementAST>(expression(3), statement(5));
|
|
} break;
|
|
|
|
#line 2833 "./glsl.g"
|
|
|
|
case 292: {
|
|
ast(1) = makeAstNode<DoStatementAST>(statement(2), expression(5));
|
|
} break;
|
|
|
|
#line 2840 "./glsl.g"
|
|
|
|
case 293: {
|
|
ast(1) = makeAstNode<ForStatementAST>(statement(3), sym(4).forstmt.condition, sym(4).forstmt.increment, statement(6));
|
|
} break;
|
|
|
|
#line 2847 "./glsl.g"
|
|
|
|
case 294: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2854 "./glsl.g"
|
|
|
|
case 295: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2861 "./glsl.g"
|
|
|
|
case 296: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2868 "./glsl.g"
|
|
|
|
case 297: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2875 "./glsl.g"
|
|
|
|
case 298: {
|
|
sym(1).forstmt.condition = expression(1);
|
|
sym(1).forstmt.increment = 0;
|
|
} break;
|
|
|
|
#line 2883 "./glsl.g"
|
|
|
|
case 299: {
|
|
sym(1).forstmt.condition = expression(1);
|
|
sym(1).forstmt.increment = expression(3);
|
|
} break;
|
|
|
|
#line 2891 "./glsl.g"
|
|
|
|
case 300: {
|
|
ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Continue);
|
|
} break;
|
|
|
|
#line 2898 "./glsl.g"
|
|
|
|
case 301: {
|
|
ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Break);
|
|
} break;
|
|
|
|
#line 2905 "./glsl.g"
|
|
|
|
case 302: {
|
|
ast(1) = makeAstNode<ReturnStatementAST>();
|
|
} break;
|
|
|
|
#line 2912 "./glsl.g"
|
|
|
|
case 303: {
|
|
ast(1) = makeAstNode<ReturnStatementAST>(expression(2));
|
|
} break;
|
|
|
|
#line 2919 "./glsl.g"
|
|
|
|
case 304: {
|
|
ast(1) = makeAstNode<JumpStatementAST>(AST::Kind_Discard);
|
|
} break;
|
|
|
|
#line 2926 "./glsl.g"
|
|
|
|
case 305: {
|
|
ast(1) = makeAstNode<TranslationUnitAST>(sym(1).declaration_list);
|
|
} break;
|
|
|
|
#line 2933 "./glsl.g"
|
|
|
|
case 306: {
|
|
if (sym(1).declaration) {
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration);
|
|
} else {
|
|
sym(1).declaration_list = 0;
|
|
}
|
|
} break;
|
|
|
|
#line 2945 "./glsl.g"
|
|
|
|
case 307: {
|
|
if (sym(1).declaration_list && sym(2).declaration) {
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(1).declaration_list, sym(2).declaration);
|
|
} else if (!sym(1).declaration_list) {
|
|
if (sym(2).declaration) {
|
|
sym(1).declaration_list = makeAstNode< List<DeclarationAST *> >
|
|
(sym(2).declaration);
|
|
} else {
|
|
sym(1).declaration_list = 0;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
#line 2962 "./glsl.g"
|
|
|
|
case 308: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2969 "./glsl.g"
|
|
|
|
case 309: {
|
|
// nothing to do.
|
|
} break;
|
|
|
|
#line 2976 "./glsl.g"
|
|
|
|
case 310: {
|
|
ast(1) = 0;
|
|
} break;
|
|
|
|
#line 2983 "./glsl.g"
|
|
|
|
case 311: {
|
|
function(1)->body = statement(2);
|
|
} break;
|
|
|
|
#line 2990 "./glsl.g"
|
|
|
|
case 312: {
|
|
ast(1) = 0;
|
|
} break;
|
|
|
|
#line 2998 "./glsl.g"
|
|
|
|
case 313: {
|
|
ast(1) = ast(2);
|
|
} break;
|
|
|
|
#line 3005 "./glsl.g"
|
|
|
|
case 314: {
|
|
ast(1) = ast(2);
|
|
} break;
|
|
|
|
#line 3011 "./glsl.g"
|
|
|
|
} // end switch
|
|
} // end Parser::reduce()
|