blob: e2959d7d7a903932cdbf47285ca8ab3fad6a7762 [file] [log] [blame]
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001//
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04002// Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00003// Use of this source code is governed by a BSD-style license that can be
4// found in the LICENSE file.
5//
6
Jamie Madill6b9cb252013-10-17 10:45:47 -04007#include "compiler/translator/ParseContext.h"
daniel@transgaming.combbf56f72010-04-20 18:52:13 +00008
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00009#include <stdarg.h>
apatrick@chromium.org8187fa82010-06-15 22:09:28 +000010#include <stdio.h>
daniel@transgaming.combbf56f72010-04-20 18:52:13 +000011
Geoff Lang17732822013-08-29 13:46:49 -040012#include "compiler/translator/glslang.h"
daniel@transgaming.comb401a922012-10-26 18:58:24 +000013#include "compiler/preprocessor/SourceLocation.h"
daniel@transgaming.combbf56f72010-04-20 18:52:13 +000014
alokp@chromium.org8b851c62012-06-15 16:25:11 +000015///////////////////////////////////////////////////////////////////////
16//
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +000017// Sub- vector and matrix fields
18//
19////////////////////////////////////////////////////////////////////////
20
21//
22// Look at a '.' field selector string and change it into offsets
23// for a vector.
24//
Jamie Madill075edd82013-07-08 13:30:19 -040025bool TParseContext::parseVectorFields(const TString& compString, int vecSize, TVectorFields& fields, const TSourceLoc& line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +000026{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000027 fields.num = (int) compString.size();
28 if (fields.num > 4) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +000029 error(line, "illegal vector field selection", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000030 return false;
31 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +000032
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000033 enum {
34 exyzw,
35 ergba,
daniel@transgaming.comb3077d02013-01-11 04:12:09 +000036 estpq
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000037 } fieldSet[4];
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +000038
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000039 for (int i = 0; i < fields.num; ++i) {
40 switch (compString[i]) {
41 case 'x':
42 fields.offsets[i] = 0;
43 fieldSet[i] = exyzw;
44 break;
45 case 'r':
46 fields.offsets[i] = 0;
47 fieldSet[i] = ergba;
48 break;
49 case 's':
50 fields.offsets[i] = 0;
51 fieldSet[i] = estpq;
52 break;
53 case 'y':
54 fields.offsets[i] = 1;
55 fieldSet[i] = exyzw;
56 break;
57 case 'g':
58 fields.offsets[i] = 1;
59 fieldSet[i] = ergba;
60 break;
61 case 't':
62 fields.offsets[i] = 1;
63 fieldSet[i] = estpq;
64 break;
65 case 'z':
66 fields.offsets[i] = 2;
67 fieldSet[i] = exyzw;
68 break;
69 case 'b':
70 fields.offsets[i] = 2;
71 fieldSet[i] = ergba;
72 break;
73 case 'p':
74 fields.offsets[i] = 2;
75 fieldSet[i] = estpq;
76 break;
77
78 case 'w':
79 fields.offsets[i] = 3;
80 fieldSet[i] = exyzw;
81 break;
82 case 'a':
83 fields.offsets[i] = 3;
84 fieldSet[i] = ergba;
85 break;
86 case 'q':
87 fields.offsets[i] = 3;
88 fieldSet[i] = estpq;
89 break;
90 default:
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +000091 error(line, "illegal vector field selection", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000092 return false;
93 }
94 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +000095
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000096 for (int i = 0; i < fields.num; ++i) {
97 if (fields.offsets[i] >= vecSize) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +000098 error(line, "vector field selection out of range", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +000099 return false;
100 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000101
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000102 if (i > 0) {
103 if (fieldSet[i] != fieldSet[i-1]) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000104 error(line, "illegal - vector component fields not from the same set", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000105 return false;
106 }
107 }
108 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000109
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000110 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000111}
112
113
114//
115// Look at a '.' field selector string and change it into offsets
116// for a matrix.
117//
Jamie Madill075edd82013-07-08 13:30:19 -0400118bool TParseContext::parseMatrixFields(const TString& compString, int matCols, int matRows, TMatrixFields& fields, const TSourceLoc& line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000119{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000120 fields.wholeRow = false;
121 fields.wholeCol = false;
122 fields.row = -1;
123 fields.col = -1;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000124
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000125 if (compString.size() != 2) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000126 error(line, "illegal length of matrix field selection", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000127 return false;
128 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000129
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000130 if (compString[0] == '_') {
131 if (compString[1] < '0' || compString[1] > '3') {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000132 error(line, "illegal matrix field selection", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000133 return false;
134 }
135 fields.wholeCol = true;
136 fields.col = compString[1] - '0';
137 } else if (compString[1] == '_') {
138 if (compString[0] < '0' || compString[0] > '3') {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000139 error(line, "illegal matrix field selection", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000140 return false;
141 }
142 fields.wholeRow = true;
143 fields.row = compString[0] - '0';
144 } else {
145 if (compString[0] < '0' || compString[0] > '3' ||
146 compString[1] < '0' || compString[1] > '3') {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000147 error(line, "illegal matrix field selection", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000148 return false;
149 }
150 fields.row = compString[0] - '0';
151 fields.col = compString[1] - '0';
152 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000153
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +0000154 if (fields.row >= matRows || fields.col >= matCols) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000155 error(line, "matrix field selection out of range", compString.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000156 return false;
157 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000158
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000159 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000160}
161
162///////////////////////////////////////////////////////////////////////
163//
164// Errors
165//
166////////////////////////////////////////////////////////////////////////
167
168//
169// Track whether errors have occurred.
170//
171void TParseContext::recover()
172{
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000173}
174
175//
176// Used by flex/bison to output all syntax and parsing errors.
177//
Jamie Madill075edd82013-07-08 13:30:19 -0400178void TParseContext::error(const TSourceLoc& loc,
alokp@chromium.org044a5cf2010-11-12 15:42:16 +0000179 const char* reason, const char* token,
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000180 const char* extraInfo)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000181{
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000182 pp::SourceLocation srcLoc;
Jamie Madill075edd82013-07-08 13:30:19 -0400183 srcLoc.file = loc.first_file;
184 srcLoc.line = loc.first_line;
Shannon Woods7f2d7942013-11-19 15:07:58 -0500185 diagnostics.writeInfo(pp::Diagnostics::PP_ERROR,
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000186 srcLoc, reason, token, extraInfo);
alokp@chromium.orgff42c632010-05-10 15:14:30 +0000187
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000188}
189
Jamie Madill075edd82013-07-08 13:30:19 -0400190void TParseContext::warning(const TSourceLoc& loc,
alokp@chromium.org044a5cf2010-11-12 15:42:16 +0000191 const char* reason, const char* token,
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000192 const char* extraInfo) {
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000193 pp::SourceLocation srcLoc;
Jamie Madill075edd82013-07-08 13:30:19 -0400194 srcLoc.file = loc.first_file;
195 srcLoc.line = loc.first_line;
Shannon Woods7f2d7942013-11-19 15:07:58 -0500196 diagnostics.writeInfo(pp::Diagnostics::PP_WARNING,
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000197 srcLoc, reason, token, extraInfo);
alokp@chromium.org044a5cf2010-11-12 15:42:16 +0000198}
199
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000200void TParseContext::trace(const char* str)
201{
202 diagnostics.writeDebug(str);
203}
204
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000205//
206// Same error message for all places assignments don't work.
207//
Jamie Madill075edd82013-07-08 13:30:19 -0400208void TParseContext::assignError(const TSourceLoc& line, const char* op, TString left, TString right)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000209{
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000210 std::stringstream extraInfoStream;
211 extraInfoStream << "cannot convert from '" << right << "' to '" << left << "'";
212 std::string extraInfo = extraInfoStream.str();
213 error(line, "", op, extraInfo.c_str());
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000214}
215
216//
217// Same error message for all places unary operations don't work.
218//
Jamie Madill075edd82013-07-08 13:30:19 -0400219void TParseContext::unaryOpError(const TSourceLoc& line, const char* op, TString operand)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000220{
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000221 std::stringstream extraInfoStream;
222 extraInfoStream << "no operation '" << op << "' exists that takes an operand of type " << operand
223 << " (or there is no acceptable conversion)";
224 std::string extraInfo = extraInfoStream.str();
225 error(line, " wrong operand type", op, extraInfo.c_str());
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000226}
227
228//
229// Same error message for all binary operations don't work.
230//
Jamie Madill075edd82013-07-08 13:30:19 -0400231void TParseContext::binaryOpError(const TSourceLoc& line, const char* op, TString left, TString right)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000232{
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000233 std::stringstream extraInfoStream;
234 extraInfoStream << "no operation '" << op << "' exists that takes a left-hand operand of type '" << left
235 << "' and a right operand of type '" << right << "' (or there is no acceptable conversion)";
236 std::string extraInfo = extraInfoStream.str();
237 error(line, " wrong operand types ", op, extraInfo.c_str());
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000238}
239
Jamie Madill075edd82013-07-08 13:30:19 -0400240bool TParseContext::precisionErrorCheck(const TSourceLoc& line, TPrecision precision, TBasicType type){
zmo@google.comdc4b4f82011-06-17 00:42:53 +0000241 if (!checksPrecisionErrors)
242 return false;
daniel@transgaming.coma5d76232010-05-17 09:58:47 +0000243 switch( type ){
244 case EbtFloat:
245 if( precision == EbpUndefined ){
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000246 error( line, "No precision specified for (float)", "" );
daniel@transgaming.coma5d76232010-05-17 09:58:47 +0000247 return true;
248 }
249 break;
250 case EbtInt:
251 if( precision == EbpUndefined ){
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000252 error( line, "No precision specified (int)", "" );
daniel@transgaming.coma5d76232010-05-17 09:58:47 +0000253 return true;
254 }
255 break;
daniel@transgaming.com0eb64c32011-03-15 18:23:51 +0000256 default:
257 return false;
daniel@transgaming.coma5d76232010-05-17 09:58:47 +0000258 }
259 return false;
260}
261
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000262//
263// Both test and if necessary, spit out an error, to see if the node is really
264// an l-value that can be operated on this way.
265//
266// Returns true if the was an error.
267//
Jamie Madill075edd82013-07-08 13:30:19 -0400268bool TParseContext::lValueErrorCheck(const TSourceLoc& line, const char* op, TIntermTyped* node)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000269{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000270 TIntermSymbol* symNode = node->getAsSymbolNode();
271 TIntermBinary* binaryNode = node->getAsBinaryNode();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000272
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000273 if (binaryNode) {
274 bool errorReturn;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000275
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000276 switch(binaryNode->getOp()) {
277 case EOpIndexDirect:
278 case EOpIndexIndirect:
279 case EOpIndexDirectStruct:
shannonwoods@chromium.org4430b0d2013-05-30 00:12:34 +0000280 case EOpIndexDirectInterfaceBlock:
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000281 return lValueErrorCheck(line, op, binaryNode->getLeft());
282 case EOpVectorSwizzle:
283 errorReturn = lValueErrorCheck(line, op, binaryNode->getLeft());
284 if (!errorReturn) {
285 int offset[4] = {0,0,0,0};
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000286
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000287 TIntermTyped* rightNode = binaryNode->getRight();
288 TIntermAggregate *aggrNode = rightNode->getAsAggregate();
Zhenyao Moe40d1e92014-07-16 17:40:36 -0700289
290 for (TIntermSequence::iterator p = aggrNode->getSequence()->begin();
291 p != aggrNode->getSequence()->end(); p++) {
shannon.woods%transgaming.com@gtempaccount.comc0d0c222013-04-13 03:29:36 +0000292 int value = (*p)->getAsTyped()->getAsConstantUnion()->getIConst(0);
Zhenyao Moe40d1e92014-07-16 17:40:36 -0700293 offset[value]++;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000294 if (offset[value] > 1) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000295 error(line, " l-value of swizzle cannot have duplicate components", op);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000296
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000297 return true;
298 }
299 }
Zhenyao Moe40d1e92014-07-16 17:40:36 -0700300 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000301
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000302 return errorReturn;
Zhenyao Moe40d1e92014-07-16 17:40:36 -0700303 default:
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000304 break;
305 }
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000306 error(line, " l-value required", op);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000307
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000308 return true;
309 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000310
311
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000312 const char* symbol = 0;
313 if (symNode != 0)
314 symbol = symNode->getSymbol().c_str();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000315
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000316 const char* message = 0;
317 switch (node->getQualifier()) {
318 case EvqConst: message = "can't modify a const"; break;
319 case EvqConstReadOnly: message = "can't modify a const"; break;
320 case EvqAttribute: message = "can't modify an attribute"; break;
Jamie Madill19571812013-08-12 15:26:34 -0700321 case EvqFragmentIn: message = "can't modify an input"; break;
322 case EvqVertexIn: message = "can't modify an input"; break;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000323 case EvqUniform: message = "can't modify a uniform"; break;
324 case EvqVaryingIn: message = "can't modify a varying"; break;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000325 case EvqFragCoord: message = "can't modify gl_FragCoord"; break;
326 case EvqFrontFacing: message = "can't modify gl_FrontFacing"; break;
327 case EvqPointCoord: message = "can't modify gl_PointCoord"; break;
328 default:
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000329
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000330 //
331 // Type that can't be written to?
332 //
Nicolas Capens344e7142013-06-24 15:39:21 -0400333 if (node->getBasicType() == EbtVoid) {
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000334 message = "can't modify void";
Nicolas Capens344e7142013-06-24 15:39:21 -0400335 }
336 if (IsSampler(node->getBasicType())) {
337 message = "can't modify a sampler";
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000338 }
339 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000340
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000341 if (message == 0 && binaryNode == 0 && symNode == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000342 error(line, " l-value required", op);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000343
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000344 return true;
345 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000346
347
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000348 //
349 // Everything else is okay, no error.
350 //
351 if (message == 0)
352 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000353
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000354 //
355 // If we get here, we have an error and a message.
356 //
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000357 if (symNode) {
358 std::stringstream extraInfoStream;
359 extraInfoStream << "\"" << symbol << "\" (" << message << ")";
360 std::string extraInfo = extraInfoStream.str();
361 error(line, " l-value required", op, extraInfo.c_str());
362 }
363 else {
364 std::stringstream extraInfoStream;
365 extraInfoStream << "(" << message << ")";
366 std::string extraInfo = extraInfoStream.str();
367 error(line, " l-value required", op, extraInfo.c_str());
368 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000369
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000370 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000371}
372
373//
374// Both test, and if necessary spit out an error, to see if the node is really
375// a constant.
376//
377// Returns true if the was an error.
378//
379bool TParseContext::constErrorCheck(TIntermTyped* node)
380{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000381 if (node->getQualifier() == EvqConst)
382 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000383
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000384 error(node->getLine(), "constant expression required", "");
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000385
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000386 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000387}
388
389//
390// Both test, and if necessary spit out an error, to see if the node is really
391// an integer.
392//
393// Returns true if the was an error.
394//
395bool TParseContext::integerErrorCheck(TIntermTyped* node, const char* token)
396{
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +0000397 if (node->isScalarInt())
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000398 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000399
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000400 error(node->getLine(), "integer expression required", token);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000401
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000402 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000403}
404
405//
406// Both test, and if necessary spit out an error, to see if we are currently
407// globally scoped.
408//
409// Returns true if the was an error.
410//
Jamie Madill075edd82013-07-08 13:30:19 -0400411bool TParseContext::globalErrorCheck(const TSourceLoc& line, bool global, const char* token)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000412{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000413 if (global)
414 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000415
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000416 error(line, "only allowed at global scope", token);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000417
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000418 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000419}
420
421//
422// For now, keep it simple: if it starts "gl_", it's reserved, independent
423// of scope. Except, if the symbol table is at the built-in push-level,
424// which is when we are parsing built-ins.
alokp@chromium.org613ef312010-07-21 18:54:22 +0000425// Also checks for "webgl_" and "_webgl_" reserved identifiers if parsing a
426// webgl shader.
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000427//
428// Returns true if there was an error.
429//
Jamie Madill075edd82013-07-08 13:30:19 -0400430bool TParseContext::reservedErrorCheck(const TSourceLoc& line, const TString& identifier)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000431{
alokp@chromium.org613ef312010-07-21 18:54:22 +0000432 static const char* reservedErrMsg = "reserved built-in name";
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000433 if (!symbolTable.atBuiltInLevel()) {
daniel@transgaming.com51db7fb2011-09-20 16:11:06 +0000434 if (identifier.compare(0, 3, "gl_") == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000435 error(line, reservedErrMsg, "gl_");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000436 return true;
437 }
Jamie Madill5508f392014-02-20 13:31:36 -0500438 if (IsWebGLBasedSpec(shaderSpec)) {
daniel@transgaming.com51db7fb2011-09-20 16:11:06 +0000439 if (identifier.compare(0, 6, "webgl_") == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000440 error(line, reservedErrMsg, "webgl_");
alokp@chromium.org613ef312010-07-21 18:54:22 +0000441 return true;
442 }
daniel@transgaming.com51db7fb2011-09-20 16:11:06 +0000443 if (identifier.compare(0, 7, "_webgl_") == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000444 error(line, reservedErrMsg, "_webgl_");
alokp@chromium.org613ef312010-07-21 18:54:22 +0000445 return true;
446 }
maxvujovic@gmail.com430f5e02012-06-08 17:47:59 +0000447 if (shaderSpec == SH_CSS_SHADERS_SPEC && identifier.compare(0, 4, "css_") == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000448 error(line, reservedErrMsg, "css_");
maxvujovic@gmail.com430f5e02012-06-08 17:47:59 +0000449 return true;
450 }
alokp@chromium.org613ef312010-07-21 18:54:22 +0000451 }
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000452 if (identifier.find("__") != TString::npos) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000453 error(line, "identifiers containing two consecutive underscores (__) are reserved as possible future keywords", identifier.c_str());
daniel@transgaming.combeadd5d2012-04-12 02:35:31 +0000454 return true;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000455 }
456 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000457
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000458 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000459}
460
461//
462// Make sure there is enough data provided to the constructor to build
463// something of the type of the constructor. Also returns the type of
464// the constructor.
465//
466// Returns true if there was an error in construction.
467//
Jamie Madill075edd82013-07-08 13:30:19 -0400468bool TParseContext::constructorErrorCheck(const TSourceLoc& line, TIntermNode* node, TFunction& function, TOperator op, TType* type)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000469{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000470 *type = function.getReturnType();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000471
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000472 bool constructingMatrix = false;
473 switch(op) {
474 case EOpConstructMat2:
475 case EOpConstructMat3:
476 case EOpConstructMat4:
477 constructingMatrix = true;
478 break;
479 default:
480 break;
481 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000482
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000483 //
484 // Note: It's okay to have too many components available, but not okay to have unused
485 // arguments. 'full' will go to true when enough args have been seen. If we loop
486 // again, there is an extra argument, so 'overfull' will become true.
487 //
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000488
Jamie Madill94bf7f22013-07-08 13:31:15 -0400489 size_t size = 0;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000490 bool constType = true;
491 bool full = false;
492 bool overFull = false;
493 bool matrixInMatrix = false;
494 bool arrayArg = false;
shannon.woods@transgaming.comd64b3da2013-02-28 23:19:26 +0000495 for (size_t i = 0; i < function.getParamCount(); ++i) {
alokp@chromium.orgb19403a2010-09-08 17:56:26 +0000496 const TParameter& param = function.getParam(i);
497 size += param.type->getObjectSize();
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000498
alokp@chromium.orgb19403a2010-09-08 17:56:26 +0000499 if (constructingMatrix && param.type->isMatrix())
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000500 matrixInMatrix = true;
501 if (full)
502 overFull = true;
503 if (op != EOpConstructStruct && !type->isArray() && size >= type->getObjectSize())
504 full = true;
alokp@chromium.orgb19403a2010-09-08 17:56:26 +0000505 if (param.type->getQualifier() != EvqConst)
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000506 constType = false;
alokp@chromium.orgb19403a2010-09-08 17:56:26 +0000507 if (param.type->isArray())
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000508 arrayArg = true;
509 }
510
511 if (constType)
alokp@chromium.org58e54292010-08-24 21:40:03 +0000512 type->setQualifier(EvqConst);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000513
shannon.woods@transgaming.com18bd2ec2013-02-28 23:19:46 +0000514 if (type->isArray() && static_cast<size_t>(type->getArraySize()) != function.getParamCount()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000515 error(line, "array constructor needs one argument per array element", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000516 return true;
517 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000518
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000519 if (arrayArg && op != EOpConstructStruct) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000520 error(line, "constructing from a non-dereferenced array", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000521 return true;
522 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000523
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000524 if (matrixInMatrix && !type->isArray()) {
daniel@transgaming.combef0b6d2010-04-29 03:32:39 +0000525 if (function.getParamCount() != 1) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000526 error(line, "constructing matrix from matrix can only take one argument", "constructor");
daniel@transgaming.combef0b6d2010-04-29 03:32:39 +0000527 return true;
528 }
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000529 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000530
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000531 if (overFull) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000532 error(line, "too many arguments", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000533 return true;
534 }
535
Brendan Longeaa84062013-12-08 18:26:50 +0100536 if (op == EOpConstructStruct && !type->isArray() && type->getStruct()->fields().size() != function.getParamCount()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000537 error(line, "Number of constructor parameters does not match the number of structure fields", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000538 return true;
539 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000540
daniel@transgaming.com67d72522011-11-29 17:23:51 +0000541 if (!type->isMatrix() || !matrixInMatrix) {
daniel@transgaming.combef0b6d2010-04-29 03:32:39 +0000542 if ((op != EOpConstructStruct && size != 1 && size < type->getObjectSize()) ||
543 (op == EOpConstructStruct && size < type->getObjectSize())) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000544 error(line, "not enough data provided for construction", "constructor");
daniel@transgaming.combef0b6d2010-04-29 03:32:39 +0000545 return true;
546 }
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000547 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000548
daniel@transgaming.com0b53fc02011-03-09 15:12:12 +0000549 TIntermTyped *typed = node ? node->getAsTyped() : 0;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000550 if (typed == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000551 error(line, "constructor argument does not have a type", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000552 return true;
553 }
554 if (op != EOpConstructStruct && IsSampler(typed->getBasicType())) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000555 error(line, "cannot convert a sampler", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000556 return true;
557 }
558 if (typed->getBasicType() == EbtVoid) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000559 error(line, "cannot convert a void", "constructor");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000560 return true;
561 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000562
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000563 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000564}
565
566// This function checks to see if a void variable has been declared and raise an error message for such a case
567//
568// returns true in case of an error
569//
Jamie Madill075edd82013-07-08 13:30:19 -0400570bool TParseContext::voidErrorCheck(const TSourceLoc& line, const TString& identifier, const TPublicType& pubType)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000571{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000572 if (pubType.type == EbtVoid) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000573 error(line, "illegal use of type 'void'", identifier.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000574 return true;
575 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000576
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000577 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000578}
579
580// This function checks to see if the node (for the expression) contains a scalar boolean expression or not
581//
582// returns true in case of an error
583//
Jamie Madill075edd82013-07-08 13:30:19 -0400584bool TParseContext::boolErrorCheck(const TSourceLoc& line, const TIntermTyped* type)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000585{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000586 if (type->getBasicType() != EbtBool || type->isArray() || type->isMatrix() || type->isVector()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000587 error(line, "boolean expression expected", "");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000588 return true;
589 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000590
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000591 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000592}
593
594// This function checks to see if the node (for the expression) contains a scalar boolean expression or not
595//
596// returns true in case of an error
597//
Jamie Madill075edd82013-07-08 13:30:19 -0400598bool TParseContext::boolErrorCheck(const TSourceLoc& line, const TPublicType& pType)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000599{
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +0000600 if (pType.type != EbtBool || pType.isAggregate()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000601 error(line, "boolean expression expected", "");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000602 return true;
603 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000604
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000605 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000606}
607
Jamie Madill075edd82013-07-08 13:30:19 -0400608bool TParseContext::samplerErrorCheck(const TSourceLoc& line, const TPublicType& pType, const char* reason)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000609{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000610 if (pType.type == EbtStruct) {
611 if (containsSampler(*pType.userDef)) {
alokp@chromium.org58e54292010-08-24 21:40:03 +0000612 error(line, reason, getBasicString(pType.type), "(structure contains a sampler)");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000613
614 return true;
615 }
616
617 return false;
618 } else if (IsSampler(pType.type)) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000619 error(line, reason, getBasicString(pType.type));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000620
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000621 return true;
622 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000623
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000624 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000625}
626
Jamie Madill075edd82013-07-08 13:30:19 -0400627bool TParseContext::structQualifierErrorCheck(const TSourceLoc& line, const TPublicType& pType)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000628{
Jamie Madillb120eac2013-06-12 14:08:13 -0400629 switch (pType.qualifier)
630 {
631 case EvqVaryingIn:
632 case EvqVaryingOut:
633 case EvqAttribute:
Jamie Madill19571812013-08-12 15:26:34 -0700634 case EvqVertexIn:
635 case EvqFragmentOut:
Jamie Madillb120eac2013-06-12 14:08:13 -0400636 if (pType.type == EbtStruct)
637 {
638 error(line, "cannot be used with a structure", getQualifierString(pType.qualifier));
639 return true;
640 }
Jamie Madill10567262014-04-17 16:40:00 -0400641
642 default: break;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000643 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000644
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000645 if (pType.qualifier != EvqUniform && samplerErrorCheck(line, pType, "samplers must be uniform"))
646 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000647
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000648 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000649}
650
Jamie Madill075edd82013-07-08 13:30:19 -0400651bool TParseContext::locationDeclaratorListCheck(const TSourceLoc& line, const TPublicType &pType)
Jamie Madill0bd18df2013-06-20 11:55:52 -0400652{
653 if (pType.layoutQualifier.location != -1)
654 {
655 error(line, "location must only be specified for a single input or output variable", "location");
656 return true;
657 }
658
659 return false;
660}
661
Jamie Madill075edd82013-07-08 13:30:19 -0400662bool TParseContext::parameterSamplerErrorCheck(const TSourceLoc& line, TQualifier qualifier, const TType& type)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000663{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000664 if ((qualifier == EvqOut || qualifier == EvqInOut) &&
665 type.getBasicType() != EbtStruct && IsSampler(type.getBasicType())) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000666 error(line, "samplers cannot be output parameters", type.getBasicString());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000667 return true;
668 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000669
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000670 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000671}
672
673bool TParseContext::containsSampler(TType& type)
674{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000675 if (IsSampler(type.getBasicType()))
676 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000677
Jamie Madill98493dd2013-07-08 14:39:03 -0400678 if (type.getBasicType() == EbtStruct || type.isInterfaceBlock()) {
679 const TFieldList& fields = type.getStruct()->fields();
680 for (unsigned int i = 0; i < fields.size(); ++i) {
681 if (containsSampler(*fields[i]->type()))
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000682 return true;
683 }
684 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000685
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000686 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000687}
688
689//
690// Do size checking for an array type's size.
691//
692// Returns true if there was an error.
693//
Jamie Madill075edd82013-07-08 13:30:19 -0400694bool TParseContext::arraySizeErrorCheck(const TSourceLoc& line, TIntermTyped* expr, int& size)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000695{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000696 TIntermConstantUnion* constant = expr->getAsConstantUnion();
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +0000697
698 if (constant == 0 || !constant->isScalarInt())
699 {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000700 error(line, "array size must be a constant integer expression", "");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000701 return true;
702 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000703
Nicolas Capens906744a2014-06-06 15:18:07 -0400704 unsigned int unsignedSize = 0;
705
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +0000706 if (constant->getBasicType() == EbtUInt)
707 {
Nicolas Capens906744a2014-06-06 15:18:07 -0400708 unsignedSize = constant->getUConst(0);
709 size = static_cast<int>(unsignedSize);
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +0000710 }
711 else
712 {
713 size = constant->getIConst(0);
714
Nicolas Capens906744a2014-06-06 15:18:07 -0400715 if (size < 0)
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +0000716 {
Nicolas Capens906744a2014-06-06 15:18:07 -0400717 error(line, "array size must be non-negative", "");
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +0000718 size = 1;
719 return true;
720 }
Nicolas Capens906744a2014-06-06 15:18:07 -0400721
722 unsignedSize = static_cast<unsigned int>(size);
723 }
724
725 if (size == 0)
726 {
727 error(line, "array size must be greater than zero", "");
728 size = 1;
729 return true;
730 }
731
732 // The size of arrays is restricted here to prevent issues further down the
733 // compiler/translator/driver stack. Shader Model 5 generation hardware is limited to
734 // 4096 registers so this should be reasonable even for aggressively optimizable code.
735 const unsigned int sizeLimit = 65536;
736
737 if (unsignedSize > sizeLimit)
738 {
739 error(line, "array size too large", "");
740 size = 1;
741 return true;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000742 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000743
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000744 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000745}
746
747//
748// See if this qualifier can be an array.
749//
750// Returns true if there is an error.
751//
Jamie Madill075edd82013-07-08 13:30:19 -0400752bool TParseContext::arrayQualifierErrorCheck(const TSourceLoc& line, TPublicType type)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000753{
Jamie Madill19571812013-08-12 15:26:34 -0700754 if ((type.qualifier == EvqAttribute) || (type.qualifier == EvqVertexIn) || (type.qualifier == EvqConst)) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000755 error(line, "cannot declare arrays of this qualifier", TType(type).getCompleteString().c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000756 return true;
757 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000758
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000759 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000760}
761
762//
763// See if this type can be an array.
764//
765// Returns true if there is an error.
766//
Jamie Madill075edd82013-07-08 13:30:19 -0400767bool TParseContext::arrayTypeErrorCheck(const TSourceLoc& line, TPublicType type)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000768{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000769 //
770 // Can the type be an array?
771 //
772 if (type.array) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000773 error(line, "cannot declare arrays of arrays", TType(type).getCompleteString().c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000774 return true;
775 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000776
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000777 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000778}
779
780//
781// Do all the semantic checking for declaring an array, with and
782// without a size, and make the right changes to the symbol table.
783//
784// size == 0 means no specified size.
785//
786// Returns true if there was an error.
787//
Jamie Madill075edd82013-07-08 13:30:19 -0400788bool TParseContext::arrayErrorCheck(const TSourceLoc& line, const TString& identifier, const TPublicType &type, TVariable*& variable)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000789{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000790 //
791 // Don't check for reserved word use until after we know it's not in the symbol table,
792 // because reserved arrays can be redeclared.
793 //
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000794
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000795 bool builtIn = false;
796 bool sameScope = false;
shannonwoods@chromium.org96e7ba12013-05-30 00:02:41 +0000797 TSymbol* symbol = symbolTable.find(identifier, 0, &builtIn, &sameScope);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000798 if (symbol == 0 || !sameScope) {
Erik Dahlströmea7a2122014-11-17 16:15:57 +0100799 bool needsReservedErrorCheck = true;
800
801 // gl_LastFragData may be redeclared with a new precision qualifier
802 if (identifier.compare(0, 15, "gl_LastFragData") == 0) {
803 if (type.arraySize == static_cast<const TVariable*>(symbolTable.findBuiltIn("gl_MaxDrawBuffers", shaderVersion))->getConstPointer()->getIConst()) {
804 if (TSymbol* builtInSymbol = symbolTable.findBuiltIn(identifier, shaderVersion)) {
805 needsReservedErrorCheck = extensionErrorCheck(line, builtInSymbol->getExtension());
806 }
807 } else {
808 error(line, "redeclaration of array with size != gl_MaxDrawBuffers", identifier.c_str());
809 return true;
810 }
811 }
812
813 if (needsReservedErrorCheck)
814 if (reservedErrorCheck(line, identifier))
815 return true;
816
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000817 variable = new TVariable(&identifier, TType(type));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000818
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000819 if (type.arraySize)
820 variable->getType().setArraySize(type.arraySize);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000821
Nicolas Capensadfffe42014-06-17 02:13:36 -0400822 if (! symbolTable.declare(variable)) {
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000823 delete variable;
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000824 error(line, "INTERNAL ERROR inserting new symbol", identifier.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000825 return true;
826 }
827 } else {
828 if (! symbol->isVariable()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000829 error(line, "variable expected", identifier.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000830 return true;
831 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000832
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000833 variable = static_cast<TVariable*>(symbol);
834 if (! variable->getType().isArray()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000835 error(line, "redeclaring non-array as array", identifier.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000836 return true;
837 }
838 if (variable->getType().getArraySize() > 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000839 error(line, "redeclaration of array with size", identifier.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000840 return true;
841 }
842
843 if (! variable->getType().sameElementType(TType(type))) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000844 error(line, "redeclaration of array with a different type", identifier.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000845 return true;
846 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000847
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000848 if (type.arraySize)
849 variable->getType().setArraySize(type.arraySize);
850 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000851
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000852 if (voidErrorCheck(line, identifier, type))
853 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000854
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000855 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000856}
857
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000858//
859// Enforce non-initializer type/qualifier rules.
860//
861// Returns true if there was an error.
862//
Jamie Madill075edd82013-07-08 13:30:19 -0400863bool TParseContext::nonInitConstErrorCheck(const TSourceLoc& line, const TString& identifier, TPublicType& type, bool array)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000864{
daniel@transgaming.com8abd0b72012-09-27 17:46:07 +0000865 if (type.qualifier == EvqConst)
866 {
867 // Make the qualifier make sense.
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000868 type.qualifier = EvqTemporary;
daniel@transgaming.com8abd0b72012-09-27 17:46:07 +0000869
870 if (array)
871 {
872 error(line, "arrays may not be declared constant since they cannot be initialized", identifier.c_str());
873 }
874 else if (type.isStructureContainingArrays())
875 {
876 error(line, "structures containing arrays may not be declared constant since they cannot be initialized", identifier.c_str());
877 }
878 else
879 {
880 error(line, "variables with qualifier 'const' must be initialized", identifier.c_str());
881 }
882
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000883 return true;
884 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000885
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000886 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000887}
888
889//
890// Do semantic checking for a variable declaration that has no initializer,
891// and update the symbol table.
892//
893// Returns true if there was an error.
894//
Jamie Madill075edd82013-07-08 13:30:19 -0400895bool TParseContext::nonInitErrorCheck(const TSourceLoc& line, const TString& identifier, const TPublicType& type, TVariable*& variable)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000896{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000897 if (reservedErrorCheck(line, identifier))
898 recover();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000899
zmo@google.comfd747b82011-04-23 01:30:07 +0000900 variable = new TVariable(&identifier, TType(type));
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000901
Nicolas Capensadfffe42014-06-17 02:13:36 -0400902 if (! symbolTable.declare(variable)) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000903 error(line, "redefinition", variable->getName().c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000904 delete variable;
zmo@google.comfd747b82011-04-23 01:30:07 +0000905 variable = 0;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000906 return true;
907 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000908
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000909 if (voidErrorCheck(line, identifier, type))
910 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000911
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000912 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000913}
914
Jamie Madill075edd82013-07-08 13:30:19 -0400915bool TParseContext::paramErrorCheck(const TSourceLoc& line, TQualifier qualifier, TQualifier paramQualifier, TType* type)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000916{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000917 if (qualifier != EvqConst && qualifier != EvqTemporary) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +0000918 error(line, "qualifier not allowed on function parameter", getQualifierString(qualifier));
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000919 return true;
920 }
921 if (qualifier == EvqConst && paramQualifier != EvqIn) {
922 error(line, "qualifier not allowed with ", getQualifierString(qualifier), getQualifierString(paramQualifier));
923 return true;
924 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000925
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000926 if (qualifier == EvqConst)
alokp@chromium.org58e54292010-08-24 21:40:03 +0000927 type->setQualifier(EvqConstReadOnly);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000928 else
alokp@chromium.org58e54292010-08-24 21:40:03 +0000929 type->setQualifier(paramQualifier);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000930
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000931 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000932}
933
Jamie Madill075edd82013-07-08 13:30:19 -0400934bool TParseContext::extensionErrorCheck(const TSourceLoc& line, const TString& extension)
alokp@chromium.org8815d7f2010-09-09 17:30:03 +0000935{
alokp@chromium.org73bc2982012-06-19 18:48:05 +0000936 const TExtensionBehavior& extBehavior = extensionBehavior();
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000937 TExtensionBehavior::const_iterator iter = extBehavior.find(extension.c_str());
938 if (iter == extBehavior.end()) {
alokp@chromium.org8815d7f2010-09-09 17:30:03 +0000939 error(line, "extension", extension.c_str(), "is not supported");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000940 return true;
941 }
zmo@google.comf5450912011-09-09 01:37:19 +0000942 // In GLSL ES, an extension's default behavior is "disable".
943 if (iter->second == EBhDisable || iter->second == EBhUndefined) {
alokp@chromium.org8815d7f2010-09-09 17:30:03 +0000944 error(line, "extension", extension.c_str(), "is disabled");
945 return true;
946 }
947 if (iter->second == EBhWarn) {
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000948 warning(line, "extension", extension.c_str(), "is being used");
alokp@chromium.org8815d7f2010-09-09 17:30:03 +0000949 return false;
950 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000951
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +0000952 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +0000953}
954
Jamie Madill075edd82013-07-08 13:30:19 -0400955bool TParseContext::singleDeclarationErrorCheck(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier)
Jamie Madilla5efff92013-06-06 11:56:47 -0400956{
957 if (structQualifierErrorCheck(identifierLocation, publicType))
958 return true;
959
960 // check for layout qualifier issues
961 const TLayoutQualifier layoutQualifier = publicType.layoutQualifier;
962
963 if (layoutQualifier.matrixPacking != EmpUnspecified)
964 {
965 error(identifierLocation, "layout qualifier", getMatrixPackingString(layoutQualifier.matrixPacking), "only valid for interface blocks");
Jamie Madill51a53c72013-06-19 09:24:43 -0400966 return true;
Jamie Madilla5efff92013-06-06 11:56:47 -0400967 }
968
969 if (layoutQualifier.blockStorage != EbsUnspecified)
970 {
971 error(identifierLocation, "layout qualifier", getBlockStorageString(layoutQualifier.blockStorage), "only valid for interface blocks");
Jamie Madill51a53c72013-06-19 09:24:43 -0400972 return true;
Jamie Madilla5efff92013-06-06 11:56:47 -0400973 }
974
Jamie Madill19571812013-08-12 15:26:34 -0700975 if (publicType.qualifier != EvqVertexIn && publicType.qualifier != EvqFragmentOut && layoutLocationErrorCheck(identifierLocation, publicType.layoutQualifier))
Jamie Madilla5efff92013-06-06 11:56:47 -0400976 {
Jamie Madill51a53c72013-06-19 09:24:43 -0400977 return true;
Jamie Madilla5efff92013-06-06 11:56:47 -0400978 }
979
980 return false;
981}
982
Jamie Madill075edd82013-07-08 13:30:19 -0400983bool TParseContext::layoutLocationErrorCheck(const TSourceLoc& location, const TLayoutQualifier &layoutQualifier)
Jamie Madilla5efff92013-06-06 11:56:47 -0400984{
985 if (layoutQualifier.location != -1)
986 {
987 error(location, "invalid layout qualifier:", "location", "only valid on program inputs and outputs");
988 return true;
989 }
990
991 return false;
992}
993
zmo@google.com09c323a2011-08-12 18:22:25 +0000994bool TParseContext::supportsExtension(const char* extension)
995{
alokp@chromium.org73bc2982012-06-19 18:48:05 +0000996 const TExtensionBehavior& extbehavior = extensionBehavior();
997 TExtensionBehavior::const_iterator iter = extbehavior.find(extension);
998 return (iter != extbehavior.end());
alokp@chromium.org8b851c62012-06-15 16:25:11 +0000999}
1000
Jamie Madill5d287f52013-07-12 15:38:19 -04001001bool TParseContext::isExtensionEnabled(const char* extension) const
1002{
1003 const TExtensionBehavior& extbehavior = extensionBehavior();
Shannon Woodsa49a9bf2013-08-02 17:23:14 -04001004 TExtensionBehavior::const_iterator iter = extbehavior.find(extension);
Jamie Madill5d287f52013-07-12 15:38:19 -04001005
1006 if (iter == extbehavior.end())
1007 {
1008 return false;
1009 }
1010
1011 return (iter->second == EBhEnable || iter->second == EBhRequire);
1012}
1013
Jamie Madill075edd82013-07-08 13:30:19 -04001014void TParseContext::handleExtensionDirective(const TSourceLoc& loc, const char* extName, const char* behavior)
1015{
1016 pp::SourceLocation srcLoc;
1017 srcLoc.file = loc.first_file;
1018 srcLoc.line = loc.first_line;
1019 directiveHandler.handleExtension(srcLoc, extName, behavior);
1020}
1021
Zhenyao Mo94ac7b72014-10-15 18:22:08 -07001022void TParseContext::handlePragmaDirective(const TSourceLoc& loc, const char* name, const char* value, bool stdgl)
Jamie Madill075edd82013-07-08 13:30:19 -04001023{
1024 pp::SourceLocation srcLoc;
1025 srcLoc.file = loc.first_file;
1026 srcLoc.line = loc.first_line;
Zhenyao Mo94ac7b72014-10-15 18:22:08 -07001027 directiveHandler.handlePragma(srcLoc, name, value, stdgl);
Jamie Madill075edd82013-07-08 13:30:19 -04001028}
1029
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001030/////////////////////////////////////////////////////////////////////////////////
1031//
1032// Non-Errors.
1033//
1034/////////////////////////////////////////////////////////////////////////////////
1035
Jamie Madill5c097022014-08-20 16:38:32 -04001036const TVariable *TParseContext::getNamedVariable(const TSourceLoc &location,
1037 const TString *name,
1038 const TSymbol *symbol)
1039{
1040 const TVariable *variable = NULL;
1041
1042 if (!symbol)
1043 {
1044 error(location, "undeclared identifier", name->c_str());
1045 recover();
1046 }
1047 else if (!symbol->isVariable())
1048 {
1049 error(location, "variable expected", name->c_str());
1050 recover();
1051 }
1052 else
1053 {
1054 variable = static_cast<const TVariable*>(symbol);
1055
1056 if (symbolTable.findBuiltIn(variable->getName(), shaderVersion) &&
1057 !variable->getExtension().empty() &&
1058 extensionErrorCheck(location, variable->getExtension()))
1059 {
1060 recover();
1061 }
1062 }
1063
1064 if (!variable)
1065 {
1066 TType type(EbtFloat, EbpUndefined);
1067 TVariable *fakeVariable = new TVariable(name, type);
1068 symbolTable.declare(fakeVariable);
1069 variable = fakeVariable;
1070 }
1071
1072 return variable;
1073}
1074
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001075//
1076// Look up a function name in the symbol table, and make sure it is a function.
1077//
1078// Return the function symbol if found, otherwise 0.
1079//
Austin Kinross3ae64652015-01-26 15:51:39 -08001080const TFunction* TParseContext::findFunction(const TSourceLoc& line, TFunction* call, int inputShaderVersion, bool *builtIn)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001081{
alokp@chromium.org0a576182010-08-09 17:16:27 +00001082 // First find by unmangled name to check whether the function name has been
1083 // hidden by a variable name or struct typename.
Nicolas Capensd4a9b8d2013-07-18 11:01:22 -04001084 // If a function is found, check for one with a matching argument list.
Austin Kinross3ae64652015-01-26 15:51:39 -08001085 const TSymbol* symbol = symbolTable.find(call->getName(), inputShaderVersion, builtIn);
Nicolas Capensd4a9b8d2013-07-18 11:01:22 -04001086 if (symbol == 0 || symbol->isFunction()) {
Austin Kinross3ae64652015-01-26 15:51:39 -08001087 symbol = symbolTable.find(call->getMangledName(), inputShaderVersion, builtIn);
alokp@chromium.org0a576182010-08-09 17:16:27 +00001088 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001089
alokp@chromium.org0a576182010-08-09 17:16:27 +00001090 if (symbol == 0) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001091 error(line, "no matching overloaded function found", call->getName().c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001092 return 0;
1093 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001094
alokp@chromium.org0a576182010-08-09 17:16:27 +00001095 if (!symbol->isFunction()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001096 error(line, "function name expected", call->getName().c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001097 return 0;
1098 }
alokp@chromium.org0a576182010-08-09 17:16:27 +00001099
1100 return static_cast<const TFunction*>(symbol);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001101}
1102
1103//
1104// Initializers show up in several places in the grammar. Have one set of
1105// code to handle them here.
1106//
Jamie Madill3b5c2da2014-08-19 15:23:32 -04001107// Returns true on error, false if no error
1108//
Jamie Madill075edd82013-07-08 13:30:19 -04001109bool TParseContext::executeInitializer(const TSourceLoc& line, const TString& identifier, TPublicType& pType,
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001110 TIntermTyped* initializer, TIntermNode*& intermNode, TVariable* variable)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001111{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001112 TType type = TType(pType);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001113
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001114 if (variable == 0) {
1115 if (reservedErrorCheck(line, identifier))
1116 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001117
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001118 if (voidErrorCheck(line, identifier, pType))
1119 return true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001120
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001121 //
1122 // add variable to symbol table
1123 //
1124 variable = new TVariable(&identifier, type);
Nicolas Capensadfffe42014-06-17 02:13:36 -04001125 if (! symbolTable.declare(variable)) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001126 error(line, "redefinition", variable->getName().c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001127 return true;
1128 // don't delete variable, it's used by error recovery, and the pool
1129 // pop will take care of the memory
1130 }
1131 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001132
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001133 //
1134 // identifier must be of type constant, a global, or a temporary
1135 //
1136 TQualifier qualifier = variable->getType().getQualifier();
1137 if ((qualifier != EvqTemporary) && (qualifier != EvqGlobal) && (qualifier != EvqConst)) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001138 error(line, " cannot initialize this type of qualifier ", variable->getType().getQualifierString());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001139 return true;
1140 }
1141 //
1142 // test for and propagate constant
1143 //
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001144
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001145 if (qualifier == EvqConst) {
1146 if (qualifier != initializer->getType().getQualifier()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001147 std::stringstream extraInfoStream;
1148 extraInfoStream << "'" << variable->getType().getCompleteString() << "'";
1149 std::string extraInfo = extraInfoStream.str();
1150 error(line, " assigning non-constant to", "=", extraInfo.c_str());
alokp@chromium.org58e54292010-08-24 21:40:03 +00001151 variable->getType().setQualifier(EvqTemporary);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001152 return true;
1153 }
1154 if (type != initializer->getType()) {
1155 error(line, " non-matching types for const initializer ",
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001156 variable->getType().getQualifierString());
alokp@chromium.org58e54292010-08-24 21:40:03 +00001157 variable->getType().setQualifier(EvqTemporary);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001158 return true;
1159 }
1160 if (initializer->getAsConstantUnion()) {
Jamie Madill94bf7f22013-07-08 13:31:15 -04001161 variable->shareConstPointer(initializer->getAsConstantUnion()->getUnionArrayPointer());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001162 } else if (initializer->getAsSymbolNode()) {
shannonwoods@chromium.org96e7ba12013-05-30 00:02:41 +00001163 const TSymbol* symbol = symbolTable.find(initializer->getAsSymbolNode()->getSymbol(), 0);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001164 const TVariable* tVar = static_cast<const TVariable*>(symbol);
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001165
alokp@chromium.org6ff56fd2010-05-05 16:37:50 +00001166 ConstantUnion* constArray = tVar->getConstPointer();
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001167 variable->shareConstPointer(constArray);
1168 } else {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001169 std::stringstream extraInfoStream;
1170 extraInfoStream << "'" << variable->getType().getCompleteString() << "'";
1171 std::string extraInfo = extraInfoStream.str();
1172 error(line, " cannot assign to", "=", extraInfo.c_str());
alokp@chromium.org58e54292010-08-24 21:40:03 +00001173 variable->getType().setQualifier(EvqTemporary);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001174 return true;
1175 }
1176 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001177
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001178 if (qualifier != EvqConst) {
1179 TIntermSymbol* intermSymbol = intermediate.addSymbol(variable->getUniqueId(), variable->getName(), variable->getType(), line);
1180 intermNode = intermediate.addAssign(EOpInitialize, intermSymbol, initializer, line);
1181 if (intermNode == 0) {
1182 assignError(line, "=", intermSymbol->getCompleteString(), initializer->getCompleteString());
1183 return true;
1184 }
1185 } else
1186 intermNode = 0;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001187
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001188 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001189}
1190
1191bool TParseContext::areAllChildConst(TIntermAggregate* aggrNode)
1192{
alokp@chromium.orgd300f5b2010-10-14 16:10:20 +00001193 ASSERT(aggrNode != NULL);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001194 if (!aggrNode->isConstructor())
1195 return false;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001196
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001197 bool allConstant = true;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001198
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001199 // check if all the child nodes are constants so that they can be inserted into
1200 // the parent node
Zhenyao Moe40d1e92014-07-16 17:40:36 -07001201 TIntermSequence *sequence = aggrNode->getSequence() ;
1202 for (TIntermSequence::iterator p = sequence->begin(); p != sequence->end(); ++p) {
alokp@chromium.orgd300f5b2010-10-14 16:10:20 +00001203 if (!(*p)->getAsTyped()->getAsConstantUnion())
1204 return false;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001205 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001206
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001207 return allConstant;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001208}
1209
Jamie Madilla5efff92013-06-06 11:56:47 -04001210TPublicType TParseContext::addFullySpecifiedType(TQualifier qualifier, TLayoutQualifier layoutQualifier, const TPublicType& typeSpecifier)
shannonwoods@chromium.org0f376ca2013-05-30 00:19:23 +00001211{
1212 TPublicType returnType = typeSpecifier;
1213 returnType.qualifier = qualifier;
Jamie Madilla5efff92013-06-06 11:56:47 -04001214 returnType.layoutQualifier = layoutQualifier;
shannonwoods@chromium.org0f376ca2013-05-30 00:19:23 +00001215
1216 if (typeSpecifier.array)
1217 {
1218 error(typeSpecifier.line, "not supported", "first-class array");
1219 recover();
1220 returnType.setArray(false);
1221 }
1222
shannonwoods@chromium.org5703d882013-05-30 00:19:38 +00001223 if (shaderVersion < 300)
shannonwoods@chromium.org0f376ca2013-05-30 00:19:23 +00001224 {
shannonwoods@chromium.org5703d882013-05-30 00:19:38 +00001225 if (qualifier == EvqAttribute && (typeSpecifier.type == EbtBool || typeSpecifier.type == EbtInt))
1226 {
1227 error(typeSpecifier.line, "cannot be bool or int", getQualifierString(qualifier));
1228 recover();
1229 }
shannonwoods@chromium.org0f376ca2013-05-30 00:19:23 +00001230
shannonwoods@chromium.org5703d882013-05-30 00:19:38 +00001231 if ((qualifier == EvqVaryingIn || qualifier == EvqVaryingOut) &&
1232 (typeSpecifier.type == EbtBool || typeSpecifier.type == EbtInt))
1233 {
1234 error(typeSpecifier.line, "cannot be bool or int", getQualifierString(qualifier));
1235 recover();
1236 }
1237 }
1238 else
shannonwoods@chromium.org0f376ca2013-05-30 00:19:23 +00001239 {
Jamie Madillb120eac2013-06-12 14:08:13 -04001240 switch (qualifier)
shannonwoods@chromium.org5703d882013-05-30 00:19:38 +00001241 {
Jamie Madill19571812013-08-12 15:26:34 -07001242 case EvqSmoothIn:
1243 case EvqSmoothOut:
1244 case EvqVertexOut:
1245 case EvqFragmentIn:
1246 case EvqCentroidOut:
1247 case EvqCentroidIn:
1248 if (typeSpecifier.type == EbtBool)
1249 {
1250 error(typeSpecifier.line, "cannot be bool", getQualifierString(qualifier));
1251 recover();
1252 }
1253 if (typeSpecifier.type == EbtInt || typeSpecifier.type == EbtUInt)
1254 {
1255 error(typeSpecifier.line, "must use 'flat' interpolation here", getQualifierString(qualifier));
1256 recover();
1257 }
1258 break;
1259
1260 case EvqVertexIn:
1261 case EvqFragmentOut:
1262 case EvqFlatIn:
1263 case EvqFlatOut:
Jamie Madillb120eac2013-06-12 14:08:13 -04001264 if (typeSpecifier.type == EbtBool)
1265 {
1266 error(typeSpecifier.line, "cannot be bool", getQualifierString(qualifier));
1267 recover();
1268 }
1269 break;
shannonwoods@chromium.org5703d882013-05-30 00:19:38 +00001270
Jamie Madillb120eac2013-06-12 14:08:13 -04001271 default: break;
shannonwoods@chromium.org5703d882013-05-30 00:19:38 +00001272 }
shannonwoods@chromium.org0f376ca2013-05-30 00:19:23 +00001273 }
1274
1275 return returnType;
1276}
1277
Jamie Madill075edd82013-07-08 13:30:19 -04001278TIntermAggregate* TParseContext::parseSingleDeclaration(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier)
Jamie Madill60ed9812013-06-06 11:56:46 -04001279{
1280 TIntermSymbol* symbol = intermediate.addSymbol(0, identifier, TType(publicType), identifierLocation);
1281 TIntermAggregate* aggregate = intermediate.makeAggregate(symbol, identifierLocation);
1282
1283 if (identifier != "")
1284 {
Jamie Madill51a53c72013-06-19 09:24:43 -04001285 if (singleDeclarationErrorCheck(publicType, identifierLocation, identifier))
Jamie Madill60ed9812013-06-06 11:56:46 -04001286 recover();
1287
1288 // this error check can mutate the type
1289 if (nonInitConstErrorCheck(identifierLocation, identifier, publicType, false))
1290 recover();
1291
1292 TVariable* variable = 0;
1293
1294 if (nonInitErrorCheck(identifierLocation, identifier, publicType, variable))
1295 recover();
1296
1297 if (variable && symbol)
1298 {
1299 symbol->setId(variable->getUniqueId());
1300 }
1301 }
1302
1303 return aggregate;
1304}
1305
Jamie Madill075edd82013-07-08 13:30:19 -04001306TIntermAggregate* TParseContext::parseSingleArrayDeclaration(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& indexLocation, TIntermTyped *indexExpression)
Jamie Madill60ed9812013-06-06 11:56:46 -04001307{
Jamie Madill51a53c72013-06-19 09:24:43 -04001308 if (singleDeclarationErrorCheck(publicType, identifierLocation, identifier))
Jamie Madill60ed9812013-06-06 11:56:46 -04001309 recover();
1310
1311 // this error check can mutate the type
1312 if (nonInitConstErrorCheck(identifierLocation, identifier, publicType, true))
1313 recover();
1314
1315 if (arrayTypeErrorCheck(indexLocation, publicType) || arrayQualifierErrorCheck(indexLocation, publicType))
1316 {
1317 recover();
1318 }
1319
1320 TPublicType arrayType = publicType;
1321
1322 int size;
1323 if (arraySizeErrorCheck(identifierLocation, indexExpression, size))
1324 {
1325 recover();
1326 }
1327 else
1328 {
1329 arrayType.setArray(true, size);
1330 }
1331
1332 TIntermSymbol* symbol = intermediate.addSymbol(0, identifier, TType(arrayType), identifierLocation);
1333 TIntermAggregate* aggregate = intermediate.makeAggregate(symbol, identifierLocation);
1334 TVariable* variable = 0;
1335
1336 if (arrayErrorCheck(identifierLocation, identifier, arrayType, variable))
1337 recover();
1338
1339 if (variable && symbol)
1340 {
1341 symbol->setId(variable->getUniqueId());
1342 }
1343
1344 return aggregate;
1345}
1346
Jamie Madill075edd82013-07-08 13:30:19 -04001347TIntermAggregate* TParseContext::parseSingleInitDeclaration(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& initLocation, TIntermTyped *initializer)
Jamie Madill60ed9812013-06-06 11:56:46 -04001348{
Jamie Madilla5efff92013-06-06 11:56:47 -04001349 if (singleDeclarationErrorCheck(publicType, identifierLocation, identifier))
Jamie Madill60ed9812013-06-06 11:56:46 -04001350 recover();
1351
1352 TIntermNode* intermNode;
1353 if (!executeInitializer(identifierLocation, identifier, publicType, initializer, intermNode))
1354 {
1355 //
1356 // Build intermediate representation
1357 //
1358 return intermNode ? intermediate.makeAggregate(intermNode, initLocation) : NULL;
1359 }
1360 else
1361 {
1362 recover();
1363 return NULL;
1364 }
1365}
1366
Jamie Madill47e3ec02014-08-20 16:38:33 -04001367TIntermAggregate* TParseContext::parseInvariantDeclaration(const TSourceLoc &invariantLoc,
1368 const TSourceLoc &identifierLoc,
1369 const TString *identifier,
1370 const TSymbol *symbol)
1371{
Jamie Madill3b5c2da2014-08-19 15:23:32 -04001372 // invariant declaration
Jamie Madill47e3ec02014-08-20 16:38:33 -04001373 if (globalErrorCheck(invariantLoc, symbolTable.atGlobalLevel(), "invariant varying"))
1374 {
1375 recover();
1376 }
1377
1378 if (!symbol)
1379 {
1380 error(identifierLoc, "undeclared identifier declared as invariant", identifier->c_str());
1381 recover();
Jamie Madill47e3ec02014-08-20 16:38:33 -04001382 return NULL;
1383 }
1384 else
1385 {
Zhenyao Mo94ac7b72014-10-15 18:22:08 -07001386 const TString kGlFrontFacing("gl_FrontFacing");
1387 if (*identifier == kGlFrontFacing)
1388 {
1389 error(identifierLoc, "identifier should not be declared as invariant", identifier->c_str());
1390 recover();
1391 return NULL;
1392 }
Jamie Madill2c433252014-12-03 12:36:54 -05001393 symbolTable.addInvariantVarying(std::string(identifier->c_str()));
Jamie Madill3b5c2da2014-08-19 15:23:32 -04001394 const TVariable *variable = getNamedVariable(identifierLoc, identifier, symbol);
1395 ASSERT(variable);
1396 const TType &type = variable->getType();
1397 TIntermSymbol *intermSymbol = intermediate.addSymbol(variable->getUniqueId(),
1398 *identifier, type, identifierLoc);
1399
1400 TIntermAggregate *aggregate = intermediate.makeAggregate(intermSymbol, identifierLoc);
1401 aggregate->setOp(EOpInvariantDeclaration);
1402 return aggregate;
Jamie Madill47e3ec02014-08-20 16:38:33 -04001403 }
1404}
1405
Jamie Madill075edd82013-07-08 13:30:19 -04001406TIntermAggregate* TParseContext::parseDeclarator(TPublicType &publicType, TIntermAggregate *aggregateDeclaration, TSymbol *identifierSymbol, const TSourceLoc& identifierLocation, const TString &identifier)
Jamie Madill502d66f2013-06-20 11:55:52 -04001407{
Jamie Madill502d66f2013-06-20 11:55:52 -04001408 TIntermSymbol* symbol = intermediate.addSymbol(0, identifier, TType(publicType), identifierLocation);
1409 TIntermAggregate* intermAggregate = intermediate.growAggregate(aggregateDeclaration, symbol, identifierLocation);
1410
1411 if (structQualifierErrorCheck(identifierLocation, publicType))
1412 recover();
1413
Jamie Madill0bd18df2013-06-20 11:55:52 -04001414 if (locationDeclaratorListCheck(identifierLocation, publicType))
1415 recover();
1416
Jamie Madill502d66f2013-06-20 11:55:52 -04001417 if (nonInitConstErrorCheck(identifierLocation, identifier, publicType, false))
1418 recover();
1419
1420 TVariable* variable = 0;
1421 if (nonInitErrorCheck(identifierLocation, identifier, publicType, variable))
1422 recover();
1423 if (symbol && variable)
1424 symbol->setId(variable->getUniqueId());
1425
1426 return intermAggregate;
1427}
1428
Jamie Madill075edd82013-07-08 13:30:19 -04001429TIntermAggregate* TParseContext::parseArrayDeclarator(TPublicType &publicType, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& arrayLocation, TIntermNode *declaratorList, TIntermTyped *indexExpression)
Jamie Madill502d66f2013-06-20 11:55:52 -04001430{
1431 if (structQualifierErrorCheck(identifierLocation, publicType))
1432 recover();
1433
Jamie Madill0bd18df2013-06-20 11:55:52 -04001434 if (locationDeclaratorListCheck(identifierLocation, publicType))
1435 recover();
1436
Jamie Madill502d66f2013-06-20 11:55:52 -04001437 if (nonInitConstErrorCheck(identifierLocation, identifier, publicType, true))
1438 recover();
1439
1440 if (arrayTypeErrorCheck(arrayLocation, publicType) || arrayQualifierErrorCheck(arrayLocation, publicType))
1441 {
1442 recover();
1443 }
1444 else if (indexExpression)
1445 {
1446 int size;
1447 if (arraySizeErrorCheck(arrayLocation, indexExpression, size))
1448 recover();
1449 TPublicType arrayType(publicType);
1450 arrayType.setArray(true, size);
1451 TVariable* variable = NULL;
1452 if (arrayErrorCheck(arrayLocation, identifier, arrayType, variable))
1453 recover();
1454 TType type = TType(arrayType);
1455 type.setArraySize(size);
1456
1457 return intermediate.growAggregate(declaratorList, intermediate.addSymbol(variable ? variable->getUniqueId() : 0, identifier, type, identifierLocation), identifierLocation);
1458 }
1459 else
1460 {
1461 TPublicType arrayType(publicType);
1462 arrayType.setArray(true);
1463 TVariable* variable = NULL;
1464 if (arrayErrorCheck(arrayLocation, identifier, arrayType, variable))
1465 recover();
1466 }
1467
1468 return NULL;
1469}
1470
Jamie Madill075edd82013-07-08 13:30:19 -04001471TIntermAggregate* TParseContext::parseInitDeclarator(TPublicType &publicType, TIntermAggregate *declaratorList, const TSourceLoc& identifierLocation, const TString &identifier, const TSourceLoc& initLocation, TIntermTyped *initializer)
Jamie Madill502d66f2013-06-20 11:55:52 -04001472{
1473 if (structQualifierErrorCheck(identifierLocation, publicType))
1474 recover();
1475
Jamie Madill0bd18df2013-06-20 11:55:52 -04001476 if (locationDeclaratorListCheck(identifierLocation, publicType))
1477 recover();
1478
Jamie Madill502d66f2013-06-20 11:55:52 -04001479 TIntermNode* intermNode;
1480 if (!executeInitializer(identifierLocation, identifier, publicType, initializer, intermNode))
1481 {
1482 //
1483 // build the intermediate representation
1484 //
1485 if (intermNode)
1486 {
1487 return intermediate.growAggregate(declaratorList, intermNode, initLocation);
1488 }
1489 else
1490 {
1491 return declaratorList;
1492 }
1493 }
1494 else
1495 {
1496 recover();
1497 return NULL;
1498 }
1499}
1500
Jamie Madilla295edf2013-06-06 11:56:48 -04001501void TParseContext::parseGlobalLayoutQualifier(const TPublicType &typeQualifier)
1502{
1503 if (typeQualifier.qualifier != EvqUniform)
1504 {
1505 error(typeQualifier.line, "invalid qualifier:", getQualifierString(typeQualifier.qualifier), "global layout must be uniform");
1506 recover();
1507 return;
1508 }
1509
1510 const TLayoutQualifier layoutQualifier = typeQualifier.layoutQualifier;
1511 ASSERT(!layoutQualifier.isEmpty());
1512
1513 if (shaderVersion < 300)
1514 {
1515 error(typeQualifier.line, "layout qualifiers supported in GLSL ES 3.00 only", "layout");
1516 recover();
1517 return;
1518 }
1519
1520 if (layoutLocationErrorCheck(typeQualifier.line, typeQualifier.layoutQualifier))
1521 {
1522 recover();
1523 return;
1524 }
1525
Jamie Madill099c0f32013-06-20 11:55:52 -04001526 if (layoutQualifier.matrixPacking != EmpUnspecified)
1527 {
1528 defaultMatrixPacking = layoutQualifier.matrixPacking;
1529 }
1530
Geoff Langc6856732014-02-11 09:38:55 -05001531 if (layoutQualifier.blockStorage != EbsUnspecified)
Jamie Madill1566ef72013-06-20 11:55:54 -04001532 {
1533 defaultBlockStorage = layoutQualifier.blockStorage;
1534 }
Jamie Madilla295edf2013-06-06 11:56:48 -04001535}
1536
shannonwoods@chromium.org18851132013-05-30 00:19:54 +00001537TFunction *TParseContext::addConstructorFunc(TPublicType publicType)
1538{
1539 TOperator op = EOpNull;
1540 if (publicType.userDef)
1541 {
1542 op = EOpConstructStruct;
1543 }
1544 else
1545 {
1546 switch (publicType.type)
1547 {
1548 case EbtFloat:
1549 if (publicType.isMatrix())
1550 {
1551 // TODO: non-square matrices
1552 switch(publicType.getCols())
1553 {
Jamie Madill28b97422013-07-08 14:01:38 -04001554 case 2: op = EOpConstructMat2; break;
1555 case 3: op = EOpConstructMat3; break;
1556 case 4: op = EOpConstructMat4; break;
shannonwoods@chromium.org18851132013-05-30 00:19:54 +00001557 }
1558 }
1559 else
1560 {
1561 switch(publicType.getNominalSize())
1562 {
Jamie Madill28b97422013-07-08 14:01:38 -04001563 case 1: op = EOpConstructFloat; break;
1564 case 2: op = EOpConstructVec2; break;
1565 case 3: op = EOpConstructVec3; break;
1566 case 4: op = EOpConstructVec4; break;
shannonwoods@chromium.org18851132013-05-30 00:19:54 +00001567 }
1568 }
1569 break;
1570
1571 case EbtInt:
1572 switch(publicType.getNominalSize())
1573 {
Jamie Madill28b97422013-07-08 14:01:38 -04001574 case 1: op = EOpConstructInt; break;
1575 case 2: op = EOpConstructIVec2; break;
1576 case 3: op = EOpConstructIVec3; break;
1577 case 4: op = EOpConstructIVec4; break;
shannonwoods@chromium.org18851132013-05-30 00:19:54 +00001578 }
1579 break;
1580
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +00001581 case EbtUInt:
1582 switch(publicType.getNominalSize())
1583 {
Jamie Madill28b97422013-07-08 14:01:38 -04001584 case 1: op = EOpConstructUInt; break;
1585 case 2: op = EOpConstructUVec2; break;
1586 case 3: op = EOpConstructUVec3; break;
1587 case 4: op = EOpConstructUVec4; break;
shannonwoods@chromium.org6b709912013-05-30 00:20:04 +00001588 }
1589 break;
1590
shannonwoods@chromium.org18851132013-05-30 00:19:54 +00001591 case EbtBool:
1592 switch(publicType.getNominalSize())
1593 {
Jamie Madill28b97422013-07-08 14:01:38 -04001594 case 1: op = EOpConstructBool; break;
1595 case 2: op = EOpConstructBVec2; break;
1596 case 3: op = EOpConstructBVec3; break;
1597 case 4: op = EOpConstructBVec4; break;
shannonwoods@chromium.org18851132013-05-30 00:19:54 +00001598 }
1599 break;
1600
1601 default: break;
1602 }
1603
1604 if (op == EOpNull)
1605 {
1606 error(publicType.line, "cannot construct this type", getBasicString(publicType.type));
1607 recover();
1608 publicType.type = EbtFloat;
1609 op = EOpConstructFloat;
1610 }
1611 }
1612
1613 TString tempString;
1614 TType type(publicType);
1615 return new TFunction(&tempString, type, op);
1616}
1617
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001618// This function is used to test for the correctness of the parameters passed to various constructor functions
1619// and also convert them to the right datatype if it is allowed and required.
1620//
1621// Returns 0 for an error or the constructed node (aggregate or typed) for no error.
1622//
Olli Etuaho21203702014-11-13 16:16:21 +02001623TIntermTyped *TParseContext::addConstructor(TIntermNode *arguments, TType *type, TOperator op, TFunction *fnCall, const TSourceLoc &line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001624{
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001625 TIntermAggregate *aggregateArguments = arguments->getAsAggregate();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001626
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001627 if (!aggregateArguments)
1628 {
1629 aggregateArguments = new TIntermAggregate;
Zhenyao Moe40d1e92014-07-16 17:40:36 -07001630 aggregateArguments->getSequence()->push_back(arguments);
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001631 }
1632
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001633 if (op == EOpConstructStruct)
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001634 {
1635 const TFieldList &fields = type->getStruct()->fields();
Zhenyao Moe40d1e92014-07-16 17:40:36 -07001636 TIntermSequence *args = aggregateArguments->getSequence();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001637
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001638 for (size_t i = 0; i < fields.size(); i++)
1639 {
Nicolas Capensffd73872014-08-21 13:49:16 -04001640 if (i >= args->size() || (*args)[i]->getAsTyped()->getType() != *fields[i]->type())
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001641 {
1642 error(line, "Structure constructor arguments do not match structure fields", "Error");
1643 recover();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001644
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001645 return 0;
1646 }
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001647 }
1648 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001649
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001650 // Turn the argument list itself into a constructor
Olli Etuaho21203702014-11-13 16:16:21 +02001651 TIntermAggregate *constructor = intermediate.setAggregateOperator(aggregateArguments, op, line);
1652 TIntermTyped *constConstructor = foldConstConstructor(constructor, *type);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001653 if (constConstructor)
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001654 {
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001655 return constConstructor;
Nicolas Capens6ed8d8a2014-06-11 11:25:20 -04001656 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001657
Olli Etuaho21203702014-11-13 16:16:21 +02001658 // Structs should not be precision qualified, the individual members may be.
1659 // Built-in types on the other hand should be precision qualified.
1660 if (op != EOpConstructStruct)
1661 {
1662 constructor->setPrecisionFromChildren();
1663 type->setPrecision(constructor->getPrecision());
1664 }
1665
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001666 return constructor;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001667}
1668
1669TIntermTyped* TParseContext::foldConstConstructor(TIntermAggregate* aggrNode, const TType& type)
1670{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001671 bool canBeFolded = areAllChildConst(aggrNode);
1672 aggrNode->setType(type);
1673 if (canBeFolded) {
1674 bool returnVal = false;
alokp@chromium.org6ff56fd2010-05-05 16:37:50 +00001675 ConstantUnion* unionArray = new ConstantUnion[type.getObjectSize()];
Zhenyao Moe40d1e92014-07-16 17:40:36 -07001676 if (aggrNode->getSequence()->size() == 1) {
shannonwoods@chromium.org298f9072013-05-30 00:21:17 +00001677 returnVal = intermediate.parseConstTree(aggrNode->getLine(), aggrNode, unionArray, aggrNode->getOp(), type, true);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001678 }
1679 else {
shannonwoods@chromium.org298f9072013-05-30 00:21:17 +00001680 returnVal = intermediate.parseConstTree(aggrNode->getLine(), aggrNode, unionArray, aggrNode->getOp(), type);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001681 }
1682 if (returnVal)
1683 return 0;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001684
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001685 return intermediate.addConstantUnion(unionArray, type, aggrNode->getLine());
1686 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001687
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001688 return 0;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001689}
1690
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001691//
1692// This function returns the tree representation for the vector field(s) being accessed from contant vector.
1693// If only one component of vector is accessed (v.x or v[0] where v is a contant vector), then a contant node is
1694// returned, else an aggregate node is returned (for v.xy). The input to this function could either be the symbol
1695// node or it could be the intermediate tree representation of accessing fields in a constant structure or column of
1696// a constant matrix.
1697//
Jamie Madill075edd82013-07-08 13:30:19 -04001698TIntermTyped* TParseContext::addConstVectorNode(TVectorFields& fields, TIntermTyped* node, const TSourceLoc& line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001699{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001700 TIntermTyped* typedNode;
1701 TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001702
alokp@chromium.org6ff56fd2010-05-05 16:37:50 +00001703 ConstantUnion *unionArray;
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001704 if (tempConstantNode) {
1705 unionArray = tempConstantNode->getUnionArrayPointer();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001706
alokp@chromium.org8b851c62012-06-15 16:25:11 +00001707 if (!unionArray) {
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001708 return node;
1709 }
1710 } else { // The node has to be either a symbol node or an aggregate node or a tempConstant node, else, its an error
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001711 error(line, "Cannot offset into the vector", "Error");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001712 recover();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001713
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001714 return 0;
1715 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001716
alokp@chromium.org6ff56fd2010-05-05 16:37:50 +00001717 ConstantUnion* constArray = new ConstantUnion[fields.num];
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001718
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001719 for (int i = 0; i < fields.num; i++) {
Jamie Madill94bf7f22013-07-08 13:31:15 -04001720 if (fields.offsets[i] >= node->getType().getNominalSize()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001721 std::stringstream extraInfoStream;
1722 extraInfoStream << "vector field selection out of range '" << fields.offsets[i] << "'";
1723 std::string extraInfo = extraInfoStream.str();
1724 error(line, "", "[", extraInfo.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001725 recover();
1726 fields.offsets[i] = 0;
1727 }
1728
1729 constArray[i] = unionArray[fields.offsets[i]];
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001730
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001731 }
1732 typedNode = intermediate.addConstantUnion(constArray, node->getType(), line);
1733 return typedNode;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001734}
1735
1736//
1737// This function returns the column being accessed from a constant matrix. The values are retrieved from
1738// the symbol table and parse-tree is built for a vector (each column of a matrix is a vector). The input
1739// to the function could either be a symbol node (m[0] where m is a constant matrix)that represents a
1740// constant matrix or it could be the tree representation of the constant matrix (s.m1[0] where s is a constant structure)
1741//
Jamie Madill075edd82013-07-08 13:30:19 -04001742TIntermTyped* TParseContext::addConstMatrixNode(int index, TIntermTyped* node, const TSourceLoc& line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001743{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001744 TIntermTyped* typedNode;
1745 TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001746
shannonwoods@chromium.org9bd22fa2013-05-30 00:18:47 +00001747 if (index >= node->getType().getCols()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001748 std::stringstream extraInfoStream;
1749 extraInfoStream << "matrix field selection out of range '" << index << "'";
1750 std::string extraInfo = extraInfoStream.str();
1751 error(line, "", "[", extraInfo.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001752 recover();
1753 index = 0;
1754 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001755
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001756 if (tempConstantNode) {
alokp@chromium.org6ff56fd2010-05-05 16:37:50 +00001757 ConstantUnion* unionArray = tempConstantNode->getUnionArrayPointer();
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00001758 int size = tempConstantNode->getType().getCols();
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001759 typedNode = intermediate.addConstantUnion(&unionArray[size*index], tempConstantNode->getType(), line);
1760 } else {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001761 error(line, "Cannot offset into the matrix", "Error");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001762 recover();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001763
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001764 return 0;
1765 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001766
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001767 return typedNode;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001768}
1769
1770
1771//
1772// This function returns an element of an array accessed from a constant array. The values are retrieved from
1773// the symbol table and parse-tree is built for the type of the element. The input
1774// to the function could either be a symbol node (a[0] where a is a constant array)that represents a
1775// constant array or it could be the tree representation of the constant array (s.a1[0] where s is a constant structure)
1776//
Jamie Madill075edd82013-07-08 13:30:19 -04001777TIntermTyped* TParseContext::addConstArrayNode(int index, TIntermTyped* node, const TSourceLoc& line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001778{
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001779 TIntermTyped* typedNode;
1780 TIntermConstantUnion* tempConstantNode = node->getAsConstantUnion();
1781 TType arrayElementType = node->getType();
1782 arrayElementType.clearArrayness();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001783
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001784 if (index >= node->getType().getArraySize()) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001785 std::stringstream extraInfoStream;
1786 extraInfoStream << "array field selection out of range '" << index << "'";
1787 std::string extraInfo = extraInfoStream.str();
1788 error(line, "", "[", extraInfo.c_str());
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001789 recover();
1790 index = 0;
1791 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001792
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001793 if (tempConstantNode) {
Jamie Madill94bf7f22013-07-08 13:31:15 -04001794 size_t arrayElementSize = arrayElementType.getObjectSize();
1795 ConstantUnion* unionArray = tempConstantNode->getUnionArrayPointer();
1796 typedNode = intermediate.addConstantUnion(&unionArray[arrayElementSize * index], tempConstantNode->getType(), line);
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001797 } else {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001798 error(line, "Cannot offset into the array", "Error");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001799 recover();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001800
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001801 return 0;
1802 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001803
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001804 return typedNode;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001805}
1806
1807
1808//
1809// This function returns the value of a particular field inside a constant structure from the symbol table.
1810// If there is an embedded/nested struct, it appropriately calls addConstStructNested or addConstStructFromAggr
1811// function and returns the parse-tree with the values of the embedded/nested struct.
1812//
Jamie Madill075edd82013-07-08 13:30:19 -04001813TIntermTyped* TParseContext::addConstStruct(const TString &identifier, TIntermTyped *node, const TSourceLoc& line)
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001814{
Jamie Madill98493dd2013-07-08 14:39:03 -04001815 const TFieldList& fields = node->getType().getStruct()->fields();
Jamie Madill94bf7f22013-07-08 13:31:15 -04001816 size_t instanceSize = 0;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001817
Jamie Madill98493dd2013-07-08 14:39:03 -04001818 for (size_t index = 0; index < fields.size(); ++index) {
1819 if (fields[index]->name() == identifier) {
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001820 break;
1821 } else {
Jamie Madill98493dd2013-07-08 14:39:03 -04001822 instanceSize += fields[index]->type()->getObjectSize();
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001823 }
1824 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001825
Jamie Madill94bf7f22013-07-08 13:31:15 -04001826 TIntermTyped *typedNode;
1827 TIntermConstantUnion *tempConstantNode = node->getAsConstantUnion();
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001828 if (tempConstantNode) {
alokp@chromium.org6ff56fd2010-05-05 16:37:50 +00001829 ConstantUnion* constArray = tempConstantNode->getUnionArrayPointer();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001830
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001831 typedNode = intermediate.addConstantUnion(constArray+instanceSize, tempConstantNode->getType(), line); // type will be changed in the calling function
1832 } else {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001833 error(line, "Cannot offset into the structure", "Error");
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001834 recover();
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001835
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001836 return 0;
1837 }
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001838
daniel@transgaming.comea15b0e2010-04-29 03:32:36 +00001839 return typedNode;
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00001840}
1841
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001842//
1843// Interface/uniform blocks
1844//
Jamie Madill98493dd2013-07-08 14:39:03 -04001845TIntermAggregate* TParseContext::addInterfaceBlock(const TPublicType& typeQualifier, const TSourceLoc& nameLine, const TString& blockName, TFieldList* fieldList,
1846 const TString* instanceName, const TSourceLoc& instanceLine, TIntermTyped* arrayIndex, const TSourceLoc& arrayIndexLine)
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001847{
1848 if (reservedErrorCheck(nameLine, blockName))
1849 recover();
1850
1851 if (typeQualifier.qualifier != EvqUniform)
1852 {
1853 error(typeQualifier.line, "invalid qualifier:", getQualifierString(typeQualifier.qualifier), "interface blocks must be uniform");
1854 recover();
1855 }
1856
Jamie Madill099c0f32013-06-20 11:55:52 -04001857 TLayoutQualifier blockLayoutQualifier = typeQualifier.layoutQualifier;
1858 if (layoutLocationErrorCheck(typeQualifier.line, blockLayoutQualifier))
Jamie Madilla5efff92013-06-06 11:56:47 -04001859 {
1860 recover();
1861 }
1862
Jamie Madill099c0f32013-06-20 11:55:52 -04001863 if (blockLayoutQualifier.matrixPacking == EmpUnspecified)
1864 {
1865 blockLayoutQualifier.matrixPacking = defaultMatrixPacking;
1866 }
1867
Jamie Madill1566ef72013-06-20 11:55:54 -04001868 if (blockLayoutQualifier.blockStorage == EbsUnspecified)
1869 {
1870 blockLayoutQualifier.blockStorage = defaultBlockStorage;
1871 }
1872
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001873 TSymbol* blockNameSymbol = new TInterfaceBlockName(&blockName);
Nicolas Capensadfffe42014-06-17 02:13:36 -04001874 if (!symbolTable.declare(blockNameSymbol)) {
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001875 error(nameLine, "redefinition", blockName.c_str(), "interface block name");
1876 recover();
1877 }
1878
Jamie Madill98493dd2013-07-08 14:39:03 -04001879 // check for sampler types and apply layout qualifiers
1880 for (size_t memberIndex = 0; memberIndex < fieldList->size(); ++memberIndex) {
1881 TField* field = (*fieldList)[memberIndex];
1882 TType* fieldType = field->type();
1883 if (IsSampler(fieldType->getBasicType())) {
1884 error(field->line(), "unsupported type", fieldType->getBasicString(), "sampler types are not allowed in interface blocks");
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001885 recover();
1886 }
1887
Jamie Madill98493dd2013-07-08 14:39:03 -04001888 const TQualifier qualifier = fieldType->getQualifier();
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001889 switch (qualifier)
1890 {
1891 case EvqGlobal:
1892 case EvqUniform:
1893 break;
1894 default:
Jamie Madill98493dd2013-07-08 14:39:03 -04001895 error(field->line(), "invalid qualifier on interface block member", getQualifierString(qualifier));
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001896 recover();
1897 break;
1898 }
Jamie Madilla5efff92013-06-06 11:56:47 -04001899
1900 // check layout qualifiers
Jamie Madill98493dd2013-07-08 14:39:03 -04001901 TLayoutQualifier fieldLayoutQualifier = fieldType->getLayoutQualifier();
1902 if (layoutLocationErrorCheck(field->line(), fieldLayoutQualifier))
Jamie Madilla5efff92013-06-06 11:56:47 -04001903 {
1904 recover();
1905 }
Jamie Madill099c0f32013-06-20 11:55:52 -04001906
Jamie Madill98493dd2013-07-08 14:39:03 -04001907 if (fieldLayoutQualifier.blockStorage != EbsUnspecified)
Jamie Madill1566ef72013-06-20 11:55:54 -04001908 {
Jamie Madill98493dd2013-07-08 14:39:03 -04001909 error(field->line(), "invalid layout qualifier:", getBlockStorageString(fieldLayoutQualifier.blockStorage), "cannot be used here");
Jamie Madill1566ef72013-06-20 11:55:54 -04001910 recover();
1911 }
1912
Jamie Madill98493dd2013-07-08 14:39:03 -04001913 if (fieldLayoutQualifier.matrixPacking == EmpUnspecified)
Jamie Madill099c0f32013-06-20 11:55:52 -04001914 {
Jamie Madill98493dd2013-07-08 14:39:03 -04001915 fieldLayoutQualifier.matrixPacking = blockLayoutQualifier.matrixPacking;
Jamie Madill099c0f32013-06-20 11:55:52 -04001916 }
Jamie Madill98493dd2013-07-08 14:39:03 -04001917 else if (!fieldType->isMatrix())
Jamie Madill099c0f32013-06-20 11:55:52 -04001918 {
Jamie Madill98493dd2013-07-08 14:39:03 -04001919 error(field->line(), "invalid layout qualifier:", getMatrixPackingString(fieldLayoutQualifier.matrixPacking), "can only be used on matrix types");
Jamie Madill099c0f32013-06-20 11:55:52 -04001920 recover();
1921 }
1922
Jamie Madill98493dd2013-07-08 14:39:03 -04001923 fieldType->setLayoutQualifier(fieldLayoutQualifier);
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001924 }
1925
Jamie Madill98493dd2013-07-08 14:39:03 -04001926 // add array index
1927 int arraySize = 0;
1928 if (arrayIndex != NULL)
1929 {
1930 if (arraySizeErrorCheck(arrayIndexLine, arrayIndex, arraySize))
1931 recover();
1932 }
1933
1934 TInterfaceBlock* interfaceBlock = new TInterfaceBlock(&blockName, fieldList, instanceName, arraySize, blockLayoutQualifier);
1935 TType interfaceBlockType(interfaceBlock, typeQualifier.qualifier, blockLayoutQualifier, arraySize);
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001936
1937 TString symbolName = "";
1938 int symbolId = 0;
1939
Jamie Madill98493dd2013-07-08 14:39:03 -04001940 if (!instanceName)
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001941 {
1942 // define symbols for the members of the interface block
Jamie Madill98493dd2013-07-08 14:39:03 -04001943 for (size_t memberIndex = 0; memberIndex < fieldList->size(); ++memberIndex)
1944 {
1945 TField* field = (*fieldList)[memberIndex];
1946 TType* fieldType = field->type();
1947
1948 // set parent pointer of the field variable
1949 fieldType->setInterfaceBlock(interfaceBlock);
1950
1951 TVariable* fieldVariable = new TVariable(&field->name(), *fieldType);
1952 fieldVariable->setQualifier(typeQualifier.qualifier);
1953
Nicolas Capensadfffe42014-06-17 02:13:36 -04001954 if (!symbolTable.declare(fieldVariable)) {
Jamie Madill98493dd2013-07-08 14:39:03 -04001955 error(field->line(), "redefinition", field->name().c_str(), "interface block member name");
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001956 recover();
1957 }
1958 }
1959 }
1960 else
1961 {
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001962 // add a symbol for this interface block
Jamie Madill98493dd2013-07-08 14:39:03 -04001963 TVariable* instanceTypeDef = new TVariable(instanceName, interfaceBlockType, false);
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001964 instanceTypeDef->setQualifier(typeQualifier.qualifier);
Jamie Madill98493dd2013-07-08 14:39:03 -04001965
Nicolas Capensadfffe42014-06-17 02:13:36 -04001966 if (!symbolTable.declare(instanceTypeDef)) {
Jamie Madill98493dd2013-07-08 14:39:03 -04001967 error(instanceLine, "redefinition", instanceName->c_str(), "interface block instance name");
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001968 recover();
1969 }
1970
1971 symbolId = instanceTypeDef->getUniqueId();
1972 symbolName = instanceTypeDef->getName();
1973 }
1974
Jamie Madill98493dd2013-07-08 14:39:03 -04001975 TIntermAggregate *aggregate = intermediate.makeAggregate(intermediate.addSymbol(symbolId, symbolName, interfaceBlockType, typeQualifier.line), nameLine);
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001976 aggregate->setOp(EOpDeclaration);
Jamie Madill98493dd2013-07-08 14:39:03 -04001977
1978 exitStructDeclaration();
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00001979 return aggregate;
1980}
1981
Jamie Madill075edd82013-07-08 13:30:19 -04001982bool TParseContext::enterStructDeclaration(const TSourceLoc& line, const TString& identifier)
kbr@chromium.org476541f2011-10-27 21:14:51 +00001983{
1984 ++structNestingLevel;
1985
1986 // Embedded structure definitions are not supported per GLSL ES spec.
1987 // They aren't allowed in GLSL either, but we need to detect this here
1988 // so we don't rely on the GLSL compiler to catch it.
1989 if (structNestingLevel > 1) {
maxvujovic@gmail.comc6b3b3c2012-06-27 22:49:39 +00001990 error(line, "", "Embedded struct definitions are not allowed");
kbr@chromium.org476541f2011-10-27 21:14:51 +00001991 return true;
1992 }
1993
1994 return false;
1995}
1996
1997void TParseContext::exitStructDeclaration()
1998{
1999 --structNestingLevel;
2000}
2001
2002namespace {
2003
2004const int kWebGLMaxStructNesting = 4;
2005
2006} // namespace
2007
Jamie Madill98493dd2013-07-08 14:39:03 -04002008bool TParseContext::structNestingErrorCheck(const TSourceLoc& line, const TField& field)
kbr@chromium.org476541f2011-10-27 21:14:51 +00002009{
Jamie Madill5508f392014-02-20 13:31:36 -05002010 if (!IsWebGLBasedSpec(shaderSpec)) {
kbr@chromium.org476541f2011-10-27 21:14:51 +00002011 return false;
2012 }
2013
Jamie Madill98493dd2013-07-08 14:39:03 -04002014 if (field.type()->getBasicType() != EbtStruct) {
kbr@chromium.org476541f2011-10-27 21:14:51 +00002015 return false;
2016 }
2017
2018 // We're already inside a structure definition at this point, so add
2019 // one to the field's struct nesting.
Jamie Madill98493dd2013-07-08 14:39:03 -04002020 if (1 + field.type()->getDeepestStructNesting() > kWebGLMaxStructNesting) {
Jamie Madill41a49272014-03-18 16:10:13 -04002021 std::stringstream reasonStream;
2022 reasonStream << "Reference of struct type "
2023 << field.type()->getStruct()->name().c_str()
2024 << " exceeds maximum allowed nesting level of "
2025 << kWebGLMaxStructNesting;
2026 std::string reason = reasonStream.str();
2027 error(line, reason.c_str(), field.name().c_str(), "");
kbr@chromium.org476541f2011-10-27 21:14:51 +00002028 return true;
2029 }
2030
2031 return false;
2032}
2033
alokp@chromium.org044a5cf2010-11-12 15:42:16 +00002034//
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002035// Parse an array index expression
2036//
Jamie Madill075edd82013-07-08 13:30:19 -04002037TIntermTyped* TParseContext::addIndexExpression(TIntermTyped *baseExpression, const TSourceLoc& location, TIntermTyped *indexExpression)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002038{
2039 TIntermTyped *indexedExpression = NULL;
2040
2041 if (!baseExpression->isArray() && !baseExpression->isMatrix() && !baseExpression->isVector())
2042 {
2043 if (baseExpression->getAsSymbolNode())
2044 {
2045 error(location, " left of '[' is not of type array, matrix, or vector ", baseExpression->getAsSymbolNode()->getSymbol().c_str());
2046 }
2047 else
2048 {
2049 error(location, " left of '[' is not of type array, matrix, or vector ", "expression");
2050 }
2051 recover();
2052 }
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00002053
Jamie Madill21c1e452014-12-29 11:33:41 -05002054 TIntermConstantUnion *indexConstantUnion = indexExpression->getAsConstantUnion();
2055
2056 if (indexExpression->getQualifier() == EvqConst && indexConstantUnion)
Jamie Madill7164cf42013-07-08 13:30:59 -04002057 {
Jamie Madill21c1e452014-12-29 11:33:41 -05002058 int index = indexConstantUnion->getIConst(0);
Jamie Madill7164cf42013-07-08 13:30:59 -04002059 if (index < 0)
2060 {
2061 std::stringstream infoStream;
2062 infoStream << index;
2063 std::string info = infoStream.str();
2064 error(location, "negative index", info.c_str());
2065 recover();
2066 index = 0;
2067 }
2068 if (baseExpression->getType().getQualifier() == EvqConst)
2069 {
2070 if (baseExpression->isArray())
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002071 {
Jamie Madill7164cf42013-07-08 13:30:59 -04002072 // constant folding for arrays
2073 indexedExpression = addConstArrayNode(index, baseExpression, location);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002074 }
Jamie Madill7164cf42013-07-08 13:30:59 -04002075 else if (baseExpression->isVector())
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002076 {
Jamie Madill7164cf42013-07-08 13:30:59 -04002077 // constant folding for vectors
2078 TVectorFields fields;
2079 fields.num = 1;
2080 fields.offsets[0] = index; // need to do it this way because v.xy sends fields integer array
2081 indexedExpression = addConstVectorNode(fields, baseExpression, location);
2082 }
2083 else if (baseExpression->isMatrix())
2084 {
2085 // constant folding for matrices
2086 indexedExpression = addConstMatrixNode(index, baseExpression, location);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002087 }
2088 }
2089 else
2090 {
Jamie Madill7164cf42013-07-08 13:30:59 -04002091 if (baseExpression->isArray())
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002092 {
Jamie Madill18464b52013-07-08 14:01:55 -04002093 if (index >= baseExpression->getType().getArraySize())
Jamie Madill7164cf42013-07-08 13:30:59 -04002094 {
2095 std::stringstream extraInfoStream;
2096 extraInfoStream << "array index out of range '" << index << "'";
2097 std::string extraInfo = extraInfoStream.str();
2098 error(location, "", "[", extraInfo.c_str());
2099 recover();
2100 index = baseExpression->getType().getArraySize() - 1;
2101 }
Jamie Madill5d287f52013-07-12 15:38:19 -04002102 else if (baseExpression->getQualifier() == EvqFragData && index > 0 && !isExtensionEnabled("GL_EXT_draw_buffers"))
2103 {
2104 error(location, "", "[", "array indexes for gl_FragData must be zero when GL_EXT_draw_buffers is disabled");
2105 recover();
2106 index = 0;
2107 }
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002108 }
Jamie Madill7164cf42013-07-08 13:30:59 -04002109 else if ((baseExpression->isVector() || baseExpression->isMatrix()) && baseExpression->getType().getNominalSize() <= index)
shannonwoods@chromium.orge429ab72013-05-30 00:12:52 +00002110 {
Jamie Madill7164cf42013-07-08 13:30:59 -04002111 std::stringstream extraInfoStream;
2112 extraInfoStream << "field selection out of range '" << index << "'";
2113 std::string extraInfo = extraInfoStream.str();
2114 error(location, "", "[", extraInfo.c_str());
shannonwoods@chromium.orge429ab72013-05-30 00:12:52 +00002115 recover();
Jamie Madill7164cf42013-07-08 13:30:59 -04002116 index = baseExpression->getType().getNominalSize() - 1;
Jamie Madill46131a32013-06-20 11:55:50 -04002117 }
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002118
Jamie Madill21c1e452014-12-29 11:33:41 -05002119 indexConstantUnion->getUnionArrayPointer()->setIConst(index);
Jamie Madill7164cf42013-07-08 13:30:59 -04002120 indexedExpression = intermediate.addIndex(EOpIndexDirect, baseExpression, indexExpression, location);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002121 }
2122 }
Jamie Madill7164cf42013-07-08 13:30:59 -04002123 else
2124 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002125 if (baseExpression->isInterfaceBlock())
Jamie Madill7164cf42013-07-08 13:30:59 -04002126 {
Jamie Madill19571812013-08-12 15:26:34 -07002127 error(location, "", "[", "array indexes for interface blocks arrays must be constant integral expressions");
Jamie Madill7164cf42013-07-08 13:30:59 -04002128 recover();
2129 }
Jamie Madill19571812013-08-12 15:26:34 -07002130 else if (baseExpression->getQualifier() == EvqFragmentOut)
Jamie Madill7164cf42013-07-08 13:30:59 -04002131 {
Jamie Madill19571812013-08-12 15:26:34 -07002132 error(location, "", "[", "array indexes for fragment outputs must be constant integral expressions");
Jamie Madill7164cf42013-07-08 13:30:59 -04002133 recover();
2134 }
2135
2136 indexedExpression = intermediate.addIndex(EOpIndexIndirect, baseExpression, indexExpression, location);
2137 }
2138
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002139 if (indexedExpression == 0)
2140 {
2141 ConstantUnion *unionArray = new ConstantUnion[1];
2142 unionArray->setFConst(0.0f);
2143 indexedExpression = intermediate.addConstantUnion(unionArray, TType(EbtFloat, EbpHigh, EvqConst), location);
2144 }
2145 else if (baseExpression->isArray())
2146 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002147 const TType &baseType = baseExpression->getType();
2148 if (baseType.getStruct())
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002149 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002150 TType copyOfType(baseType.getStruct());
2151 indexedExpression->setType(copyOfType);
2152 }
2153 else if (baseType.isInterfaceBlock())
2154 {
2155 TType copyOfType(baseType.getInterfaceBlock(), baseType.getQualifier(), baseType.getLayoutQualifier(), 0);
shannonwoods@chromium.orge429ab72013-05-30 00:12:52 +00002156 indexedExpression->setType(copyOfType);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002157 }
2158 else
2159 {
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00002160 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision(), EvqTemporary, baseExpression->getNominalSize(), baseExpression->getSecondarySize()));
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002161 }
2162
2163 if (baseExpression->getType().getQualifier() == EvqConst)
2164 {
2165 indexedExpression->getTypePointer()->setQualifier(EvqConst);
2166 }
2167 }
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002168 else if (baseExpression->isMatrix())
2169 {
Jamie Madill7164cf42013-07-08 13:30:59 -04002170 TQualifier qualifier = baseExpression->getType().getQualifier() == EvqConst ? EvqConst : EvqTemporary;
2171 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision(), qualifier, baseExpression->getRows()));
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002172 }
2173 else if (baseExpression->isVector())
2174 {
Jamie Madill7164cf42013-07-08 13:30:59 -04002175 TQualifier qualifier = baseExpression->getType().getQualifier() == EvqConst ? EvqConst : EvqTemporary;
2176 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision(), qualifier));
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002177 }
2178 else
2179 {
2180 indexedExpression->setType(baseExpression->getType());
2181 }
2182
2183 return indexedExpression;
2184}
2185
Jamie Madill075edd82013-07-08 13:30:19 -04002186TIntermTyped* TParseContext::addFieldSelectionExpression(TIntermTyped *baseExpression, const TSourceLoc& dotLocation, const TString &fieldString, const TSourceLoc& fieldLocation)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002187{
2188 TIntermTyped *indexedExpression = NULL;
2189
2190 if (baseExpression->isArray())
2191 {
2192 error(fieldLocation, "cannot apply dot operator to an array", ".");
2193 recover();
2194 }
2195
2196 if (baseExpression->isVector())
2197 {
2198 TVectorFields fields;
2199 if (!parseVectorFields(fieldString, baseExpression->getNominalSize(), fields, fieldLocation))
2200 {
2201 fields.num = 1;
2202 fields.offsets[0] = 0;
2203 recover();
2204 }
2205
2206 if (baseExpression->getType().getQualifier() == EvqConst)
2207 {
2208 // constant folding for vector fields
2209 indexedExpression = addConstVectorNode(fields, baseExpression, fieldLocation);
2210 if (indexedExpression == 0)
2211 {
2212 recover();
2213 indexedExpression = baseExpression;
2214 }
2215 else
2216 {
2217 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision(), EvqConst, (int) (fieldString).size()));
2218 }
2219 }
2220 else
2221 {
2222 TString vectorString = fieldString;
2223 TIntermTyped* index = intermediate.addSwizzle(fields, fieldLocation);
2224 indexedExpression = intermediate.addIndex(EOpVectorSwizzle, baseExpression, index, dotLocation);
2225 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision(), EvqTemporary, (int) vectorString.size()));
2226 }
2227 }
2228 else if (baseExpression->isMatrix())
2229 {
2230 TMatrixFields fields;
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00002231 if (!parseMatrixFields(fieldString, baseExpression->getCols(), baseExpression->getRows(), fields, fieldLocation))
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002232 {
2233 fields.wholeRow = false;
2234 fields.wholeCol = false;
2235 fields.row = 0;
2236 fields.col = 0;
2237 recover();
2238 }
2239
2240 if (fields.wholeRow || fields.wholeCol)
2241 {
2242 error(dotLocation, " non-scalar fields not implemented yet", ".");
2243 recover();
2244 ConstantUnion *unionArray = new ConstantUnion[1];
2245 unionArray->setIConst(0);
2246 TIntermTyped* index = intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), fieldLocation);
2247 indexedExpression = intermediate.addIndex(EOpIndexDirect, baseExpression, index, dotLocation);
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00002248 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision(),EvqTemporary, baseExpression->getCols(), baseExpression->getRows()));
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002249 }
2250 else
2251 {
2252 ConstantUnion *unionArray = new ConstantUnion[1];
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00002253 unionArray->setIConst(fields.col * baseExpression->getRows() + fields.row);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002254 TIntermTyped* index = intermediate.addConstantUnion(unionArray, TType(EbtInt, EbpUndefined, EvqConst), fieldLocation);
2255 indexedExpression = intermediate.addIndex(EOpIndexDirect, baseExpression, index, dotLocation);
2256 indexedExpression->setType(TType(baseExpression->getBasicType(), baseExpression->getPrecision()));
2257 }
2258 }
2259 else if (baseExpression->getBasicType() == EbtStruct)
2260 {
2261 bool fieldFound = false;
Jamie Madill98493dd2013-07-08 14:39:03 -04002262 const TFieldList& fields = baseExpression->getType().getStruct()->fields();
2263 if (fields.empty())
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002264 {
2265 error(dotLocation, "structure has no fields", "Internal Error");
2266 recover();
2267 indexedExpression = baseExpression;
2268 }
2269 else
2270 {
2271 unsigned int i;
Jamie Madill98493dd2013-07-08 14:39:03 -04002272 for (i = 0; i < fields.size(); ++i)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002273 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002274 if (fields[i]->name() == fieldString)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002275 {
2276 fieldFound = true;
2277 break;
2278 }
2279 }
2280 if (fieldFound)
2281 {
2282 if (baseExpression->getType().getQualifier() == EvqConst)
2283 {
2284 indexedExpression = addConstStruct(fieldString, baseExpression, dotLocation);
2285 if (indexedExpression == 0)
2286 {
2287 recover();
2288 indexedExpression = baseExpression;
2289 }
2290 else
2291 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002292 indexedExpression->setType(*fields[i]->type());
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002293 // change the qualifier of the return type, not of the structure field
2294 // as the structure definition is shared between various structures.
2295 indexedExpression->getTypePointer()->setQualifier(EvqConst);
2296 }
2297 }
2298 else
2299 {
2300 ConstantUnion *unionArray = new ConstantUnion[1];
2301 unionArray->setIConst(i);
Jamie Madill98493dd2013-07-08 14:39:03 -04002302 TIntermTyped* index = intermediate.addConstantUnion(unionArray, *fields[i]->type(), fieldLocation);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002303 indexedExpression = intermediate.addIndex(EOpIndexDirectStruct, baseExpression, index, dotLocation);
Jamie Madill98493dd2013-07-08 14:39:03 -04002304 indexedExpression->setType(*fields[i]->type());
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002305 }
2306 }
2307 else
2308 {
2309 error(dotLocation, " no such field in structure", fieldString.c_str());
2310 recover();
2311 indexedExpression = baseExpression;
2312 }
2313 }
2314 }
Jamie Madill98493dd2013-07-08 14:39:03 -04002315 else if (baseExpression->isInterfaceBlock())
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002316 {
2317 bool fieldFound = false;
Jamie Madill98493dd2013-07-08 14:39:03 -04002318 const TFieldList& fields = baseExpression->getType().getInterfaceBlock()->fields();
2319 if (fields.empty())
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002320 {
2321 error(dotLocation, "interface block has no fields", "Internal Error");
2322 recover();
2323 indexedExpression = baseExpression;
2324 }
2325 else
2326 {
2327 unsigned int i;
Jamie Madill98493dd2013-07-08 14:39:03 -04002328 for (i = 0; i < fields.size(); ++i)
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002329 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002330 if (fields[i]->name() == fieldString)
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002331 {
2332 fieldFound = true;
2333 break;
2334 }
2335 }
2336 if (fieldFound)
2337 {
2338 ConstantUnion *unionArray = new ConstantUnion[1];
2339 unionArray->setIConst(i);
Jamie Madill98493dd2013-07-08 14:39:03 -04002340 TIntermTyped* index = intermediate.addConstantUnion(unionArray, *fields[i]->type(), fieldLocation);
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002341 indexedExpression = intermediate.addIndex(EOpIndexDirectInterfaceBlock, baseExpression, index, dotLocation);
Jamie Madill98493dd2013-07-08 14:39:03 -04002342 indexedExpression->setType(*fields[i]->type());
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002343 }
2344 else
2345 {
2346 error(dotLocation, " no such field in interface block", fieldString.c_str());
2347 recover();
2348 indexedExpression = baseExpression;
2349 }
2350 }
2351 }
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002352 else
2353 {
shannonwoods@chromium.org5668c5d2013-05-30 00:11:48 +00002354 if (shaderVersion < 300)
2355 {
2356 error(dotLocation, " field selection requires structure, vector, or matrix on left hand side", fieldString.c_str());
2357 }
2358 else
2359 {
2360 error(dotLocation, " field selection requires structure, vector, matrix, or interface block on left hand side", fieldString.c_str());
2361 }
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002362 recover();
2363 indexedExpression = baseExpression;
2364 }
2365
2366 return indexedExpression;
2367}
2368
Jamie Madill075edd82013-07-08 13:30:19 -04002369TLayoutQualifier TParseContext::parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine)
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002370{
Jamie Madilla5efff92013-06-06 11:56:47 -04002371 TLayoutQualifier qualifier;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002372
Jamie Madilla5efff92013-06-06 11:56:47 -04002373 qualifier.location = -1;
2374 qualifier.matrixPacking = EmpUnspecified;
2375 qualifier.blockStorage = EbsUnspecified;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002376
2377 if (qualifierType == "shared")
2378 {
Jamie Madilla5efff92013-06-06 11:56:47 -04002379 qualifier.blockStorage = EbsShared;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002380 }
2381 else if (qualifierType == "packed")
2382 {
Jamie Madilla5efff92013-06-06 11:56:47 -04002383 qualifier.blockStorage = EbsPacked;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002384 }
2385 else if (qualifierType == "std140")
2386 {
Jamie Madilla5efff92013-06-06 11:56:47 -04002387 qualifier.blockStorage = EbsStd140;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002388 }
2389 else if (qualifierType == "row_major")
2390 {
Jamie Madilla5efff92013-06-06 11:56:47 -04002391 qualifier.matrixPacking = EmpRowMajor;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002392 }
2393 else if (qualifierType == "column_major")
2394 {
Jamie Madilla5efff92013-06-06 11:56:47 -04002395 qualifier.matrixPacking = EmpColumnMajor;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002396 }
2397 else if (qualifierType == "location")
2398 {
2399 error(qualifierTypeLine, "invalid layout qualifier", qualifierType.c_str(), "location requires an argument");
2400 recover();
2401 }
2402 else
2403 {
2404 error(qualifierTypeLine, "invalid layout qualifier", qualifierType.c_str());
2405 recover();
2406 }
2407
Jamie Madilla5efff92013-06-06 11:56:47 -04002408 return qualifier;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002409}
2410
Jamie Madill075edd82013-07-08 13:30:19 -04002411TLayoutQualifier TParseContext::parseLayoutQualifier(const TString &qualifierType, const TSourceLoc& qualifierTypeLine, const TString &intValueString, int intValue, const TSourceLoc& intValueLine)
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002412{
Jamie Madilla5efff92013-06-06 11:56:47 -04002413 TLayoutQualifier qualifier;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002414
Jamie Madilla5efff92013-06-06 11:56:47 -04002415 qualifier.location = -1;
2416 qualifier.matrixPacking = EmpUnspecified;
2417 qualifier.blockStorage = EbsUnspecified;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002418
2419 if (qualifierType != "location")
2420 {
2421 error(qualifierTypeLine, "invalid layout qualifier", qualifierType.c_str(), "only location may have arguments");
2422 recover();
2423 }
2424 else
2425 {
Jamie Madill05a80ce2013-06-20 11:55:49 -04002426 // must check that location is non-negative
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002427 if (intValue < 0)
2428 {
Jamie Madill05a80ce2013-06-20 11:55:49 -04002429 error(intValueLine, "out of range:", intValueString.c_str(), "location must be non-negative");
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002430 recover();
2431 }
2432 else
2433 {
Jamie Madilla5efff92013-06-06 11:56:47 -04002434 qualifier.location = intValue;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002435 }
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002436 }
2437
Jamie Madilla5efff92013-06-06 11:56:47 -04002438 return qualifier;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002439}
2440
Jamie Madilla5efff92013-06-06 11:56:47 -04002441TLayoutQualifier TParseContext::joinLayoutQualifiers(TLayoutQualifier leftQualifier, TLayoutQualifier rightQualifier)
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002442{
Jamie Madilla5efff92013-06-06 11:56:47 -04002443 TLayoutQualifier joinedQualifier = leftQualifier;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002444
Jamie Madilla5efff92013-06-06 11:56:47 -04002445 if (rightQualifier.location != -1)
2446 {
2447 joinedQualifier.location = rightQualifier.location;
2448 }
2449 if (rightQualifier.matrixPacking != EmpUnspecified)
2450 {
2451 joinedQualifier.matrixPacking = rightQualifier.matrixPacking;
2452 }
2453 if (rightQualifier.blockStorage != EbsUnspecified)
2454 {
2455 joinedQualifier.blockStorage = rightQualifier.blockStorage;
2456 }
2457
2458 return joinedQualifier;
shannonwoods@chromium.org302adfe2013-05-30 00:21:06 +00002459}
2460
Jamie Madillf2e0f9b2013-08-26 16:39:42 -04002461TPublicType TParseContext::joinInterpolationQualifiers(const TSourceLoc &interpolationLoc, TQualifier interpolationQualifier,
2462 const TSourceLoc &storageLoc, TQualifier storageQualifier)
2463{
2464 TQualifier mergedQualifier = EvqSmoothIn;
2465
Jamie Madill19571812013-08-12 15:26:34 -07002466 if (storageQualifier == EvqFragmentIn) {
Jamie Madillf2e0f9b2013-08-26 16:39:42 -04002467 if (interpolationQualifier == EvqSmooth)
2468 mergedQualifier = EvqSmoothIn;
2469 else if (interpolationQualifier == EvqFlat)
2470 mergedQualifier = EvqFlatIn;
2471 else UNREACHABLE();
2472 }
2473 else if (storageQualifier == EvqCentroidIn) {
2474 if (interpolationQualifier == EvqSmooth)
2475 mergedQualifier = EvqCentroidIn;
2476 else if (interpolationQualifier == EvqFlat)
2477 mergedQualifier = EvqFlatIn;
2478 else UNREACHABLE();
2479 }
Jamie Madill19571812013-08-12 15:26:34 -07002480 else if (storageQualifier == EvqVertexOut) {
Jamie Madillf2e0f9b2013-08-26 16:39:42 -04002481 if (interpolationQualifier == EvqSmooth)
2482 mergedQualifier = EvqSmoothOut;
2483 else if (interpolationQualifier == EvqFlat)
2484 mergedQualifier = EvqFlatOut;
2485 else UNREACHABLE();
2486 }
2487 else if (storageQualifier == EvqCentroidOut) {
2488 if (interpolationQualifier == EvqSmooth)
2489 mergedQualifier = EvqCentroidOut;
2490 else if (interpolationQualifier == EvqFlat)
2491 mergedQualifier = EvqFlatOut;
2492 else UNREACHABLE();
2493 }
2494 else {
2495 error(interpolationLoc, "interpolation qualifier requires a fragment 'in' or vertex 'out' storage qualifier", getInterpolationString(interpolationQualifier));
2496 recover();
2497
2498 mergedQualifier = storageQualifier;
2499 }
2500
2501 TPublicType type;
2502 type.setBasic(EbtVoid, mergedQualifier, storageLoc);
2503 return type;
2504}
2505
Jamie Madill98493dd2013-07-08 14:39:03 -04002506TFieldList *TParseContext::addStructDeclaratorList(const TPublicType& typeSpecifier, TFieldList *fieldList)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002507{
Jamie Madill98493dd2013-07-08 14:39:03 -04002508 if (voidErrorCheck(typeSpecifier.line, (*fieldList)[0]->name(), typeSpecifier)) {
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002509 recover();
2510 }
2511
Jamie Madill98493dd2013-07-08 14:39:03 -04002512 for (unsigned int i = 0; i < fieldList->size(); ++i) {
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002513 //
2514 // Careful not to replace already known aspects of type, like array-ness
2515 //
Jamie Madill98493dd2013-07-08 14:39:03 -04002516 TType* type = (*fieldList)[i]->type();
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002517 type->setBasicType(typeSpecifier.type);
shannonwoods@chromium.org09e09882013-05-30 00:18:25 +00002518 type->setPrimarySize(typeSpecifier.primarySize);
2519 type->setSecondarySize(typeSpecifier.secondarySize);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002520 type->setPrecision(typeSpecifier.precision);
2521 type->setQualifier(typeSpecifier.qualifier);
Jamie Madilla5efff92013-06-06 11:56:47 -04002522 type->setLayoutQualifier(typeSpecifier.layoutQualifier);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002523
2524 // don't allow arrays of arrays
2525 if (type->isArray()) {
2526 if (arrayTypeErrorCheck(typeSpecifier.line, typeSpecifier))
2527 recover();
2528 }
2529 if (typeSpecifier.array)
2530 type->setArraySize(typeSpecifier.arraySize);
2531 if (typeSpecifier.userDef) {
2532 type->setStruct(typeSpecifier.userDef->getStruct());
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002533 }
2534
Jamie Madill98493dd2013-07-08 14:39:03 -04002535 if (structNestingErrorCheck(typeSpecifier.line, *(*fieldList)[i])) {
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002536 recover();
2537 }
2538 }
2539
Jamie Madill98493dd2013-07-08 14:39:03 -04002540 return fieldList;
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002541}
2542
Jamie Madill98493dd2013-07-08 14:39:03 -04002543TPublicType TParseContext::addStructure(const TSourceLoc& structLine, const TSourceLoc& nameLine, const TString *structName, TFieldList* fieldList)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002544{
Jamie Madill98493dd2013-07-08 14:39:03 -04002545 TStructure* structure = new TStructure(structName, fieldList);
2546 TType* structureType = new TType(structure);
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002547
Jamie Madillbfa91f42014-06-05 15:45:18 -04002548 structure->setUniqueId(TSymbolTable::nextUniqueId());
2549
Jamie Madill98493dd2013-07-08 14:39:03 -04002550 if (!structName->empty())
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002551 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002552 if (reservedErrorCheck(nameLine, *structName))
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002553 {
2554 recover();
2555 }
Jamie Madill98493dd2013-07-08 14:39:03 -04002556 TVariable* userTypeDef = new TVariable(structName, *structureType, true);
Nicolas Capensadfffe42014-06-17 02:13:36 -04002557 if (!symbolTable.declare(userTypeDef)) {
Jamie Madill98493dd2013-07-08 14:39:03 -04002558 error(nameLine, "redefinition", structName->c_str(), "struct");
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002559 recover();
2560 }
2561 }
2562
2563 // ensure we do not specify any storage qualifiers on the struct members
Jamie Madill98493dd2013-07-08 14:39:03 -04002564 for (unsigned int typeListIndex = 0; typeListIndex < fieldList->size(); typeListIndex++)
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002565 {
Jamie Madill98493dd2013-07-08 14:39:03 -04002566 const TField &field = *(*fieldList)[typeListIndex];
2567 const TQualifier qualifier = field.type()->getQualifier();
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002568 switch (qualifier)
2569 {
2570 case EvqGlobal:
2571 case EvqTemporary:
2572 break;
2573 default:
Jamie Madill98493dd2013-07-08 14:39:03 -04002574 error(field.line(), "invalid qualifier on struct member", getQualifierString(qualifier));
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002575 recover();
2576 break;
2577 }
2578 }
2579
2580 TPublicType publicType;
2581 publicType.setBasic(EbtStruct, EvqTemporary, structLine);
Jamie Madill98493dd2013-07-08 14:39:03 -04002582 publicType.userDef = structureType;
shannonwoods@chromium.orga9100882013-05-30 00:11:39 +00002583 exitStructDeclaration();
2584
2585 return publicType;
2586}
2587
2588//
alokp@chromium.org044a5cf2010-11-12 15:42:16 +00002589// Parse an array of strings using yyparse.
2590//
2591// Returns 0 for success.
2592//
shannon.woods@transgaming.comd64b3da2013-02-28 23:19:26 +00002593int PaParseStrings(size_t count, const char* const string[], const int length[],
alokp@chromium.org044a5cf2010-11-12 15:42:16 +00002594 TParseContext* context) {
2595 if ((count == 0) || (string == NULL))
2596 return 1;
2597
alokp@chromium.org044a5cf2010-11-12 15:42:16 +00002598 if (glslang_initialize(context))
2599 return 1;
2600
alokp@chromium.org408c45e2012-04-05 15:54:43 +00002601 int error = glslang_scan(count, string, length, context);
2602 if (!error)
2603 error = glslang_parse(context);
alokp@chromium.org044a5cf2010-11-12 15:42:16 +00002604
alokp@chromium.org73bc2982012-06-19 18:48:05 +00002605 glslang_finalize(context);
alokp@chromium.org8b851c62012-06-15 16:25:11 +00002606
alokp@chromium.org6b495712012-06-29 00:06:58 +00002607 return (error == 0) && (context->numErrors() == 0) ? 0 : 1;
alokp@chromium.org044a5cf2010-11-12 15:42:16 +00002608}
2609
daniel@transgaming.com4f39fd92010-03-08 20:26:45 +00002610
alokp@chromium.org34b99cd2010-07-27 18:37:55 +00002611