RPCS3/glslang
1
0
Fork 0
mirror of https://github.com/RPCS3/glslang.git synced 2024-11-30 22:51:06 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
6c5f649ae8
glslang/hlsl/hlslGrammar.cpp

4121 lines
126 KiB
C++
Raw Normal View History

HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Copyright (C) 2016 Google, Inc.
// Copyright (C) 2016 LunarG, Inc.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// All rights reserved.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
// Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
//
// Neither the name of Google, Inc., nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
Non-functional: White space after "//", mostly for copyrights.
2017-01-06 19:34:14 +00:00
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
//
// This is a set of mutually recursive methods implementing the HLSL grammar.
// Generally, each returns
// - through an argument: a type specifically appropriate to which rule it
// recognized
// - through the return value: true/false to indicate whether or not it
// recognized its rule
//
// As much as possible, only grammar recognition should happen in this file,
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// with all other work being farmed out to hlslParseHelper.cpp, which in turn
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
// will build the AST.
//
// The next token, yet to be "accepted" is always sitting in 'token'.
// When a method says it accepts a rule, that means all tokens involved
// in the rule will have been consumed, and none left in 'token'.
//
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
#include "hlslTokens.h"
#include "hlslGrammar.h"
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
#include "hlslAttributes.h"
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
namespace glslang {
// Root entry point to this recursive decent parser.
// Return true if compilation unit was successfully accepted.
bool HlslGrammar::parse()
{
advanceToken();
return acceptCompilationUnit();
}
void HlslGrammar::expected(const char* syntax)
{
parseContext.error(token.loc, "Expected", syntax, "");
}
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
void HlslGrammar::unimplemented(const char* error)
{
parseContext.error(token.loc, "Unimplemented", error, "");
}
HLSL: Implement 'this' keyword.
2017-03-22 17:38:22 +00:00
// IDENTIFIER
// THIS
// type that can be used as IDENTIFIER
//
HLSL: Abstract accepting an identifier.
2016-03-14 16:46:34 +00:00
// Only process the next token if it is an identifier.
// Return true if it was an identifier.
bool HlslGrammar::acceptIdentifier(HlslToken& idToken)
{
HLSL: Implement 'this' keyword.
2017-03-22 17:38:22 +00:00
// IDENTIFIER
HLSL: Abstract accepting an identifier.
2016-03-14 16:46:34 +00:00
if (peekTokenClass(EHTokIdentifier)) {
idToken = token;
advanceToken();
return true;
}
HLSL: Implement 'this' keyword.
2017-03-22 17:38:22 +00:00
// THIS
// -> maps to the IDENTIFIER spelled with the internal special name for 'this'
if (peekTokenClass(EHTokThis)) {
idToken = token;
advanceToken();
idToken.tokenClass = EHTokIdentifier;
idToken.string = NewPoolTString(intermediate.implicitThisName);
return true;
}
// type that can be used as IDENTIFIER
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
// Even though "sample", "bool", "float", etc keywords (for types, interpolation modifiers),
// they ARE still accepted as identifiers. This is not a dense space: e.g, "void" is not a
// valid identifier, nor is "linear". This code special cases the known instances of this, so
// e.g, "int sample;" or "float float;" is accepted. Other cases can be added here if needed.
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Recognize types declared as identifiers as identifiers. E.g., in float float; (float) * float; The "(float)" is not a type cast, it is an expression.
2017-06-14 04:22:52 +00:00
const char* idString = getTypeString(peek());
if (idString == nullptr)
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
return false;
HLSL: allow "sample" as a valid identifier. HLSL has keywords for various interpolation modifiers such as "linear", "centroid", "sample", etc. Of these, "sample" appears to be special, as it is also accepted as an identifier string, where the others are not. This PR adds this ability, so the construct "int sample = 42;" no longer produces a compilation error. New test = hlsl.identifier.sample.frag
2016-11-16 20:22:11 +00:00
HLSL: Recognize types declared as identifiers as identifiers. E.g., in float float; (float) * float; The "(float)" is not a type cast, it is an expression.
2017-06-14 04:22:52 +00:00
token.string = NewPoolTString(idString);
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
token.tokenClass = EHTokIdentifier;
HLSL: Recognize types declared as identifiers as identifiers. E.g., in float float; (float) * float; The "(float)" is not a type cast, it is an expression.
2017-06-14 04:22:52 +00:00
idToken = token;
typeIdentifiers = true;
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
advanceToken();
return true;
HLSL: Abstract accepting an identifier.
2016-03-14 16:46:34 +00:00
}
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
// compilationUnit
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// : declaration_list EOF
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
//
bool HlslGrammar::acceptCompilationUnit()
{
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
TIntermNode* unitNode = nullptr;
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
if (! acceptDeclarationList(unitNode))
return false;
HLSL: allow semicolons between global scope declarations.
2016-08-03 13:04:18 +00:00
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
if (! peekTokenClass(EHTokNone))
return false;
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
// set root of AST
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
if (unitNode && !unitNode->getAsAggregate())
unitNode = intermediate.growAggregate(nullptr, unitNode);
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
intermediate.setTreeRoot(unitNode);
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
return true;
}
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// Recognize the following, but with the extra condition that it can be
// successfully terminated by EOF or '}'.
//
// declaration_list
// : list of declaration_or_semicolon followed by EOF or RIGHT_BRACE
//
// declaration_or_semicolon
// : declaration
// : SEMICOLON
//
bool HlslGrammar::acceptDeclarationList(TIntermNode*& nodeList)
{
do {
// HLSL allows extra semicolons between global declarations
do { } while (acceptTokenClass(EHTokSemicolon));
// EOF or RIGHT_BRACE
if (peekTokenClass(EHTokNone) || peekTokenClass(EHTokRightBrace))
return true;
// declaration
if (! acceptDeclaration(nodeList))
return false;
} while (true);
return true;
}
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// sampler_state
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
// : LEFT_BRACE [sampler_state_assignment ... ] RIGHT_BRACE
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
//
// sampler_state_assignment
// : sampler_state_identifier EQUAL value SEMICOLON
//
// sampler_state_identifier
// : ADDRESSU
// | ADDRESSV
// | ADDRESSW
// | BORDERCOLOR
// | FILTER
// | MAXANISOTROPY
// | MAXLOD
// | MINLOD
// | MIPLODBIAS
//
bool HlslGrammar::acceptSamplerState()
{
// TODO: this should be genericized to accept a list of valid tokens and
// return token/value pairs. Presently it is specific to texture values.
if (! acceptTokenClass(EHTokLeftBrace))
return true;
parseContext.warn(token.loc, "unimplemented", "immediate sampler state", "");
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
do {
// read state name
HlslToken state;
if (! acceptIdentifier(state))
break; // end of list
// FXC accepts any case
TString stateName = *state.string;
std::transform(stateName.begin(), stateName.end(), stateName.begin(), ::tolower);
if (! acceptTokenClass(EHTokAssign)) {
expected("assign");
return false;
}
if (stateName == "minlod" || stateName == "maxlod") {
if (! peekTokenClass(EHTokIntConstant)) {
expected("integer");
return false;
}
TIntermTyped* lod = nullptr;
if (! acceptLiteral(lod)) // should never fail, since we just looked for an integer
return false;
} else if (stateName == "maxanisotropy") {
if (! peekTokenClass(EHTokIntConstant)) {
expected("integer");
return false;
}
TIntermTyped* maxAnisotropy = nullptr;
if (! acceptLiteral(maxAnisotropy)) // should never fail, since we just looked for an integer
return false;
} else if (stateName == "filter") {
HlslToken filterMode;
if (! acceptIdentifier(filterMode)) {
expected("filter mode");
return false;
}
} else if (stateName == "addressu" || stateName == "addressv" || stateName == "addressw") {
HlslToken addrMode;
if (! acceptIdentifier(addrMode)) {
expected("texture address mode");
return false;
}
} else if (stateName == "miplodbias") {
TIntermTyped* lodBias = nullptr;
if (! acceptLiteral(lodBias)) {
expected("lod bias");
return false;
}
} else if (stateName == "bordercolor") {
return false;
} else {
expected("texture state");
return false;
}
// SEMICOLON
if (! acceptTokenClass(EHTokSemicolon)) {
expected("semicolon");
return false;
}
} while (true);
if (! acceptTokenClass(EHTokRightBrace))
return false;
return true;
}
// sampler_declaration_dx9
// : SAMPLER identifier EQUAL sampler_type sampler_state
//
Build: Fix three new warnings in HLSL code.
2016-07-16 16:19:43 +00:00
bool HlslGrammar::acceptSamplerDeclarationDX9(TType& /*type*/)
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
{
if (! acceptTokenClass(EHTokSampler))
return false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// TODO: remove this when DX9 style declarations are implemented.
unimplemented("Direct3D 9 sampler declaration");
// read sampler name
HlslToken name;
if (! acceptIdentifier(name)) {
expected("sampler name");
return false;
}
if (! acceptTokenClass(EHTokAssign)) {
expected("=");
return false;
}
return false;
}
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
// declaration
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
// : attributes attributed_declaration
// | NAMESPACE IDENTIFIER LEFT_BRACE declaration_list RIGHT_BRACE
//
// attributed_declaration
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// : sampler_declaration_dx9 post_decls SEMICOLON
HLSL: Non-functional: Make test valid HLSL, and related comments/cleanup.
2017-06-19 21:13:26 +00:00
// | fully_specified_type // for cbuffer/tbuffer
// | fully_specified_type declarator_list SEMICOLON // for non cbuffer/tbuffer
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
// | fully_specified_type identifier function_parameters post_decls compound_statement // function definition
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// | fully_specified_type identifier sampler_state post_decls compound_statement // sampler definition
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
// | typedef declaration
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
//
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// declarator_list
// : declarator COMMA declarator COMMA declarator... // zero or more declarators
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
//
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// declarator
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
// : identifier array_specifier post_decls
// | identifier array_specifier post_decls EQUAL assignment_expression
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// | identifier function_parameters post_decls // function prototype
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
//
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// Parsing has to go pretty far in to know whether it's a variable, prototype, or
// function definition, so the implementation below doesn't perfectly divide up the grammar
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
// as above. (The 'identifier' in the first item in init_declarator list is the
// same as 'identifier' for function declarations.)
//
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
// This can generate more than one subtree, one per initializer or a function body.
// All initializer subtrees are put in their own aggregate node, making one top-level
// node for all the initializers. Each function created is a top-level node to grow
// into the passed-in nodeList.
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
//
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
// If 'nodeList' is passed in as non-null, it must an aggregate to extend for
// each top-level node the declaration creates. Otherwise, if only one top-level
// node in generated here, that is want is returned in nodeList.
HLSL: Wrap the entry-point; need to write 'in' args, and support 'inout' args. This needs some render testing, but is destined to be part of master. This also leads to a variety of other simplifications. - IO are global symbols, so only need one list of linkage nodes (deferred) - no longer need parse-context-wide 'inEntryPoint' state, entry-point is localized - several parts of splitting/flattening are now localized
2017-01-19 22:41:47 +00:00
//
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
bool HlslGrammar::acceptDeclaration(TIntermNode*& nodeList)
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
{
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// NAMESPACE IDENTIFIER LEFT_BRACE declaration_list RIGHT_BRACE
if (acceptTokenClass(EHTokNamespace)) {
HlslToken namespaceToken;
if (!acceptIdentifier(namespaceToken)) {
expected("namespace name");
return false;
}
parseContext.pushNamespace(*namespaceToken.string);
if (!acceptTokenClass(EHTokLeftBrace)) {
expected("{");
return false;
}
if (!acceptDeclarationList(nodeList)) {
expected("declaration list");
return false;
}
if (!acceptTokenClass(EHTokRightBrace)) {
expected("}");
return false;
}
parseContext.popNamespace();
return true;
}
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
bool declarator_list = false; // true when processing comma separation
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
// attributes
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
TFunctionDeclarator declarator;
acceptAttributes(declarator.attributes);
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
// typedef
bool typedefDecl = acceptTokenClass(EHTokTypedef);
HLSL: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
TType declaredType;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// DX9 sampler declaration use a different syntax
Whitespace: Nonfunctional: fix inconsistent white space, esp. no tabs.
2016-08-05 23:34:34 +00:00
// DX9 shaders need to run through HLSL compiler (fxc) via a back compat mode, it isn't going to
// be possible to simultaneously compile D3D10+ style shaders and DX9 shaders. If we want to compile DX9
// HLSL shaders, this will have to be a master level switch
// As such, the sampler keyword in D3D10+ turns into an automatic sampler type, and is commonly used
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
// For that reason, this line is commented out
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
// if (acceptSamplerDeclarationDX9(declaredType))
// return true;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
bool forbidDeclarators = (peekTokenClass(EHTokCBuffer) || peekTokenClass(EHTokTBuffer));
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// fully_specified_type
HLSL: Fix #1203: Declare anonymous members for cbuffer with no ';' The grammar for no semicolon and no object name for cbuffer/tbuffer was correct, but the production still skipped the anonymous declarations if an identifier followed.
2018-01-02 18:27:54 +00:00
if (! acceptFullySpecifiedType(declaredType, nodeList, declarator.attributes, forbidDeclarators))
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return false;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
// cbuffer and tbuffer end with the closing '}'.
// No semicolon is included.
if (forbidDeclarators)
return true;
HLSL: Non-functional: Make test valid HLSL, and related comments/cleanup.
2017-06-19 21:13:26 +00:00
// declarator_list
// : declarator
// : identifier
HLSL: Abstract accepting an identifier.
2016-03-14 16:46:34 +00:00
HlslToken idToken;
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
TIntermAggregate* initializers = nullptr;
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
while (acceptIdentifier(idToken)) {
GLSL: Promote HLSL entry-point renaming code to be used by GLSL as well. Fixes #1045.
2017-09-12 03:48:19 +00:00
TString *fullName = idToken.string;
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
if (parseContext.symbolTable.atGlobalLevel())
parseContext.getFullNamespaceName(fullName);
HLSL: Non-functional: Don't process function name/parameters before expected a function declaration.
2017-03-09 01:53:51 +00:00
if (peekTokenClass(EHTokLeftParen)) {
// looks like function parameters
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
// merge in the attributes into the return type
parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType, true);
HLSL: Non-functional: Don't process function name/parameters before expected a function declaration.
2017-03-09 01:53:51 +00:00
// Potentially rename shader entry point function. No-op most of the time.
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
parseContext.renameShaderFunction(fullName);
HLSL: Non-functional: Don't process function name/parameters before expected a function declaration.
2017-03-09 01:53:51 +00:00
// function_parameters
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
declarator.function = new TFunction(fullName, declaredType);
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
if (!acceptFunctionParameters(*declarator.function)) {
HLSL: Non-functional: Don't process function name/parameters before expected a function declaration.
2017-03-09 01:53:51 +00:00
expected("function parameter list");
return false;
}
allow renaming of shader entry point when creating SPIR-V Use "--source-entrypoint name" on the command line, or the TShader::setSourceEntryPoint(char*) API. When the name given to the above interfaces is detected in the shader source, it will be renamed to the entry point name supplied to the -e option or the TShader::setEntryPoint() method.
2016-10-31 21:13:43 +00:00
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// post_decls
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
acceptPostDecls(declarator.function->getWritableType().getQualifier());
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// compound_statement (function body definition) or just a prototype?
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
declarator.loc = token.loc;
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
if (peekTokenClass(EHTokLeftBrace)) {
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
if (declarator_list)
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
parseContext.error(idToken.loc, "function body can't be in a declarator list", "{", "");
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
if (typedefDecl)
parseContext.error(idToken.loc, "function body can't be in a typedef", "{", "");
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
return acceptFunctionDefinition(declarator, nodeList, nullptr);
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
} else {
if (typedefDecl)
parseContext.error(idToken.loc, "function typedefs not implemented", "{", "");
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, true);
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
}
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
} else {
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
// A variable declaration.
// merge in the attributes, the first time around, into the shared type
if (! declarator_list)
parseContext.transferTypeAttributes(token.loc, declarator.attributes, declaredType);
// Fix the storage qualifier if it's a global.
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
if (declaredType.getQualifier().storage == EvqTemporary && parseContext.symbolTable.atGlobalLevel())
declaredType.getQualifier().storage = EvqUniform;
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
// recognize array_specifier
TArraySizes* arraySizes = nullptr;
acceptArraySpecifier(arraySizes);
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
// We can handle multiple variables per type declaration, so
HLSL: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
// the number of types can expand when arrayness is different.
TType variableType;
variableType.shallowCopy(declaredType);
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
// In the most general case, arrayness is potentially coming both from the
// declared type and from the variable: "int[] a[];" or just one or the other.
// Merge it all to the variableType, so all arrayness is part of the variableType.
variableType.transferArraySizes(arraySizes);
variableType.copyArrayInnerSizes(declaredType.getArraySizes());
HLSL: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// samplers accept immediate sampler state
HLSL: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
if (variableType.getBasicType() == EbtSampler) {
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
if (! acceptSamplerState())
return false;
}
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// post_decls
HLSL: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
acceptPostDecls(variableType.getQualifier());
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
// EQUAL assignment_expression
TIntermTyped* expressionNode = nullptr;
if (acceptTokenClass(EHTokAssign)) {
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
if (typedefDecl)
parseContext.error(idToken.loc, "can't have an initializer", "typedef", "");
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
if (! acceptAssignmentExpression(expressionNode)) {
expected("initializer");
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
return false;
}
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
}
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
// TODO: things scoped within an annotation need their own name space;
// TODO: strings are not yet handled.
if (variableType.getBasicType() != EbtString && parseContext.getAnnotationNestingLevel() == 0) {
if (typedefDecl)
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
parseContext.declareTypedef(idToken.loc, *fullName, variableType);
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
else if (variableType.getBasicType() == EbtBlock) {
HLSL: Give error on unsupported buffer initializer.
2017-12-09 11:42:42 +00:00
if (expressionNode)
parseContext.error(idToken.loc, "buffer aliasing not yet supported", "block initializer", "");
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
parseContext.declareBlock(idToken.loc, variableType, fullName);
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
parseContext.declareStructBufferCounter(idToken.loc, variableType, *fullName);
} else {
HLSL: Recursive composite flattening This PR implements recursive type flattening. For example, an array of structs of other structs can be flattened to individual member variables at the shader interface. This is sufficient for many purposes, e.g, uniforms containing opaque types, but is not sufficient for geometry shader arrayed inputs. That will be handled separately with structure splitting, which is not implemented by this PR. In the meantime, that case is detected and triggers an error. The recursive flattening extends the following three aspects of single-level flattening: - Flattening of structures to individual members with names such as "foo[0].samp[1]"; - Turning constant references to the nested composite type into a reference to a particular flattened member. - Shadow copies between arrays of flattened members and the nested composite type. Previous single-level flattening only flattened at the shader interface, and that is unchanged by this PR. Internally, shadow copies are, such as if the type is passed to a function. Also, the reasons for flattening are unchanged. Uniforms containing opaque types, and interface struct types are flattened. (The latter will change with structure splitting). One existing test changes: hlsl.structin.vert, which did in fact contain a nested composite type to be flattened. Two new tests are added: hlsl.structarray.flatten.frag, and hlsl.structarray.flatten.geom (currently issues an error until type splitting is online). The process of arriving at the individual member from chained postfix expressions is more complex than it was with one level. See large-ish comment above HlslParseContext::flatten() for details.
2016-11-29 00:09:54 +00:00
if (variableType.getQualifier().storage == EvqUniform && ! variableType.containsOpaque()) {
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
// this isn't really an individual variable, but a member of the $Global buffer
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
parseContext.growGlobalUniformBlock(idToken.loc, variableType, *fullName);
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
} else {
// Declare the variable and add any initializer code to the AST.
// The top-level node is always made into an aggregate, as that's
// historically how the AST has been.
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
initializers = intermediate.growAggregate(initializers,
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
parseContext.declareVariable(idToken.loc, *fullName, variableType, expressionNode),
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
idToken.loc);
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
}
}
HLSL: Add typedef grammar and production.
2016-07-05 06:02:40 +00:00
}
HLSL: Grammar: Make comma-separated declaration lists work.
2016-07-02 01:06:44 +00:00
}
HLSL: Non-functional: Make test valid HLSL, and related comments/cleanup.
2017-06-19 21:13:26 +00:00
// COMMA
if (acceptTokenClass(EHTokComma))
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
declarator_list = true;
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
// The top-level initializer node is a sequence.
if (initializers != nullptr)
initializers->setOperator(EOpSequence);
// Add the initializers' aggregate to the nodeList we were handed.
if (nodeList)
nodeList = intermediate.growAggregate(nodeList, initializers);
else
nodeList = initializers;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
// SEMICOLON
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
if (! acceptTokenClass(EHTokSemicolon)) {
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
// This may have been a false detection of what appeared to be a declaration, but
// was actually an assignment such as "float = 4", where "float" is an identifier.
// We put the token back to let further parsing happen for cases where that may
// happen. This errors on the side of caution, and mostly triggers the error.
HLSL: Fix #832: don't require terminating semicolon for cbuffer/tbuffer.
2017-04-11 15:51:32 +00:00
if (peek() == EHTokAssign || peek() == EHTokLeftBracket || peek() == EHTokDot || peek() == EHTokComma) {
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
recedeToken();
HLSL: Fix #832: don't require terminating semicolon for cbuffer/tbuffer.
2017-04-11 15:51:32 +00:00
return false;
} else {
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
expected(";");
HLSL: Fix #832: don't require terminating semicolon for cbuffer/tbuffer.
2017-04-11 15:51:32 +00:00
return false;
}
HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
2016-07-04 23:32:45 +00:00
}
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return true;
}
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
// control_declaration
// : fully_specified_type identifier EQUAL expression
//
bool HlslGrammar::acceptControlDeclaration(TIntermNode*& node)
{
node = nullptr;
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
TAttributes attributes;
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
// fully_specified_type
TType type;
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
if (! acceptFullySpecifiedType(type, attributes))
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
return false;
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
if (attributes.size() > 0)
parseContext.warn(token.loc, "attributes don't apply to control declaration", "", "");
HLSL: Fix #754: recognize type casts in if-statements separately from declarations.
2017-03-07 01:18:37 +00:00
// filter out type casts
if (peekTokenClass(EHTokLeftParen)) {
recedeToken();
return false;
}
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
// identifier
HlslToken idToken;
if (! acceptIdentifier(idToken)) {
expected("identifier");
return false;
}
// EQUAL
TIntermTyped* expressionNode = nullptr;
if (! acceptTokenClass(EHTokAssign)) {
expected("=");
return false;
}
// expression
if (! acceptExpression(expressionNode)) {
expected("initializer");
return false;
}
HLSL: Rationalize combination of type arrayness and name arrayness.
2016-09-27 20:38:57 +00:00
node = parseContext.declareVariable(idToken.loc, *idToken.string, type, expressionNode);
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
return true;
}
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
// fully_specified_type
// : type_specifier
// | type_qualifier type_specifier
//
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
bool HlslGrammar::acceptFullySpecifiedType(TType& type, const TAttributes& attributes)
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
{
TIntermNode* nodeList = nullptr;
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
return acceptFullySpecifiedType(type, nodeList, attributes);
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
}
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
bool HlslGrammar::acceptFullySpecifiedType(TType& type, TIntermNode*& nodeList, const TAttributes& attributes, bool forbidDeclarators)
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
{
// type_qualifier
TQualifier qualifier;
qualifier.clear();
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
if (! acceptQualifier(qualifier))
return false;
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
TSourceLoc loc = token.loc;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
// type_specifier
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
if (! acceptType(type, nodeList)) {
HLSL: allow "sample" in expressions. Unlike other qualifiers, HLSL allows "sample" to be either a qualifier keyword or an identifier (e.g, a variable or function name). A fix to allow this was made a while ago, but that fix was insufficient when 'sample' was used in an expression. The problem was around the initial ambiguity between: sample float a; // "sample" is part of a fully specified type and sample.xyz; // sample is a keyword in a dot expression Both start the same. The "sample" was being accepted as a qualifier before enough further parsing was done to determine we were not a declaration after all. This consumed the token, causing it to fail for its real purpose. Now, when accepting a fully specified type, the token is pushed back onto the stack if the thing is not a fully specified type. This leaves it available for subsequent purposes. Changed the "hlsl.identifier.sample.frag" test to exercise this situation, distilled down from a production shaders.
2016-12-19 00:51:14 +00:00
// If this is not a type, we may have inadvertently gone down a wrong path
HLSL: struct splitting: assignments of hierarchical split types This commit adds support for copying nested hierarchical types of split types. E.g, a struct of a struct containing both user and builtin interstage IO variables. When copying split types, if any subtree does NOT contain builtin interstage IO, we can copy the whole subtree with one assignment, which saves a bunch of AST verbosity for memberwise copies of that subtree.
2016-12-19 22:48:01 +00:00
// by parsing "sample", which can be treated like either an identifier or a
HLSL: allow "sample" in expressions. Unlike other qualifiers, HLSL allows "sample" to be either a qualifier keyword or an identifier (e.g, a variable or function name). A fix to allow this was made a while ago, but that fix was insufficient when 'sample' was used in an expression. The problem was around the initial ambiguity between: sample float a; // "sample" is part of a fully specified type and sample.xyz; // sample is a keyword in a dot expression Both start the same. The "sample" was being accepted as a qualifier before enough further parsing was done to determine we were not a declaration after all. This consumed the token, causing it to fail for its real purpose. Now, when accepting a fully specified type, the token is pushed back onto the stack if the thing is not a fully specified type. This leaves it available for subsequent purposes. Changed the "hlsl.identifier.sample.frag" test to exercise this situation, distilled down from a production shaders.
2016-12-19 00:51:14 +00:00
// qualifier. Back it out, if we did.
if (qualifier.sample)
recedeToken();
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return false;
HLSL: allow "sample" in expressions. Unlike other qualifiers, HLSL allows "sample" to be either a qualifier keyword or an identifier (e.g, a variable or function name). A fix to allow this was made a while ago, but that fix was insufficient when 'sample' was used in an expression. The problem was around the initial ambiguity between: sample float a; // "sample" is part of a fully specified type and sample.xyz; // sample is a keyword in a dot expression Both start the same. The "sample" was being accepted as a qualifier before enough further parsing was done to determine we were not a declaration after all. This consumed the token, causing it to fail for its real purpose. Now, when accepting a fully specified type, the token is pushed back onto the stack if the thing is not a fully specified type. This leaves it available for subsequent purposes. Changed the "hlsl.identifier.sample.frag" test to exercise this situation, distilled down from a production shaders.
2016-12-19 00:51:14 +00:00
}
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
if (type.getBasicType() == EbtBlock) {
// the type was a block, which set some parts of the qualifier
HLSL: Improve setting and testing of interpolation qualifiers. Notably, use of 'linear' on a non-input could mark it as an input.
2016-09-16 23:10:39 +00:00
parseContext.mergeQualifiers(type.getQualifier(), qualifier);
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
// merge in the attributes
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
parseContext.transferTypeAttributes(token.loc, attributes, type);
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
// further, it can create an anonymous instance of the block
Build: Tickle bots to try again... seems like a process hang; all tests passed.
2018-01-02 20:07:14 +00:00
// (cbuffer and tbuffer don't consume the next identifier, and
// should set forbidDeclarators)
HLSL: Fix #1203: Declare anonymous members for cbuffer with no ';' The grammar for no semicolon and no object name for cbuffer/tbuffer was correct, but the production still skipped the anonymous declarations if an identifier followed.
2018-01-02 18:27:54 +00:00
if (forbidDeclarators || peek() != EHTokIdentifier)
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
parseContext.declareBlock(loc, type);
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
} else {
// Some qualifiers are set when parsing the type. Merge those with
// whatever comes from acceptQualifier.
assert(qualifier.layoutFormat == ElfNone);
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
qualifier.layoutFormat = type.getQualifier().layoutFormat;
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
qualifier.precision = type.getQualifier().precision;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
HLSL: fix GS implementation for EP wrapping The prior implementation of GS did not work with the new EP wrapping architecture. This fixes it: the Append() method now looks up the actual output rather than the internal sanitized temporary type, and writes to that.
2017-03-30 02:01:13 +00:00
if (type.getQualifier().storage == EvqOut ||
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
type.getQualifier().storage == EvqBuffer) {
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
qualifier.storage = type.getQualifier().storage;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
qualifier.readonly = type.getQualifier().readonly;
}
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
Non-functional HLSL: Factor out built-ins from splitting and related simplifications.
2017-08-08 05:40:05 +00:00
if (type.isBuiltIn())
HLSL: fix GS implementation for EP wrapping The prior implementation of GS did not work with the new EP wrapping architecture. This fixes it: the Append() method now looks up the actual output rather than the internal sanitized temporary type, and writes to that.
2017-03-30 02:01:13 +00:00
qualifier.builtIn = type.getQualifier().builtIn;
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
type.getQualifier() = qualifier;
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
}
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return true;
}
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
// type_qualifier
// : qualifier qualifier ...
//
// Zero or more of these, so this can't return false.
//
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
bool HlslGrammar::acceptQualifier(TQualifier& qualifier)
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
{
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
do {
switch (peek()) {
case EHTokStatic:
Support a uniform block to hold global uniform variables. Used initially just by HLSL, for $Global. Could be an option for GLSL -> Vulkan.
2016-09-28 01:13:05 +00:00
qualifier.storage = parseContext.symbolTable.atGlobalLevel() ? EvqGlobal : EvqTemporary;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
break;
case EHTokExtern:
// TODO: no meaning in glslang?
break;
case EHTokShared:
// TODO: hint
break;
case EHTokGroupShared:
qualifier.storage = EvqShared;
break;
case EHTokUniform:
qualifier.storage = EvqUniform;
break;
case EHTokConst:
qualifier.storage = EvqConst;
break;
case EHTokVolatile:
qualifier.volatil = true;
break;
case EHTokLinear:
qualifier.smooth = true;
break;
case EHTokCentroid:
qualifier.centroid = true;
break;
case EHTokNointerpolation:
qualifier.flat = true;
break;
case EHTokNoperspective:
qualifier.nopersp = true;
break;
case EHTokSample:
qualifier.sample = true;
break;
case EHTokRowMajor:
HLSL: Reverse what the driver is told about row/column majorness, matching the row-column reversal.
2016-09-26 02:25:06 +00:00
qualifier.layoutMatrix = ElmColumnMajor;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
break;
case EHTokColumnMajor:
HLSL: Reverse what the driver is told about row/column majorness, matching the row-column reversal.
2016-09-26 02:25:06 +00:00
qualifier.layoutMatrix = ElmRowMajor;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
break;
case EHTokPrecise:
qualifier.noContraction = true;
break;
HLSL: add in/out/inout qualifiers.
2016-07-13 02:44:32 +00:00
case EHTokIn:
hlsl: "in out" is also an inout qualifier.
2017-06-20 05:49:22 +00:00
qualifier.storage = (qualifier.storage == EvqOut) ? EvqInOut : EvqIn;
HLSL: add in/out/inout qualifiers.
2016-07-13 02:44:32 +00:00
break;
case EHTokOut:
hlsl: "in out" is also an inout qualifier.
2017-06-20 05:49:22 +00:00
qualifier.storage = (qualifier.storage == EvqIn) ? EvqInOut : EvqOut;
HLSL: add in/out/inout qualifiers.
2016-07-13 02:44:32 +00:00
break;
case EHTokInOut:
qualifier.storage = EvqInOut;
break;
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
case EHTokLayout:
if (! acceptLayoutQualifierList(qualifier))
return false;
continue;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
case EHTokGloballyCoherent:
qualifier.coherent = true;
break;
HLSL: Fix #771: add inline keyword.
2017-03-15 15:05:14 +00:00
case EHTokInline:
// TODO: map this to SPIR-V function control
break;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
// GS geometries: these are specified on stage input variables, and are an error (not verified here)
// for output variables.
case EHTokPoint:
qualifier.storage = EvqIn;
if (!parseContext.handleInputGeometry(token.loc, ElgPoints))
return false;
break;
case EHTokLine:
qualifier.storage = EvqIn;
if (!parseContext.handleInputGeometry(token.loc, ElgLines))
return false;
break;
case EHTokTriangle:
qualifier.storage = EvqIn;
if (!parseContext.handleInputGeometry(token.loc, ElgTriangles))
return false;
break;
case EHTokLineAdj:
qualifier.storage = EvqIn;
if (!parseContext.handleInputGeometry(token.loc, ElgLinesAdjacency))
return false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
break;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
case EHTokTriangleAdj:
qualifier.storage = EvqIn;
if (!parseContext.handleInputGeometry(token.loc, ElgTrianglesAdjacency))
return false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
break;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
default:
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
return true;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
}
advanceToken();
} while (true);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
}
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
// layout_qualifier_list
HLSL: Accept layout(...) also as a post-decl. Issue #454.
2016-09-05 20:37:03 +00:00
// : LAYOUT LEFT_PAREN layout_qualifier COMMA layout_qualifier ... RIGHT_PAREN
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
//
// layout_qualifier
// : identifier
HLSL: Fix issue #442, smear and truncate shape conversions for == and !=.
2016-09-03 03:12:23 +00:00
// | identifier EQUAL expression
HLSL: Partially address issue #463: accept GLSL layout(...). This includes all "per variable" layout qualifiers, but the key ones mattering and tested for now are: set= binding= constant_id= push_constant
2016-08-17 16:22:08 +00:00
//
// Zero or more of these, so this can't return false.
//
bool HlslGrammar::acceptLayoutQualifierList(TQualifier& qualifier)
{
if (! acceptTokenClass(EHTokLayout))
return false;
// LEFT_PAREN
if (! acceptTokenClass(EHTokLeftParen))
return false;
do {
// identifier
HlslToken idToken;
if (! acceptIdentifier(idToken))
break;
// EQUAL expression
if (acceptTokenClass(EHTokAssign)) {
TIntermTyped* expr;
if (! acceptConditionalExpression(expr)) {
expected("expression");
return false;
}
parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string, expr);
} else
parseContext.setLayoutQualifier(idToken.loc, qualifier, *idToken.string);
// COMMA
if (! acceptTokenClass(EHTokComma))
break;
} while (true);
// RIGHT_PAREN
if (! acceptTokenClass(EHTokRightParen)) {
expected(")");
return false;
}
return true;
}
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
// template_type
// : FLOAT
// | DOUBLE
// | INT
// | DWORD
// | UINT
// | BOOL
//
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
bool HlslGrammar::acceptTemplateVecMatBasicType(TBasicType& basicType)
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
{
switch (peek()) {
case EHTokFloat:
basicType = EbtFloat;
break;
case EHTokDouble:
basicType = EbtDouble;
break;
case EHTokInt:
case EHTokDword:
basicType = EbtInt;
break;
case EHTokUint:
basicType = EbtUint;
break;
case EHTokBool:
basicType = EbtBool;
break;
default:
return false;
}
advanceToken();
return true;
}
// vector_template_type
// : VECTOR
// | VECTOR LEFT_ANGLE template_type COMMA integer_literal RIGHT_ANGLE
//
bool HlslGrammar::acceptVectorTemplateType(TType& type)
{
if (! acceptTokenClass(EHTokVector))
return false;
if (! acceptTokenClass(EHTokLeftAngle)) {
// in HLSL, 'vector' alone means float4.
new(&type) TType(EbtFloat, EvqTemporary, 4);
return true;
}
TBasicType basicType;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
if (! acceptTemplateVecMatBasicType(basicType)) {
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
expected("scalar type");
return false;
}
// COMMA
if (! acceptTokenClass(EHTokComma)) {
expected(",");
return false;
}
// integer
if (! peekTokenClass(EHTokIntConstant)) {
expected("literal integer");
return false;
}
TIntermTyped* vecSize;
if (! acceptLiteral(vecSize))
return false;
const int vecSizeI = vecSize->getAsConstantUnion()->getConstArray()[0].getIConst();
new(&type) TType(basicType, EvqTemporary, vecSizeI);
if (vecSizeI == 1)
type.makeVector();
if (!acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
return true;
}
// matrix_template_type
// : MATRIX
// | MATRIX LEFT_ANGLE template_type COMMA integer_literal COMMA integer_literal RIGHT_ANGLE
//
bool HlslGrammar::acceptMatrixTemplateType(TType& type)
{
if (! acceptTokenClass(EHTokMatrix))
return false;
if (! acceptTokenClass(EHTokLeftAngle)) {
// in HLSL, 'matrix' alone means float4x4.
new(&type) TType(EbtFloat, EvqTemporary, 0, 4, 4);
return true;
}
TBasicType basicType;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
if (! acceptTemplateVecMatBasicType(basicType)) {
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
expected("scalar type");
return false;
}
// COMMA
if (! acceptTokenClass(EHTokComma)) {
expected(",");
return false;
}
// integer rows
if (! peekTokenClass(EHTokIntConstant)) {
expected("literal integer");
return false;
}
TIntermTyped* rows;
if (! acceptLiteral(rows))
return false;
// COMMA
if (! acceptTokenClass(EHTokComma)) {
expected(",");
return false;
}
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
// integer cols
if (! peekTokenClass(EHTokIntConstant)) {
expected("literal integer");
return false;
}
TIntermTyped* cols;
if (! acceptLiteral(cols))
return false;
new(&type) TType(basicType, EvqTemporary, 0,
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
rows->getAsConstantUnion()->getConstArray()[0].getIConst(),
cols->getAsConstantUnion()->getConstArray()[0].getIConst());
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
if (!acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
return true;
}
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
// layout_geometry
// : LINESTREAM
// | POINTSTREAM
// | TRIANGLESTREAM
//
bool HlslGrammar::acceptOutputPrimitiveGeometry(TLayoutGeometry& geometry)
{
// read geometry type
const EHlslTokenClass geometryType = peek();
switch (geometryType) {
case EHTokPointStream: geometry = ElgPoints; break;
case EHTokLineStream: geometry = ElgLineStrip; break;
case EHTokTriangleStream: geometry = ElgTriangleStrip; break;
default:
return false; // not a layout geometry
}
advanceToken(); // consume the layout keyword
return true;
}
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
// tessellation_decl_type
// : INPUTPATCH
// | OUTPUTPATCH
//
WIP: HLSL: Support InputPatch variables in patch constant functions Previously, patch constant functions only accepted OutputPatch. This adds InputPatch support, via a pseudo-builtin variable type, so that the patch can be tracked clear through from the qualifier.
2017-04-01 21:34:48 +00:00
bool HlslGrammar::acceptTessellationDeclType(TBuiltInVariable& patchType)
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
{
// read geometry type
const EHlslTokenClass tessType = peek();
switch (tessType) {
WIP: HLSL: Support InputPatch variables in patch constant functions Previously, patch constant functions only accepted OutputPatch. This adds InputPatch support, via a pseudo-builtin variable type, so that the patch can be tracked clear through from the qualifier.
2017-04-01 21:34:48 +00:00
case EHTokInputPatch: patchType = EbvInputPatch; break;
case EHTokOutputPatch: patchType = EbvOutputPatch; break;
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
default:
return false; // not a tessellation decl
}
advanceToken(); // consume the keyword
return true;
}
// tessellation_patch_template_type
// : tessellation_decl_type LEFT_ANGLE type comma integer_literal RIGHT_ANGLE
//
bool HlslGrammar::acceptTessellationPatchTemplateType(TType& type)
{
WIP: HLSL: Support InputPatch variables in patch constant functions Previously, patch constant functions only accepted OutputPatch. This adds InputPatch support, via a pseudo-builtin variable type, so that the patch can be tracked clear through from the qualifier.
2017-04-01 21:34:48 +00:00
TBuiltInVariable patchType;
if (! acceptTessellationDeclType(patchType))
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
return false;
if (! acceptTokenClass(EHTokLeftAngle))
return false;
if (! acceptType(type)) {
expected("tessellation patch type");
return false;
}
if (! acceptTokenClass(EHTokComma))
return false;
// integer size
if (! peekTokenClass(EHTokIntConstant)) {
expected("literal integer");
return false;
}
TIntermTyped* size;
if (! acceptLiteral(size))
return false;
TArraySizes* arraySizes = new TArraySizes;
arraySizes->addInnerSize(size->getAsConstantUnion()->getConstArray()[0].getIConst());
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
type.transferArraySizes(arraySizes);
WIP: HLSL: Support InputPatch variables in patch constant functions Previously, patch constant functions only accepted OutputPatch. This adds InputPatch support, via a pseudo-builtin variable type, so that the patch can be tracked clear through from the qualifier.
2017-04-01 21:34:48 +00:00
type.getQualifier().builtIn = patchType;
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
return true;
}
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
// stream_out_template_type
// : output_primitive_geometry_type LEFT_ANGLE type RIGHT_ANGLE
//
bool HlslGrammar::acceptStreamOutTemplateType(TType& type, TLayoutGeometry& geometry)
{
geometry = ElgNone;
if (! acceptOutputPrimitiveGeometry(geometry))
return false;
if (! acceptTokenClass(EHTokLeftAngle))
return false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
if (! acceptType(type)) {
expected("stream output type");
return false;
}
HLSL: fix GS implementation for EP wrapping The prior implementation of GS did not work with the new EP wrapping architecture. This fixes it: the Append() method now looks up the actual output rather than the internal sanitized temporary type, and writes to that.
2017-03-30 02:01:13 +00:00
type.getQualifier().storage = EvqOut;
type.getQualifier().builtIn = EbvGsOutputStream;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
return true;
}
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
// annotations
// : LEFT_ANGLE declaration SEMI_COLON ... declaration SEMICOLON RIGHT_ANGLE
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
//
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
bool HlslGrammar::acceptAnnotations(TQualifier&)
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
{
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
if (! acceptTokenClass(EHTokLeftAngle))
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
return false;
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
// note that we are nesting a name space
parseContext.nestAnnotations();
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
// declaration SEMI_COLON ... declaration SEMICOLON RIGHT_ANGLE
do {
// eat any extra SEMI_COLON; don't know if the grammar calls for this or not
while (acceptTokenClass(EHTokSemicolon))
;
if (acceptTokenClass(EHTokRightAngle))
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
break;
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
// declaration
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
TIntermNode* node = nullptr;
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
if (! acceptDeclaration(node)) {
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
expected("declaration in annotation");
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
return false;
}
} while (true);
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
parseContext.unnestAnnotations();
return true;
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
}
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
HLSL: add subpass input types and methods Add support for Subpass Input proposal of issue #1069. Subpass input types are given as: layout(input_attachment_index = 1) SubpassInput<float4> subpass_f; layout(input_attachment_index = 2) SubpassInput<int4> subpass_i; layout(input_attachment_index = 3) SubpassInput<uint4> subpass_u; layout(input_attachment_index = 1) SubpassInputMS<float4> subpass_ms_f; layout(input_attachment_index = 2) SubpassInputMS<int4> subpass_ms_i; layout(input_attachment_index = 3) SubpassInputMS<uint4> subpass_ms_u; The input attachment may also be specified using attribute syntax: [[vk::input_attachment_index(7)]] SubpassInput subpass_2; The template type may be a shorter-than-vec4 vector, but currently user structs are not supported. (An unimplemented error will be issued). The load operations are methods on objects of the above type: float4 result = subpass_f.SubpassLoad(); int4 result = subpass_i.SubpassLoad(); uint4 result = subpass_u.SubpassLoad(); float4 result = subpass_ms_f.SubpassLoad(samp); int4 result = subpass_ms_i.SubpassLoad(samp); uint4 result = subpass_ms_u.SubpassLoad(samp); Additionally, the AST printer could not print EOpSubpass* nodes. Now it can. Fixes #1069
2017-09-27 15:04:43 +00:00
// subpass input type
// : SUBPASSINPUT
// | SUBPASSINPUT VECTOR LEFT_ANGLE template_type RIGHT_ANGLE
// | SUBPASSINPUTMS
// | SUBPASSINPUTMS VECTOR LEFT_ANGLE template_type RIGHT_ANGLE
bool HlslGrammar::acceptSubpassInputType(TType& type)
{
// read subpass type
const EHlslTokenClass subpassInputType = peek();
bool multisample;
switch (subpassInputType) {
case EHTokSubpassInput: multisample = false; break;
case EHTokSubpassInputMS: multisample = true; break;
default:
return false; // not a subpass input declaration
}
advanceToken(); // consume the sampler type keyword
TType subpassType(EbtFloat, EvqUniform, 4); // default type is float4
if (acceptTokenClass(EHTokLeftAngle)) {
if (! acceptType(subpassType)) {
expected("scalar or vector type");
return false;
}
const TBasicType basicRetType = subpassType.getBasicType() ;
switch (basicRetType) {
case EbtFloat:
case EbtUint:
case EbtInt:
case EbtStruct:
break;
default:
unimplemented("basic type in subpass input");
return false;
}
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
}
const TBasicType subpassBasicType = subpassType.isStruct() ? (*subpassType.getStruct())[0].type->getBasicType()
: subpassType.getBasicType();
TSampler sampler;
sampler.setSubpass(subpassBasicType, multisample);
// Remember the declared return type. Function returns false on error.
if (!parseContext.setTextureReturnType(sampler, subpassType, token.loc))
return false;
type.shallowCopy(TType(sampler, EvqUniform));
return true;
}
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
// sampler_type
// : SAMPLER
// | SAMPLER1D
// | SAMPLER2D
// | SAMPLER3D
// | SAMPLERCUBE
// | SAMPLERSTATE
// | SAMPLERCOMPARISONSTATE
bool HlslGrammar::acceptSamplerType(TType& type)
{
// read sampler type
const EHlslTokenClass samplerType = peek();
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
// TODO: for DX9
HLSL: Add tx.GetDimensions method (uint returns only)
2016-07-15 17:22:24 +00:00
// TSamplerDim dim = EsdNone;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
bool isShadow = false;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
switch (samplerType) {
case EHTokSampler: break;
HLSL: Add tx.GetDimensions method (uint returns only)
2016-07-15 17:22:24 +00:00
case EHTokSampler1d: /*dim = Esd1D*/; break;
case EHTokSampler2d: /*dim = Esd2D*/; break;
case EHTokSampler3d: /*dim = Esd3D*/; break;
case EHTokSamplerCube: /*dim = EsdCube*/; break;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
case EHTokSamplerState: break;
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
case EHTokSamplerComparisonState: isShadow = true; break;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
default:
return false; // not a sampler declaration
}
advanceToken(); // consume the sampler type keyword
TArraySizes* arraySizes = nullptr; // TODO: array
TSampler sampler;
HLSL: Add SampleCmp and SampleCmpLevelZero texture methods
2016-07-19 20:28:05 +00:00
sampler.setPureSampler(isShadow);
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
type.shallowCopy(TType(sampler, EvqUniform, arraySizes));
return true;
}
// texture_type
// | BUFFER
// | TEXTURE1D
// | TEXTURE1DARRAY
// | TEXTURE2D
// | TEXTURE2DARRAY
// | TEXTURE3D
// | TEXTURECUBE
// | TEXTURECUBEARRAY
// | TEXTURE2DMS
// | TEXTURE2DMSARRAY
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
// | RWBUFFER
// | RWTEXTURE1D
// | RWTEXTURE1DARRAY
// | RWTEXTURE2D
// | RWTEXTURE2DARRAY
// | RWTEXTURE3D
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
bool HlslGrammar::acceptTextureType(TType& type)
{
const EHlslTokenClass textureType = peek();
TSamplerDim dim = EsdNone;
bool array = false;
bool ms = false;
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
bool image = false;
WIP: HLSL: force uncombined flag off for Buffer<>
2017-03-31 23:40:09 +00:00
bool combined = true;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
switch (textureType) {
WIP: HLSL: force uncombined flag off for Buffer<>
2017-03-31 23:40:09 +00:00
case EHTokBuffer: dim = EsdBuffer; combined = false; break;
Revert "Merge pull request #779 from steve-lunarg/buffer-unsampled-fix" This reverts commit 1dd65ca3983d3c361e66fbf788f050177f596d3a, reversing changes made to 4960baaf663b18a6e0a58edb9073158ef7331930.
2017-03-31 20:39:30 +00:00
case EHTokTexture1d: dim = Esd1D; break;
case EHTokTexture1darray: dim = Esd1D; array = true; break;
case EHTokTexture2d: dim = Esd2D; break;
case EHTokTexture2darray: dim = Esd2D; array = true; break;
case EHTokTexture3d: dim = Esd3D; break;
case EHTokTextureCube: dim = EsdCube; break;
case EHTokTextureCubearray: dim = EsdCube; array = true; break;
case EHTokTexture2DMS: dim = Esd2D; ms = true; break;
case EHTokTexture2DMSarray: dim = Esd2D; array = true; ms = true; break;
case EHTokRWBuffer: dim = EsdBuffer; image=true; break;
case EHTokRWTexture1d: dim = Esd1D; array=false; image=true; break;
case EHTokRWTexture1darray: dim = Esd1D; array=true; image=true; break;
case EHTokRWTexture2d: dim = Esd2D; array=false; image=true; break;
case EHTokRWTexture2darray: dim = Esd2D; array=true; image=true; break;
case EHTokRWTexture3d: dim = Esd3D; array=false; image=true; break;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
default:
return false; // not a texture declaration
}
advanceToken(); // consume the texture object keyword
TType txType(EbtFloat, EvqUniform, 4); // default type is float4
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
TIntermTyped* msCount = nullptr;
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
// texture type: required for multisample types and RWBuffer/RWTextures!
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
if (acceptTokenClass(EHTokLeftAngle)) {
if (! acceptType(txType)) {
expected("scalar or vector type");
return false;
}
const TBasicType basicRetType = txType.getBasicType() ;
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
switch (basicRetType) {
case EbtFloat:
case EbtUint:
case EbtInt:
case EbtStruct:
break;
default:
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
unimplemented("basic type in texture");
return false;
}
HLSL: add Buffer support for Load method
2016-07-27 21:46:48 +00:00
// Buffers can handle small mats if they fit in 4 components
if (dim == EsdBuffer && txType.isMatrix()) {
if ((txType.getMatrixCols() * txType.getMatrixRows()) > 4) {
expected("components < 4 in matrix buffer type");
return false;
}
// TODO: except we don't handle it yet...
unimplemented("matrix type in buffer");
return false;
}
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
if (!txType.isScalar() && !txType.isVector() && !txType.isStruct()) {
expected("scalar, vector, or struct type");
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
return false;
}
if (ms && acceptTokenClass(EHTokComma)) {
// read sample count for multisample types, if given
if (! peekTokenClass(EHTokIntConstant)) {
expected("multisample count");
return false;
}
if (! acceptLiteral(msCount)) // should never fail, since we just found an integer
return false;
}
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
} else if (ms) {
expected("texture type for multisample");
return false;
Revert "Merge pull request #779 from steve-lunarg/buffer-unsampled-fix" This reverts commit 1dd65ca3983d3c361e66fbf788f050177f596d3a, reversing changes made to 4960baaf663b18a6e0a58edb9073158ef7331930.
2017-03-31 20:39:30 +00:00
} else if (image) {
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
expected("type for RWTexture/RWBuffer");
return false;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
}
TArraySizes* arraySizes = nullptr;
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
const bool shadow = false; // declared on the sampler
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
TSampler sampler;
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
TLayoutFormat format = ElfNone;
HLSL: phase 3a: Add sub-vec4 rwtexture formats (qualifier.layoutFormat) This PR sets the TQualifier layoutFormat according to the HLSL image type. For instance: RWTexture1D <float2> g_tTex1df2; becomes ElfRg32f. Similar on Buffers, e.g, Buffer<float4> mybuffer; The return type for image and buffer loads is now taken from the storage format. Also, the qualifier for the return type is now (properly) a temp, not a global.
2016-10-10 21:24:57 +00:00
// Buffer, RWBuffer and RWTexture (images) require a TLayoutFormat. We handle only a limit set.
if (image || dim == EsdBuffer)
format = parseContext.getLayoutFromTxType(token.loc, txType);
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
const TBasicType txBasicType = txType.isStruct() ? (*txType.getStruct())[0].type->getBasicType()
: txType.getBasicType();
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
// Non-image Buffers are combined
if (dim == EsdBuffer && !image) {
HLSL: add Buffer support for Load method
2016-07-27 21:46:48 +00:00
sampler.set(txType.getBasicType(), dim, array);
} else {
// DX10 textures are separated. TODO: DX9.
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
if (image) {
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
sampler.setImage(txBasicType, dim, array, shadow, ms);
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
} else {
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
sampler.setTexture(txBasicType, dim, array, shadow, ms);
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
}
HLSL: add Buffer support for Load method
2016-07-27 21:46:48 +00:00
}
HLSL: phase 3b: Texture methods remember and return vector size. Also makes a (correct) test change for global -> temp vars.
2016-10-14 22:40:32 +00:00
HLSL: add methods to track user structure in texture return type. Some languages allow a restricted set of user structure types returned from texture sampling operations. Restrictions include the total vector size of all components may not exceed 4, and the basic types of all members must be identical. This adds underpinnings for that ability. Because storing a whole TType or even a simple TTypeList in the TSampler would be expensive, the structure definition is held in a table outside the TType. The TSampler contains a small bitfield index, currently 4 bits to support up to 15 separate texture template structure types, but that can be adjusted up or down. Vector returns are handled as before. There are abstraction methods accepting and returning a TType (such as may have been parsed from a grammar). The new methods will accept a texture template type and set the sampler to the structure if possible, checking a range of error conditions such as whether the total structure vector components exceed 4, or whether their basic types differe, or whether the struct contains non-vector-or-scalar members. Another query returns the appropriate TType for the sampler. High level summary of design: In the TSampler, this holds an index into the texture structure return type table: unsigned int structReturnIndex : structReturnIndexBits; These are the methods to set or get the return type from the TSampler. They work for vector or structure returns, and potentially could be expanded to handle other things (small arrays?) if ever needed. bool setTextureReturnType(TSampler& sampler, const TType& retType, const TSourceLoc& loc); void getTextureReturnType(const TSampler& sampler, const TType& retType, const TSourceLoc& loc) const; The ``convertReturn`` lambda in ``HlslParseContext::decomposeSampleMethods`` is greatly expanded to know how to copy a vec4 sample return to whatever the structure type should be. This is a little awkward since it involves introducing a comma expression to return the proper aggregate value after a set of memberwise copies.
2017-07-31 19:41:42 +00:00
// Remember the declared return type. Function returns false on error.
if (!parseContext.setTextureReturnType(sampler, txType, token.loc))
return false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
WIP: HLSL: force uncombined flag off for Buffer<>
2017-03-31 23:40:09 +00:00
// Force uncombined, if necessary
if (!combined)
sampler.combined = false;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
type.shallowCopy(TType(sampler, EvqUniform, arraySizes));
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
type.getQualifier().layoutFormat = format;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
return true;
}
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
// If token is for a type, update 'type' with the type information,
// and return true and advance.
// Otherwise, return false, and don't advance
bool HlslGrammar::acceptType(TType& type)
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
{
TIntermNode* nodeList = nullptr;
return acceptType(type, nodeList);
}
bool HlslGrammar::acceptType(TType& type, TIntermNode*& nodeList)
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
{
Allow --hlsl-enable-16bit-types to be used without AMD_EXTENSIONS
2018-03-08 14:17:04 +00:00
// Basic types for min* types, use native halfs if the option allows them.
HLSL: Map min types to GLSL 16-bit types
2018-03-07 05:10:01 +00:00
bool enable16BitTypes = parseContext.hlslEnable16BitTypes();
const TBasicType min16float_bt = enable16BitTypes ? EbtFloat16 : EbtFloat;
const TBasicType min10float_bt = enable16BitTypes ? EbtFloat16 : EbtFloat;
const TBasicType half_bt = enable16BitTypes ? EbtFloat16 : EbtFloat;
const TBasicType min16int_bt = enable16BitTypes ? EbtInt16 : EbtInt;
const TBasicType min12int_bt = enable16BitTypes ? EbtInt16 : EbtInt;
const TBasicType min16uint_bt = enable16BitTypes ? EbtUint16 : EbtUint;
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
HLSL: Recognize types declared as identifiers as identifiers. E.g., in float float; (float) * float; The "(float)" is not a type cast, it is an expression.
2017-06-14 04:22:52 +00:00
// Some types might have turned into identifiers. Take the hit for checking
// when this has happened.
if (typeIdentifiers) {
const char* identifierString = getTypeString(peek());
if (identifierString != nullptr) {
TString name = identifierString;
// if it's an identifier, it's not a type
if (parseContext.symbolTable.find(name) != nullptr)
return false;
}
}
HLSL: Accept unorm and snorm on types This is currently parsed and ignored, save for some minor validation.
2017-11-14 21:55:40 +00:00
bool isUnorm = false;
bool isSnorm = false;
// Accept snorm and unorm. Presently, this is ignored, save for an error check below.
switch (peek()) {
case EHTokUnorm:
isUnorm = true;
advanceToken(); // eat the token
break;
case EHTokSNorm:
isSnorm = true;
advanceToken(); // eat the token
break;
default:
break;
}
HLSL: Separate out token stream handling from grammar recognition.
2016-05-04 04:49:24 +00:00
switch (peek()) {
HLSL: Add template style constructors for vector & matrix types
2016-06-24 01:13:48 +00:00
case EHTokVector:
return acceptVectorTemplateType(type);
break;
case EHTokMatrix:
return acceptMatrixTemplateType(type);
break;
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
case EHTokPointStream: // fall through
case EHTokLineStream: // ...
case EHTokTriangleStream: // ...
{
TLayoutGeometry geometry;
if (! acceptStreamOutTemplateType(type, geometry))
return false;
if (! parseContext.handleOutputGeometry(token.loc, geometry))
return false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
WIP: HLSL: Add GS support This PR adds: [maxvertexcount(n)] attributes point/line/triangle/lineadj/triangleadj qualifiers PointStream/LineStream/TriangleStream templatized types Append method on above template types RestartStrip method on above template types.
2016-11-17 22:04:20 +00:00
return true;
}
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
case EHTokInputPatch: // fall through
case EHTokOutputPatch: // ...
{
if (! acceptTessellationPatchTemplateType(type))
return false;
return true;
}
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
case EHTokSampler: // fall through
case EHTokSampler1d: // ...
case EHTokSampler2d: // ...
case EHTokSampler3d: // ...
case EHTokSamplerCube: // ...
case EHTokSamplerState: // ...
case EHTokSamplerComparisonState: // ...
return acceptSamplerType(type);
break;
HLSL: add subpass input types and methods Add support for Subpass Input proposal of issue #1069. Subpass input types are given as: layout(input_attachment_index = 1) SubpassInput<float4> subpass_f; layout(input_attachment_index = 2) SubpassInput<int4> subpass_i; layout(input_attachment_index = 3) SubpassInput<uint4> subpass_u; layout(input_attachment_index = 1) SubpassInputMS<float4> subpass_ms_f; layout(input_attachment_index = 2) SubpassInputMS<int4> subpass_ms_i; layout(input_attachment_index = 3) SubpassInputMS<uint4> subpass_ms_u; The input attachment may also be specified using attribute syntax: [[vk::input_attachment_index(7)]] SubpassInput subpass_2; The template type may be a shorter-than-vec4 vector, but currently user structs are not supported. (An unimplemented error will be issued). The load operations are methods on objects of the above type: float4 result = subpass_f.SubpassLoad(); int4 result = subpass_i.SubpassLoad(); uint4 result = subpass_u.SubpassLoad(); float4 result = subpass_ms_f.SubpassLoad(samp); int4 result = subpass_ms_i.SubpassLoad(samp); uint4 result = subpass_ms_u.SubpassLoad(samp); Additionally, the AST printer could not print EOpSubpass* nodes. Now it can. Fixes #1069
2017-09-27 15:04:43 +00:00
case EHTokSubpassInput: // fall through
case EHTokSubpassInputMS: // ...
return acceptSubpassInputType(type);
break;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
case EHTokBuffer: // fall through
case EHTokTexture1d: // ...
case EHTokTexture1darray: // ...
case EHTokTexture2d: // ...
case EHTokTexture2darray: // ...
case EHTokTexture3d: // ...
case EHTokTextureCube: // ...
case EHTokTextureCubearray: // ...
case EHTokTexture2DMS: // ...
case EHTokTexture2DMSarray: // ...
HLSL: phase 1: add RWTexture and RWBuffer There's a lot to do for RWTexture and RWBuffer, so it will be broken up into several PRs. This is #1. This adds RWTexture and RWBuffer support, with the following limitations: * Only 4 component formats supported * No operator[] yet Those will be added in other PRs. This PR supports declarations and the Load & GetDimensions methods. New tests are added.
2016-10-04 22:58:14 +00:00
case EHTokRWTexture1d: // ...
case EHTokRWTexture1darray: // ...
case EHTokRWTexture2d: // ...
case EHTokRWTexture2darray: // ...
case EHTokRWTexture3d: // ...
case EHTokRWBuffer: // ...
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
return acceptTextureType(type);
break;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
case EHTokAppendStructuredBuffer:
case EHTokByteAddressBuffer:
case EHTokConsumeStructuredBuffer:
case EHTokRWByteAddressBuffer:
case EHTokRWStructuredBuffer:
case EHTokStructuredBuffer:
return acceptStructBufferType(type);
break;
HLSL: implement TextureBuffer<type> Almost equivalent to tbuffer, except members not at global scope. So, reference is "TextureBuffer_var.member", not simply "member".
2017-11-09 02:48:11 +00:00
case EHTokTextureBuffer:
return acceptTextureBufferType(type);
break;
HLSL: Add ConstantBuffer<T> syntax Note: multi-dimension arrays of ConstantBuffer objects will go through uniform flattening.
2017-04-25 15:30:28 +00:00
case EHTokConstantBuffer:
return acceptConstantBufferType(type);
HLSL: Add 'class' keyword as (so far) synonym for 'struct'.
2017-03-04 00:01:01 +00:00
case EHTokClass:
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
case EHTokStruct:
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
case EHTokCBuffer:
case EHTokTBuffer:
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
return acceptStruct(type, nodeList);
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
case EHTokIdentifier:
// An identifier could be for a user-defined type.
// Note we cache the symbol table lookup, to save for a later rule
// when this is not a type.
HLSL: Non-functional: the symbol field of a token was in practice unused; remove it. Another precurser to getting member non-static functions working.
2017-03-22 00:35:04 +00:00
if (parseContext.lookupUserType(*token.string, type) != nullptr) {
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
advanceToken();
return true;
} else
return false;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
case EHTokVoid:
new(&type) TType(EbtVoid);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
case EHTokString:
new(&type) TType(EbtString);
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokFloat:
Full stack: distinguish between a scalar and a vector of size 1. There have been GLSL extensions considering this, and HLSL does it. This is a fully backward compatible change that allows this distinction.
2016-05-20 18:06:03 +00:00
new(&type) TType(EbtFloat);
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokFloat1:
new(&type) TType(EbtFloat);
Full stack: distinguish between a scalar and a vector of size 1. There have been GLSL extensions considering this, and HLSL does it. This is a fully backward compatible change that allows this distinction.
2016-05-20 18:06:03 +00:00
type.makeVector();
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokFloat2:
new(&type) TType(EbtFloat, EvqTemporary, 2);
break;
case EHTokFloat3:
new(&type) TType(EbtFloat, EvqTemporary, 3);
break;
case EHTokFloat4:
new(&type) TType(EbtFloat, EvqTemporary, 4);
break;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
case EHTokDouble:
new(&type) TType(EbtDouble);
break;
case EHTokDouble1:
new(&type) TType(EbtDouble);
type.makeVector();
break;
case EHTokDouble2:
new(&type) TType(EbtDouble, EvqTemporary, 2);
break;
case EHTokDouble3:
new(&type) TType(EbtDouble, EvqTemporary, 3);
break;
case EHTokDouble4:
new(&type) TType(EbtDouble, EvqTemporary, 4);
break;
case EHTokInt:
case EHTokDword:
new(&type) TType(EbtInt);
break;
case EHTokInt1:
new(&type) TType(EbtInt);
type.makeVector();
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokInt2:
new(&type) TType(EbtInt, EvqTemporary, 2);
break;
case EHTokInt3:
new(&type) TType(EbtInt, EvqTemporary, 3);
break;
case EHTokInt4:
new(&type) TType(EbtInt, EvqTemporary, 4);
break;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
case EHTokUint:
new(&type) TType(EbtUint);
break;
case EHTokUint1:
new(&type) TType(EbtUint);
type.makeVector();
break;
case EHTokUint2:
new(&type) TType(EbtUint, EvqTemporary, 2);
break;
case EHTokUint3:
new(&type) TType(EbtUint, EvqTemporary, 3);
break;
case EHTokUint4:
new(&type) TType(EbtUint, EvqTemporary, 4);
break;
SPV: Implement Vulkan 1.1 features and extensions.
2018-03-06 23:12:04 +00:00
case EHTokUint64:
new(&type) TType(EbtUint64);
break;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
case EHTokBool:
new(&type) TType(EbtBool);
break;
case EHTokBool1:
new(&type) TType(EbtBool);
type.makeVector();
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokBool2:
new(&type) TType(EbtBool, EvqTemporary, 2);
break;
case EHTokBool3:
new(&type) TType(EbtBool, EvqTemporary, 3);
break;
case EHTokBool4:
new(&type) TType(EbtBool, EvqTemporary, 4);
break;
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
case EHTokHalf:
HLSL: Implement half matrices, and map all half* -> float*.
2017-06-07 05:35:25 +00:00
new(&type) TType(half_bt, EvqTemporary);
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
break;
case EHTokHalf1:
HLSL: Implement half matrices, and map all half* -> float*.
2017-06-07 05:35:25 +00:00
new(&type) TType(half_bt, EvqTemporary);
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
type.makeVector();
break;
case EHTokHalf2:
HLSL: Implement half matrices, and map all half* -> float*.
2017-06-07 05:35:25 +00:00
new(&type) TType(half_bt, EvqTemporary, 2);
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
break;
case EHTokHalf3:
HLSL: Implement half matrices, and map all half* -> float*.
2017-06-07 05:35:25 +00:00
new(&type) TType(half_bt, EvqTemporary, 3);
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
break;
case EHTokHalf4:
HLSL: Implement half matrices, and map all half* -> float*.
2017-06-07 05:35:25 +00:00
new(&type) TType(half_bt, EvqTemporary, 4);
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
break;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
case EHTokMin16float:
new(&type) TType(min16float_bt, EvqTemporary, EpqMedium);
break;
case EHTokMin16float1:
new(&type) TType(min16float_bt, EvqTemporary, EpqMedium);
type.makeVector();
break;
case EHTokMin16float2:
new(&type) TType(min16float_bt, EvqTemporary, EpqMedium, 2);
break;
case EHTokMin16float3:
new(&type) TType(min16float_bt, EvqTemporary, EpqMedium, 3);
break;
case EHTokMin16float4:
new(&type) TType(min16float_bt, EvqTemporary, EpqMedium, 4);
break;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
case EHTokMin10float:
new(&type) TType(min10float_bt, EvqTemporary, EpqMedium);
break;
case EHTokMin10float1:
new(&type) TType(min10float_bt, EvqTemporary, EpqMedium);
type.makeVector();
break;
case EHTokMin10float2:
new(&type) TType(min10float_bt, EvqTemporary, EpqMedium, 2);
break;
case EHTokMin10float3:
new(&type) TType(min10float_bt, EvqTemporary, EpqMedium, 3);
break;
case EHTokMin10float4:
new(&type) TType(min10float_bt, EvqTemporary, EpqMedium, 4);
break;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
case EHTokMin16int:
new(&type) TType(min16int_bt, EvqTemporary, EpqMedium);
break;
case EHTokMin16int1:
new(&type) TType(min16int_bt, EvqTemporary, EpqMedium);
type.makeVector();
break;
case EHTokMin16int2:
new(&type) TType(min16int_bt, EvqTemporary, EpqMedium, 2);
break;
case EHTokMin16int3:
new(&type) TType(min16int_bt, EvqTemporary, EpqMedium, 3);
break;
case EHTokMin16int4:
new(&type) TType(min16int_bt, EvqTemporary, EpqMedium, 4);
break;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
case EHTokMin12int:
new(&type) TType(min12int_bt, EvqTemporary, EpqMedium);
break;
case EHTokMin12int1:
new(&type) TType(min12int_bt, EvqTemporary, EpqMedium);
type.makeVector();
break;
case EHTokMin12int2:
new(&type) TType(min12int_bt, EvqTemporary, EpqMedium, 2);
break;
case EHTokMin12int3:
new(&type) TType(min12int_bt, EvqTemporary, EpqMedium, 3);
break;
case EHTokMin12int4:
new(&type) TType(min12int_bt, EvqTemporary, EpqMedium, 4);
break;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Add min*{float,int,uint} types These HLSL types are guaranteed to have at least the given number of bits, but may have more. min{16,10}float is mapped to EbtFloat at medium precision -> SPIRV RelaxedPrecision min{16,12}int and min16uint are mapped to mediump -> SPIR-V RelaxedPrecision
2016-10-27 01:18:55 +00:00
case EHTokMin16uint:
new(&type) TType(min16uint_bt, EvqTemporary, EpqMedium);
break;
case EHTokMin16uint1:
new(&type) TType(min16uint_bt, EvqTemporary, EpqMedium);
type.makeVector();
break;
case EHTokMin16uint2:
new(&type) TType(min16uint_bt, EvqTemporary, EpqMedium, 2);
break;
case EHTokMin16uint3:
new(&type) TType(min16uint_bt, EvqTemporary, EpqMedium, 3);
break;
case EHTokMin16uint4:
new(&type) TType(min16uint_bt, EvqTemporary, EpqMedium, 4);
break;
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
case EHTokInt1x1:
new(&type) TType(EbtInt, EvqTemporary, 0, 1, 1);
break;
case EHTokInt1x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 1, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt1x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 1, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt1x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 1, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt2x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 2, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt2x2:
new(&type) TType(EbtInt, EvqTemporary, 0, 2, 2);
break;
case EHTokInt2x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 2, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt2x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 2, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt3x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 3, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt3x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 3, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt3x3:
new(&type) TType(EbtInt, EvqTemporary, 0, 3, 3);
break;
case EHTokInt3x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 3, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt4x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 4, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt4x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 4, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt4x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtInt, EvqTemporary, 0, 4, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokInt4x4:
new(&type) TType(EbtInt, EvqTemporary, 0, 4, 4);
break;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
case EHTokUint1x1:
new(&type) TType(EbtUint, EvqTemporary, 0, 1, 1);
break;
case EHTokUint1x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 1, 2);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint1x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 1, 3);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint1x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 1, 4);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint2x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 2, 1);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint2x2:
new(&type) TType(EbtUint, EvqTemporary, 0, 2, 2);
break;
case EHTokUint2x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 2, 3);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint2x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 2, 4);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint3x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 3, 1);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint3x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 3, 2);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint3x3:
new(&type) TType(EbtUint, EvqTemporary, 0, 3, 3);
break;
case EHTokUint3x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 3, 4);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint4x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 4, 1);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint4x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 4, 2);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint4x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtUint, EvqTemporary, 0, 4, 3);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokUint4x4:
new(&type) TType(EbtUint, EvqTemporary, 0, 4, 4);
break;
case EHTokBool1x1:
new(&type) TType(EbtBool, EvqTemporary, 0, 1, 1);
break;
case EHTokBool1x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 1, 2);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool1x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 1, 3);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool1x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 1, 4);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool2x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 2, 1);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool2x2:
new(&type) TType(EbtBool, EvqTemporary, 0, 2, 2);
break;
case EHTokBool2x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 2, 3);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool2x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 2, 4);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool3x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 3, 1);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool3x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 3, 2);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool3x3:
new(&type) TType(EbtBool, EvqTemporary, 0, 3, 3);
break;
case EHTokBool3x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 3, 4);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool4x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 4, 1);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool4x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 4, 2);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool4x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtBool, EvqTemporary, 0, 4, 3);
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
break;
case EHTokBool4x4:
new(&type) TType(EbtBool, EvqTemporary, 0, 4, 4);
break;
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
case EHTokFloat1x1:
new(&type) TType(EbtFloat, EvqTemporary, 0, 1, 1);
break;
case EHTokFloat1x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 1, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokFloat1x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 1, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokFloat1x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 1, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokFloat2x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 2, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokFloat2x2:
new(&type) TType(EbtFloat, EvqTemporary, 0, 2, 2);
break;
case EHTokFloat2x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 2, 3);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokFloat2x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 2, 4);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
case EHTokFloat3x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 3, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokFloat3x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 3, 2);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokFloat3x3:
new(&type) TType(EbtFloat, EvqTemporary, 0, 3, 3);
break;
case EHTokFloat3x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 3, 4);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
case EHTokFloat4x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 4, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokFloat4x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 4, 2);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokFloat4x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtFloat, EvqTemporary, 0, 4, 3);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokFloat4x4:
new(&type) TType(EbtFloat, EvqTemporary, 0, 4, 4);
break;
HLSL: Implement half matrices, and map all half* -> float*.
2017-06-07 05:35:25 +00:00
case EHTokHalf1x1:
new(&type) TType(half_bt, EvqTemporary, 0, 1, 1);
break;
case EHTokHalf1x2:
new(&type) TType(half_bt, EvqTemporary, 0, 1, 2);
break;
case EHTokHalf1x3:
new(&type) TType(half_bt, EvqTemporary, 0, 1, 3);
break;
case EHTokHalf1x4:
new(&type) TType(half_bt, EvqTemporary, 0, 1, 4);
break;
case EHTokHalf2x1:
new(&type) TType(half_bt, EvqTemporary, 0, 2, 1);
break;
case EHTokHalf2x2:
new(&type) TType(half_bt, EvqTemporary, 0, 2, 2);
break;
case EHTokHalf2x3:
new(&type) TType(half_bt, EvqTemporary, 0, 2, 3);
break;
case EHTokHalf2x4:
new(&type) TType(half_bt, EvqTemporary, 0, 2, 4);
break;
case EHTokHalf3x1:
new(&type) TType(half_bt, EvqTemporary, 0, 3, 1);
break;
case EHTokHalf3x2:
new(&type) TType(half_bt, EvqTemporary, 0, 3, 2);
break;
case EHTokHalf3x3:
new(&type) TType(half_bt, EvqTemporary, 0, 3, 3);
break;
case EHTokHalf3x4:
new(&type) TType(half_bt, EvqTemporary, 0, 3, 4);
break;
case EHTokHalf4x1:
new(&type) TType(half_bt, EvqTemporary, 0, 4, 1);
break;
case EHTokHalf4x2:
new(&type) TType(half_bt, EvqTemporary, 0, 4, 2);
break;
case EHTokHalf4x3:
new(&type) TType(half_bt, EvqTemporary, 0, 4, 3);
break;
case EHTokHalf4x4:
new(&type) TType(half_bt, EvqTemporary, 0, 4, 4);
break;
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
case EHTokDouble1x1:
new(&type) TType(EbtDouble, EvqTemporary, 0, 1, 1);
break;
case EHTokDouble1x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 1, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble1x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 1, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble1x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 1, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble2x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 2, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble2x2:
new(&type) TType(EbtDouble, EvqTemporary, 0, 2, 2);
break;
case EHTokDouble2x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 2, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble2x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 2, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble3x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 3, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble3x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 3, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble3x3:
new(&type) TType(EbtDouble, EvqTemporary, 0, 3, 3);
break;
case EHTokDouble3x4:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 3, 4);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble4x1:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 4, 1);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble4x2:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 4, 2);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble4x3:
WIP: HLSL: Treat HLSL rows as GLSL columns. WIP: HLSL: EOpGenMul arg reversal
2016-08-24 20:36:13 +00:00
new(&type) TType(EbtDouble, EvqTemporary, 0, 4, 3);
HLSL: Add more matrix types to the grammar.
2016-05-20 18:17:26 +00:00
break;
case EHTokDouble4x4:
new(&type) TType(EbtDouble, EvqTemporary, 0, 4, 4);
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
default:
return false;
}
advanceToken();
HLSL: Accept unorm and snorm on types This is currently parsed and ignored, save for some minor validation.
2017-11-14 21:55:40 +00:00
if ((isUnorm || isSnorm) && !type.isFloatingDomain()) {
parseContext.error(token.loc, "unorm and snorm only valid in floating point domain", "", "");
return false;
}
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return true;
}
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// struct
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
// : struct_type IDENTIFIER post_decls LEFT_BRACE struct_declaration_list RIGHT_BRACE
// | struct_type post_decls LEFT_BRACE struct_declaration_list RIGHT_BRACE
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
// | struct_type IDENTIFIER // use of previously declared struct type
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
//
// struct_type
// : STRUCT
HLSL: Add 'class' keyword as (so far) synonym for 'struct'.
2017-03-04 00:01:01 +00:00
// | CLASS
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
// | CBUFFER
// | TBUFFER
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
//
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
bool HlslGrammar::acceptStruct(TType& type, TIntermNode*& nodeList)
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
{
HLSL: Track binding numbers to struct instances; fixes issue #496.
2016-09-05 18:19:18 +00:00
// This storage qualifier will tell us whether it's an AST
// block type or just a generic structure type.
TStorageQualifier storageQualifier = EvqTemporary;
HLSL: add readonly qualifier to tbuffer, so they end up as SRV
2017-04-20 19:16:23 +00:00
bool readonly = false;
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
HLSL: add readonly qualifier to tbuffer, so they end up as SRV
2017-04-20 19:16:23 +00:00
if (acceptTokenClass(EHTokCBuffer)) {
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
// CBUFFER
HLSL: Track binding numbers to struct instances; fixes issue #496.
2016-09-05 18:19:18 +00:00
storageQualifier = EvqUniform;
HLSL: add readonly qualifier to tbuffer, so they end up as SRV
2017-04-20 19:16:23 +00:00
} else if (acceptTokenClass(EHTokTBuffer)) {
HLSL: Remove support for named tbuffer/cbuffer. Fixes #939.
2017-06-19 21:41:11 +00:00
// TBUFFER
HLSL: Track binding numbers to struct instances; fixes issue #496.
2016-09-05 18:19:18 +00:00
storageQualifier = EvqBuffer;
HLSL: add readonly qualifier to tbuffer, so they end up as SRV
2017-04-20 19:16:23 +00:00
readonly = true;
HLSL: Non-functional: Make test valid HLSL, and related comments/cleanup.
2017-06-19 21:13:26 +00:00
} else if (! acceptTokenClass(EHTokClass) && ! acceptTokenClass(EHTokStruct)) {
// Neither CLASS nor STRUCT
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
return false;
HLSL: Non-functional: Make test valid HLSL, and related comments/cleanup.
2017-06-19 21:13:26 +00:00
}
// Now known to be one of CBUFFER, TBUFFER, CLASS, or STRUCT
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
HLSL: allow keyword-identifiers as cbuffer/struct names. Issue #791 was partially fixed by PR #1161 (the mat mul implicit truncations were its main point), but it still wouldn't compile due to the use of ConstantBuffer as an identifier. Apparently those fall into the same class as "float float", where float is both a type and an identifier. This allows struct definitions with such keyword-identifiers, and adds ConstantBuffer to the set. 'cbuffer int' is legal in HLSL, and 'struct int' appears to only be rejected due to the redefinition of the 'int' type. Fixes #791
2017-11-27 21:45:36 +00:00
// IDENTIFIER. It might also be a keyword which can double as an identifier.
// For example: 'cbuffer ConstantBuffer' or 'struct ConstantBuffer' is legal.
// 'cbuffer int' is also legal, and 'struct int' appears rejected only because
// it attempts to redefine the 'int' type.
const char* idString = getTypeString(peek());
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
TString structName = "";
HLSL: allow keyword-identifiers as cbuffer/struct names. Issue #791 was partially fixed by PR #1161 (the mat mul implicit truncations were its main point), but it still wouldn't compile due to the use of ConstantBuffer as an identifier. Apparently those fall into the same class as "float float", where float is both a type and an identifier. This allows struct definitions with such keyword-identifiers, and adds ConstantBuffer to the set. 'cbuffer int' is legal in HLSL, and 'struct int' appears to only be rejected due to the redefinition of the 'int' type. Fixes #791
2017-11-27 21:45:36 +00:00
if (peekTokenClass(EHTokIdentifier) || idString != nullptr) {
if (idString != nullptr)
structName = *idString;
else
structName = *token.string;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
advanceToken();
}
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
// post_decls
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
TQualifier postDeclQualifier;
postDeclQualifier.clear();
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
bool postDeclsFound = acceptPostDecls(postDeclQualifier);
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
// LEFT_BRACE, or
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
// struct_type IDENTIFIER
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
if (! acceptTokenClass(EHTokLeftBrace)) {
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
if (structName.size() > 0 && !postDeclsFound && parseContext.lookupUserType(structName, type) != nullptr) {
// struct_type IDENTIFIER
return true;
} else {
expected("{");
return false;
}
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
}
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// struct_declaration_list
TTypeList* typeList;
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
// Save each member function so they can be processed after we have a fully formed 'this'.
TVector<TFunctionDeclarator> functionDeclarators;
parseContext.pushNamespace(structName);
Fix #800 (mostly): set of Linux warnings.
2017-03-28 15:52:38 +00:00
bool acceptedList = acceptStructDeclarationList(typeList, nodeList, functionDeclarators);
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
parseContext.popNamespace();
if (! acceptedList) {
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
expected("struct member declarations");
return false;
}
// RIGHT_BRACE
if (! acceptTokenClass(EHTokRightBrace)) {
expected("}");
return false;
}
// create the user-defined type
HLSL: Track binding numbers to struct instances; fixes issue #496.
2016-09-05 18:19:18 +00:00
if (storageQualifier == EvqTemporary)
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
new(&type) TType(typeList, structName);
HLSL: Track binding numbers to struct instances; fixes issue #496.
2016-09-05 18:19:18 +00:00
else {
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
postDeclQualifier.storage = storageQualifier;
HLSL: add readonly qualifier to tbuffer, so they end up as SRV
2017-04-20 19:16:23 +00:00
postDeclQualifier.readonly = readonly;
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
new(&type) TType(typeList, structName, postDeclQualifier); // sets EbtBlock
HLSL: Track binding numbers to struct instances; fixes issue #496.
2016-09-05 18:19:18 +00:00
}
HLSL: cbuffer and tbuffer grammar and production.
2016-07-25 22:05:33 +00:00
HLSL: Build IO types bottom up, as parsed, and cache the original (IO). Previously, this was done recursively, per object, and the nonIO version was cached. This reverses both those approaches.
2017-02-04 00:57:55 +00:00
parseContext.declareStruct(token.loc, structName, type);
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
// For member functions: now that we know the type of 'this', go back and
// - add their implicit argument with 'this' (not to the mangling, just the argument list)
// - parse the functions, their tokens were saved for deferred parsing (now)
for (int b = 0; b < (int)functionDeclarators.size(); ++b) {
// update signature
if (functionDeclarators[b].function->hasImplicitThis())
HLSL: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
functionDeclarators[b].function->addThisParameter(type, intermediate.implicitThisName);
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
}
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
// All member functions get parsed inside the class/struct namespace and with the
// class/struct members in a symbol-table level.
parseContext.pushNamespace(structName);
HLSL: Implement member functions calling member functions.
2017-05-17 05:16:26 +00:00
parseContext.pushThisScope(type, functionDeclarators);
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
bool deferredSuccess = true;
for (int b = 0; b < (int)functionDeclarators.size() && deferredSuccess; ++b) {
// parse body
pushTokenStream(functionDeclarators[b].body);
if (! acceptFunctionBody(functionDeclarators[b], nodeList))
deferredSuccess = false;
popTokenStream();
}
HLSL: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
parseContext.popThisScope();
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
parseContext.popNamespace();
return deferredSuccess;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
}
HLSL: Add ConstantBuffer<T> syntax Note: multi-dimension arrays of ConstantBuffer objects will go through uniform flattening.
2017-04-25 15:30:28 +00:00
// constantbuffer
// : CONSTANTBUFFER LEFT_ANGLE type RIGHT_ANGLE
bool HlslGrammar::acceptConstantBufferType(TType& type)
{
if (! acceptTokenClass(EHTokConstantBuffer))
return false;
if (! acceptTokenClass(EHTokLeftAngle)) {
expected("left angle bracket");
return false;
}
TType templateType;
if (! acceptType(templateType)) {
expected("type");
return false;
}
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
TQualifier postDeclQualifier;
postDeclQualifier.clear();
postDeclQualifier.storage = EvqUniform;
if (templateType.isStruct()) {
// Make a block from the type parsed as the template argument
TTypeList* typeList = templateType.getWritableStruct();
new(&type) TType(typeList, "", postDeclQualifier); // sets EbtBlock
type.getQualifier().storage = EvqUniform;
return true;
} else {
parseContext.error(token.loc, "non-structure type in ConstantBuffer", "", "");
return false;
}
}
HLSL: implement TextureBuffer<type> Almost equivalent to tbuffer, except members not at global scope. So, reference is "TextureBuffer_var.member", not simply "member".
2017-11-09 02:48:11 +00:00
// texture_buffer
// : TEXTUREBUFFER LEFT_ANGLE type RIGHT_ANGLE
bool HlslGrammar::acceptTextureBufferType(TType& type)
{
if (! acceptTokenClass(EHTokTextureBuffer))
return false;
if (! acceptTokenClass(EHTokLeftAngle)) {
expected("left angle bracket");
return false;
}
TType templateType;
if (! acceptType(templateType)) {
expected("type");
return false;
}
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
templateType.getQualifier().storage = EvqBuffer;
templateType.getQualifier().readonly = true;
TType blockType(templateType.getWritableStruct(), "", templateType.getQualifier());
blockType.getQualifier().storage = EvqBuffer;
blockType.getQualifier().readonly = true;
type.shallowCopy(blockType);
return true;
}
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
// struct_buffer
// : APPENDSTRUCTUREDBUFFER
// | BYTEADDRESSBUFFER
// | CONSUMESTRUCTUREDBUFFER
// | RWBYTEADDRESSBUFFER
// | RWSTRUCTUREDBUFFER
// | STRUCTUREDBUFFER
bool HlslGrammar::acceptStructBufferType(TType& type)
{
const EHlslTokenClass structBuffType = peek();
// TODO: globallycoherent
bool hasTemplateType = true;
bool readonly = false;
TStorageQualifier storage = EvqBuffer;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
TBuiltInVariable builtinType = EbvNone;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
switch (structBuffType) {
case EHTokAppendStructuredBuffer:
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
builtinType = EbvAppendConsume;
break;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
case EHTokByteAddressBuffer:
hasTemplateType = false;
readonly = true;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
builtinType = EbvByteAddressBuffer;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
break;
case EHTokConsumeStructuredBuffer:
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
builtinType = EbvAppendConsume;
break;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
case EHTokRWByteAddressBuffer:
hasTemplateType = false;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
builtinType = EbvRWByteAddressBuffer;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
break;
case EHTokRWStructuredBuffer:
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
builtinType = EbvRWStructuredBuffer;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
break;
case EHTokStructuredBuffer:
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
builtinType = EbvStructuredBuffer;
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
readonly = true;
break;
default:
return false; // not a structure buffer type
}
advanceToken(); // consume the structure keyword
// type on which this StructedBuffer is templatized. E.g, StructedBuffer<MyStruct> ==> MyStruct
TType* templateType = new TType;
if (hasTemplateType) {
if (! acceptTokenClass(EHTokLeftAngle)) {
expected("left angle bracket");
return false;
}
if (! acceptType(*templateType)) {
expected("type");
return false;
}
if (! acceptTokenClass(EHTokRightAngle)) {
expected("right angle bracket");
return false;
}
} else {
// byte address buffers have no explicit type.
TType uintType(EbtUint, storage);
templateType->shallowCopy(uintType);
}
// Create an unsized array out of that type.
// TODO: does this work if it's already an array type?
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
TArraySizes* unsizedArray = new TArraySizes;
unsizedArray->addInnerSize(UnsizedArraySize);
templateType->transferArraySizes(unsizedArray);
WIP: HLSL: Fix ordering defect if global SB decl after fn param This change propagates the storage qualifier from the buffer object to its contained array type so that isStructBufferType() realizes it is one. That propagation was happening before only for global variable declarations, so compilation defects would result if the use of a function parameter happened before a global declaration. This fixes that case, whether or not there ever is a global declaration, and regardless of the relative order. This changes the hlsl.structbuffer.fn.frag test to exercise the alternate order. There are no differences to generated SPIR-V for the cases which successfully compiled before.
2017-03-06 19:01:44 +00:00
templateType->getQualifier().storage = storage;
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// field name is canonical for all structbuffers
templateType->setFieldName("@data");
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
TTypeList* blockStruct = new TTypeList;
TTypeLoc member = { templateType, token.loc };
blockStruct->push_back(member);
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// This is the type of the buffer block (SSBO)
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
TType blockType(blockStruct, "", templateType->getQualifier());
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
blockType.getQualifier().storage = storage;
blockType.getQualifier().readonly = readonly;
WIP: HLSL: structuredbuffer counter functionality This is WIP, heavy on the IP part. There's not yet enough to use in real workloads. Currently present: * Creation of separate counter buffers for structured buffer types needing them. * IncrementCounter / DecrementCounter methods * Postprocess to remove unused counter buffers from linkage * Associated counter buffers are given @count suffix (invalid as a user identifier) Not yet present: * reflection queries to obtain bindings for counter buffers * Append/Consume buffers * Ability to use SB references passed as fn parameters
2017-04-10 14:19:21 +00:00
blockType.getQualifier().builtIn = builtinType;
WIP: HLSL: add structuredbuffer pass by reference in fn params This PR adds the ability to pass structuredbuffer types by reference as function parameters. It also changes the representation of structuredbuffers from anonymous blocks with named members, to named blocks with pseudonymous members. That should not be an externally visible change.
2017-02-24 01:04:12 +00:00
// We may have created an equivalent type before, in which case we should use its
// deep structure.
parseContext.shareStructBufferType(blockType);
HLSL: implement 4 (of 6) structuredbuffer types This is a partial implemention of structurebuffers supporting: * structured buffer types of: * StructuredBuffer * RWStructuredBuffer * ByteAddressBuffer * RWByteAddressBuffer * Atomic operations on RWByteAddressBuffer * Load/Load[234], Store/Store[234], GetDimensions methods (where allowed by type) * globallycoherent flag But NOT yet supporting: * AppendStructuredBuffer / ConsumeStructuredBuffer types * IncrementCounter/DecrementCounter methods Please note: the stride returned by GetDimensions is as calculated by glslang for std430, and may not match other environments in all cases.
2017-02-13 00:50:28 +00:00
type.shallowCopy(blockType);
return true;
}
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// struct_declaration_list
// : struct_declaration SEMI_COLON struct_declaration SEMI_COLON ...
//
// struct_declaration
HLSL: Fix #1154: Support PointSize, as an attribute.
2017-12-06 14:33:36 +00:00
// : attributes fully_specified_type struct_declarator COMMA struct_declarator ...
// | attributes fully_specified_type IDENTIFIER function_parameters post_decls compound_statement // member-function definition
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
//
// struct_declarator
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
// : IDENTIFIER post_decls
// | IDENTIFIER array_specifier post_decls
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// | IDENTIFIER function_parameters post_decls // member-function prototype
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
//
Fix #800 (mostly): set of Linux warnings.
2017-03-28 15:52:38 +00:00
bool HlslGrammar::acceptStructDeclarationList(TTypeList*& typeList, TIntermNode*& nodeList,
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
TVector<TFunctionDeclarator>& declarators)
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
{
typeList = new TTypeList();
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
HlslToken idToken;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
do {
// success on seeing the RIGHT_BRACE coming up
if (peekTokenClass(EHTokRightBrace))
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
break;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// struct_declaration
HLSL: Fix #1154: Support PointSize, as an attribute.
2017-12-06 14:33:36 +00:00
// attributes
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
TAttributes attributes;
HLSL: Fix #1154: Support PointSize, as an attribute.
2017-12-06 14:33:36 +00:00
acceptAttributes(attributes);
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
bool declarator_list = false;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// fully_specified_type
TType memberType;
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
if (! acceptFullySpecifiedType(memberType, nodeList, attributes)) {
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
expected("member type");
return false;
}
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
// merge in the attributes
parseContext.transferTypeAttributes(token.loc, attributes, memberType);
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// struct_declarator COMMA struct_declarator ...
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
bool functionDefinitionAccepted = false;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
do {
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
if (! acceptIdentifier(idToken)) {
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
expected("member name");
return false;
}
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
if (peekTokenClass(EHTokLeftParen)) {
// function_parameters
if (!declarator_list) {
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
declarators.resize(declarators.size() + 1);
// request a token stream for deferred processing
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
functionDefinitionAccepted = acceptMemberFunctionDefinition(nodeList, memberType, *idToken.string,
declarators.back());
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
if (functionDefinitionAccepted)
break;
}
expected("member-function definition");
return false;
} else {
// add it to the list of members
TTypeLoc member = { new TType(EbtVoid), token.loc };
member.type->shallowCopy(memberType);
member.type->setFieldName(*idToken.string);
typeList->push_back(member);
// array_specifier
TArraySizes* arraySizes = nullptr;
acceptArraySpecifier(arraySizes);
if (arraySizes)
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
typeList->back().type->transferArraySizes(arraySizes);
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
acceptPostDecls(member.type->getQualifier());
// EQUAL assignment_expression
if (acceptTokenClass(EHTokAssign)) {
parseContext.warn(idToken.loc, "struct-member initializers ignored", "typedef", "");
TIntermTyped* expressionNode = nullptr;
if (! acceptAssignmentExpression(expressionNode)) {
expected("initializer");
return false;
}
Resolve issue #700: allow initializers on struct members.
2017-02-02 22:16:20 +00:00
}
}
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
// success on seeing the SEMICOLON coming up
if (peekTokenClass(EHTokSemicolon))
break;
// COMMA
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
if (acceptTokenClass(EHTokComma))
declarator_list = true;
else {
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
expected(",");
return false;
}
} while (true);
// SEMI_COLON
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
if (! functionDefinitionAccepted && ! acceptTokenClass(EHTokSemicolon)) {
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
expected(";");
return false;
}
} while (true);
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
return true;
HLSL: Implement basic "struct" grammar.
2016-06-11 22:43:14 +00:00
}
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// member_function_definition
// | function_parameters post_decls compound_statement
//
// Expects type to have EvqGlobal for a static member and
// EvqTemporary for non-static member.
GLSL: Promote HLSL entry-point renaming code to be used by GLSL as well. Fixes #1045.
2017-09-12 03:48:19 +00:00
bool HlslGrammar::acceptMemberFunctionDefinition(TIntermNode*& nodeList, const TType& type, TString& memberName,
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
TFunctionDeclarator& declarator)
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
{
bool accepted = false;
GLSL: Promote HLSL entry-point renaming code to be used by GLSL as well. Fixes #1045.
2017-09-12 03:48:19 +00:00
TString* functionName = &memberName;
Non-functional: Round of adding 'const', related to more efficient getFullNamespaceName().
2017-03-29 05:43:10 +00:00
parseContext.getFullNamespaceName(functionName);
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
declarator.function = new TFunction(functionName, type);
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
if (type.getQualifier().storage == EvqTemporary)
declarator.function->setImplicitThis();
HLSL: non-static member functions: track and find active anonymous 'this' scopes and members. Thanks to @steve-lunarg for his input and discussions on handling member functions.
2017-03-22 05:56:40 +00:00
else
declarator.function->setIllegalImplicitThis();
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// function_parameters
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
if (acceptFunctionParameters(*declarator.function)) {
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// post_decls
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
acceptPostDecls(declarator.function->getWritableType().getQualifier());
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// compound_statement (function body definition)
if (peekTokenClass(EHTokLeftBrace)) {
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
declarator.loc = token.loc;
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
declarator.body = new TVector<HlslToken>;
accepted = acceptFunctionDefinition(declarator, nodeList, declarator.body);
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
}
} else
expected("function parameter list");
return accepted;
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// function_parameters
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// : LEFT_PAREN parameter_declaration COMMA parameter_declaration ... RIGHT_PAREN
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
// | LEFT_PAREN VOID RIGHT_PAREN
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
//
bool HlslGrammar::acceptFunctionParameters(TFunction& function)
{
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// LEFT_PAREN
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
if (! acceptTokenClass(EHTokLeftParen))
return false;
HLSL: Add all int/float/bool/uint matrix types, void for functions, and a few others.
2016-06-08 18:50:56 +00:00
// VOID RIGHT_PAREN
if (! acceptTokenClass(EHTokVoid)) {
do {
// parameter_declaration
if (! acceptParameterDeclaration(function))
break;
// COMMA
if (! acceptTokenClass(EHTokComma))
break;
} while (true);
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// RIGHT_PAREN
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
if (! acceptTokenClass(EHTokRightParen)) {
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
expected(")");
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
return false;
}
return true;
}
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
// default_parameter_declaration
// : EQUAL conditional_expression
// : EQUAL initializer
bool HlslGrammar::acceptDefaultParameterDeclaration(const TType& type, TIntermTyped*& node)
{
node = nullptr;
// Valid not to have a default_parameter_declaration
if (!acceptTokenClass(EHTokAssign))
return true;
if (!acceptConditionalExpression(node)) {
if (!acceptInitializer(node))
return false;
// For initializer lists, we have to const-fold into a constructor for the type, so build
// that.
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TFunction* constructor = parseContext.makeConstructorCall(token.loc, type);
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
if (constructor == nullptr) // cannot construct
return false;
TIntermTyped* arguments = nullptr;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
for (int i = 0; i < int(node->getAsAggregate()->getSequence().size()); i++)
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
parseContext.handleFunctionArgument(constructor, arguments, node->getAsAggregate()->getSequence()[i]->getAsTyped());
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
node = parseContext.handleFunctionCall(token.loc, constructor, node);
}
HLSL: Validate implicit initializer assignment to opaque members. Fixes #1091.
2017-10-07 19:23:09 +00:00
if (node == nullptr)
return false;
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
// If this is simply a constant, we can use it directly.
if (node->getAsConstantUnion())
return true;
// Otherwise, it has to be const-foldable.
TIntermTyped* origNode = node;
node = intermediate.fold(node->getAsAggregate());
if (node != nullptr && origNode != node)
return true;
parseContext.error(token.loc, "invalid default parameter value", "", "");
return false;
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// parameter_declaration
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
// : attributes attributed_declaration
//
// attributed_declaration
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
// : fully_specified_type post_decls [ = default_parameter_declaration ]
// | fully_specified_type identifier array_specifier post_decls [ = default_parameter_declaration ]
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
//
bool HlslGrammar::acceptParameterDeclaration(TFunction& function)
{
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
// attributes
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
TAttributes attributes;
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
acceptAttributes(attributes);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// fully_specified_type
TType* type = new TType;
HLSL: Attributes: Add [[vk::constant_id()]] and [[vk::push_constant]]
2017-12-24 00:29:45 +00:00
if (! acceptFullySpecifiedType(*type, attributes))
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
return false;
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
// merge in the attributes
parseContext.transferTypeAttributes(token.loc, attributes, *type);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// identifier
HLSL: Abstract accepting an identifier.
2016-03-14 16:46:34 +00:00
HlslToken idToken;
acceptIdentifier(idToken);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// array_specifier
TArraySizes* arraySizes = nullptr;
acceptArraySpecifier(arraySizes);
HLSL: allow implicit array sizing. In HLSL array sizes need not be provided explicitly in all circumstances. For example, this is valid (note no number between the [ ]): // no explicit array size uniform float g_array[] = { 1, 2, 3, 4, 5 }; This PR does not attempt to validate most invalid cases. A new test is added to verify the resulting linker objects.
2016-09-27 16:57:35 +00:00
if (arraySizes) {
Non-functional. Rationalizations enabling future generalizations: - Use much simpler method to update implicit array sizes. The previous overly complicated method was error prone. - Rationalize all use of unsized arrays. - Combine decorations when generating SPIR-V, to simplify adding extensions.
2018-03-29 00:01:20 +00:00
if (arraySizes->hasUnsized()) {
parseContext.error(token.loc, "function parameter requires array size", "[]", "");
HLSL: allow implicit array sizing. In HLSL array sizes need not be provided explicitly in all circumstances. For example, this is valid (note no number between the [ ]): // no explicit array size uniform float g_array[] = { 1, 2, 3, 4, 5 }; This PR does not attempt to validate most invalid cases. A new test is added to verify the resulting linker objects.
2016-09-27 16:57:35 +00:00
return false;
}
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
type->transferArraySizes(arraySizes);
HLSL: allow implicit array sizing. In HLSL array sizes need not be provided explicitly in all circumstances. For example, this is valid (note no number between the [ ]): // no explicit array size uniform float g_array[] = { 1, 2, 3, 4, 5 }; This PR does not attempt to validate most invalid cases. A new test is added to verify the resulting linker objects.
2016-09-27 16:57:35 +00:00
}
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// post_decls
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
acceptPostDecls(type->getQualifier());
HLSL: Support semantics in function parameter declarations.
2016-06-17 20:21:02 +00:00
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
TIntermTyped* defaultValue;
if (!acceptDefaultParameterDeclaration(*type, defaultValue))
return false;
HLSL: Map parameter qualifiers from generic to function-specific and entry-point specific.
2016-06-17 21:50:47 +00:00
parseContext.paramFix(*type);
HLSL default function parameters This PR adds support for default function parameters in the following cases: 1. Simple constants, such as void fn(int x, float myparam = 3) 2. Expressions that can be const folded, such a ... myparam = sin(some_const) 3. Initializer lists that can be const folded, such as ... float2 myparam = {1,2} New tests are added: hlsl.params.default.frag and hlsl.params.default.err.frag (for testing error situations, such as ambiguity or non-const-foldable). In order to avoid sampler method ambiguity, the hlsl better() lambda now considers sampler matches. Previously, all sampler types looked identical since only the basic type of EbtSampler was considered.
2016-12-24 01:56:57 +00:00
// If any prior parameters have default values, all the parameters after that must as well.
if (defaultValue == nullptr && function.getDefaultParamCount() > 0) {
parseContext.error(idToken.loc, "invalid parameter after default value parameters", idToken.string->c_str(), "");
return false;
}
TParameter param = { idToken.string, type, defaultValue };
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
function.addParameter(param);
return true;
}
// Do the work to create the function definition in addition to
// parsing the body (compound_statement).
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
//
// If 'deferredTokens' are passed in, just get the token stream,
// don't process.
//
bool HlslGrammar::acceptFunctionDefinition(TFunctionDeclarator& declarator, TIntermNode*& nodeList,
TVector<HlslToken>* deferredTokens)
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
{
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
parseContext.handleFunctionDeclarator(declarator.loc, *declarator.function, false /* not prototype */);
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
if (deferredTokens)
return captureBlockTokens(*deferredTokens);
else
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
return acceptFunctionBody(declarator, nodeList);
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
bool HlslGrammar::acceptFunctionBody(TFunctionDeclarator& declarator, TIntermNode*& nodeList)
{
// we might get back an entry-point
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
TIntermNode* entryPointNode = nullptr;
HLSL: Implement proper nesting of symbol-table scopes and identifier searching.
2016-06-09 08:02:17 +00:00
// This does a pushScope()
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
TIntermNode* functionNode = parseContext.handleFunctionDefinition(declarator.loc, *declarator.function,
declarator.attributes, entryPointNode);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// compound_statement
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
TIntermNode* functionBody = nullptr;
HLSL: Wrap the entry-point; need to write 'in' args, and support 'inout' args. This needs some render testing, but is destined to be part of master. This also leads to a variety of other simplifications. - IO are global symbols, so only need one list of linkage nodes (deferred) - no longer need parse-context-wide 'inEntryPoint' state, entry-point is localized - several parts of splitting/flattening are now localized
2017-01-19 22:41:47 +00:00
if (! acceptCompoundStatement(functionBody))
return false;
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// this does a popScope()
HLSL: Non-functional: consolidate function declarator information.
2017-03-12 00:55:28 +00:00
parseContext.handleFunctionBody(declarator.loc, *declarator.function, functionBody, functionNode);
HLSL: Grammar: Generalize accepting a declaration to accept an aggregate of subtrees. This is slightly cleaner today for entry-point wrapping, which sometimes made two subtrees for a function definition instead of just one subtree. It will be critical though for recognizing a struct with multiple member functions.
2017-03-08 03:44:09 +00:00
// Hook up the 1 or 2 function definitions.
nodeList = intermediate.growAggregate(nodeList, functionNode);
nodeList = intermediate.growAggregate(nodeList, entryPointNode);
HLSL: Wrap the entry-point; need to write 'in' args, and support 'inout' args. This needs some render testing, but is destined to be part of master. This also leads to a variety of other simplifications. - IO are global symbols, so only need one list of linkage nodes (deferred) - no longer need parse-context-wide 'inEntryPoint' state, entry-point is localized - several parts of splitting/flattening are now localized
2017-01-19 22:41:47 +00:00
return true;
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// Accept an expression with parenthesis around it, where
// the parenthesis ARE NOT expression parenthesis, but the
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
// syntactically required ones like in "if ( expression )".
//
// Also accepts a declaration expression; "if (int a = expression)".
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
//
// Note this one is not set up to be speculative; as it gives
// errors if not found.
//
bool HlslGrammar::acceptParenExpression(TIntermTyped*& expression)
{
Add initialization in case it is causing the Apple Clang release failure.
2017-11-29 23:32:46 +00:00
expression = nullptr;
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// LEFT_PAREN
if (! acceptTokenClass(EHTokLeftParen))
expected("(");
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
bool decl = false;
TIntermNode* declNode = nullptr;
decl = acceptControlDeclaration(declNode);
if (decl) {
if (declNode == nullptr || declNode->getAsTyped() == nullptr) {
expected("initialized declaration");
return false;
} else
expression = declNode->getAsTyped();
} else {
// no declaration
if (! acceptExpression(expression)) {
expected("expression");
return false;
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
}
// RIGHT_PAREN
if (! acceptTokenClass(EHTokRightParen))
expected(")");
return true;
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// The top-level full expression recognizer.
//
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
// expression
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// : assignment_expression COMMA assignment_expression COMMA assignment_expression ...
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
//
bool HlslGrammar::acceptExpression(TIntermTyped*& node)
{
Fix for empty statement segfault.
2016-06-03 15:17:51 +00:00
node = nullptr;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// assignment_expression
if (! acceptAssignmentExpression(node))
return false;
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
if (! peekTokenClass(EHTokComma))
return true;
do {
// ... COMMA
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
TSourceLoc loc = token.loc;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
advanceToken();
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// ... assignment_expression
TIntermTyped* rightNode = nullptr;
if (! acceptAssignmentExpression(rightNode)) {
expected("assignment expression");
return false;
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
node = intermediate.addComma(node, rightNode, loc);
if (! peekTokenClass(EHTokComma))
return true;
} while (true);
}
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
// initializer
HLSL: Support {...} initializer lists that are too short.
2016-11-28 00:39:07 +00:00
// : LEFT_BRACE RIGHT_BRACE
// | LEFT_BRACE initializer_list RIGHT_BRACE
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
//
// initializer_list
// : assignment_expression COMMA assignment_expression COMMA ...
//
bool HlslGrammar::acceptInitializer(TIntermTyped*& node)
{
// LEFT_BRACE
if (! acceptTokenClass(EHTokLeftBrace))
return false;
HLSL: Support {...} initializer lists that are too short.
2016-11-28 00:39:07 +00:00
// RIGHT_BRACE
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
TSourceLoc loc = token.loc;
HLSL: Support {...} initializer lists that are too short.
2016-11-28 00:39:07 +00:00
if (acceptTokenClass(EHTokRightBrace)) {
// a zero-length initializer list
node = intermediate.makeAggregate(loc);
return true;
}
// initializer_list
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
node = nullptr;
do {
// assignment_expression
TIntermTyped* expr;
if (! acceptAssignmentExpression(expr)) {
expected("assignment expression in initializer list");
return false;
}
WIP: HLSL: support global const initializers from non-constant rvalues Semantic test left over from other source languages is removed, since this is permitted by HLSL. Also, to support the functionality, a targeted test is performed for this case and it is turned into a EvqGlobal qualifier to create an AST initialization segment when needed. Constness is now propagated up aggregate chains during initializer construction. This handles hierarchical cases such as the distinction between: static const float2 a[2] = { { 1, 2 }, { 3, 4} }; vs static const float2 a[2] = { { 1, 2 }, { cbuffer_member, 4} }; The first of which can use a first class constant initalization, and the second cannot.
2017-07-10 21:43:40 +00:00
const bool firstNode = (node == nullptr);
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
node = intermediate.growAggregate(node, expr, loc);
WIP: HLSL: support global const initializers from non-constant rvalues Semantic test left over from other source languages is removed, since this is permitted by HLSL. Also, to support the functionality, a targeted test is performed for this case and it is turned into a EvqGlobal qualifier to create an AST initialization segment when needed. Constness is now propagated up aggregate chains during initializer construction. This handles hierarchical cases such as the distinction between: static const float2 a[2] = { { 1, 2 }, { 3, 4} }; vs static const float2 a[2] = { { 1, 2 }, { cbuffer_member, 4} }; The first of which can use a first class constant initalization, and the second cannot.
2017-07-10 21:43:40 +00:00
// If every sub-node in the list has qualifier EvqConst, the returned node becomes
// EvqConst. Otherwise, it becomes EvqTemporary. That doesn't happen with e.g.
// EvqIn or EvqPosition, since the collection isn't EvqPosition if all the members are.
if (firstNode && expr->getQualifier().storage == EvqConst)
node->getQualifier().storage = EvqConst;
else if (expr->getQualifier().storage != EvqConst)
node->getQualifier().storage = EvqTemporary;
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
// COMMA
HLSL: allow trailing commas in initializer lists & scalar initialization
2016-07-30 16:36:09 +00:00
if (acceptTokenClass(EHTokComma)) {
if (acceptTokenClass(EHTokRightBrace)) // allow trailing comma
return true;
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
continue;
HLSL: allow trailing commas in initializer lists & scalar initialization
2016-07-30 16:36:09 +00:00
}
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
// RIGHT_BRACE
if (acceptTokenClass(EHTokRightBrace))
return true;
expected(", or }");
return false;
} while (true);
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// Accept an assignment expression, where assignment operations
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
// associate right-to-left. That is, it is implicit, for example
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
//
// a op (b op (c op d))
//
// assigment_expression
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
// : initializer
// | conditional_expression
// | conditional_expression assign_op conditional_expression assign_op conditional_expression ...
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
//
bool HlslGrammar::acceptAssignmentExpression(TIntermTyped*& node)
{
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
// initializer
if (peekTokenClass(EHTokLeftBrace)) {
if (acceptInitializer(node))
return true;
expected("initializer");
return false;
}
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
// conditional_expression
if (! acceptConditionalExpression(node))
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
return false;
HLSL: Grammar: Recognize { } style initializers for composites.
2016-07-02 01:58:06 +00:00
// assignment operation?
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
TOperator assignOp = HlslOpMap::assignment(peek());
if (assignOp == EOpNull)
return true;
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
// assign_op
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
TSourceLoc loc = token.loc;
advanceToken();
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
// conditional_expression assign_op conditional_expression ...
// Done by recursing this function, which automatically
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// gets the right-to-left associativity.
TIntermTyped* rightNode = nullptr;
if (! acceptAssignmentExpression(rightNode)) {
expected("assignment expression");
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
return false;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
}
HLSL: Flatten whole-struct assigns and returns when targeting flattened I/O structs.
2016-09-16 09:05:12 +00:00
node = parseContext.handleAssign(loc, assignOp, node, rightNode);
HLSL: phase 2b: add l-value operator[] for RWTexture/RWBuffer This commit adds l-value support for RW texture and buffer objects. Supported are: - pre and post inc/decrement - function out parameters - op-assignments, such as *=, +-, etc. - result values from op-assignments. e.g, val=(MyRwTex[loc] *= 2); Not supported are: - Function inout parameters - multiple post-inc/decrement operators. E.g, MyRWTex[loc]++++;
2016-10-08 01:35:40 +00:00
node = parseContext.handleLvalue(loc, "assign", node);
HLSL: Add shape conversions for scalar -> vector assigments. Also, this allows turning on the error check for a failed assigment when parsing. This makes 39 HLSL tests have a working assignment that was previously silently dropped, due to lack of this functionality.
2016-07-28 23:53:56 +00:00
if (node == nullptr) {
parseContext.error(loc, "could not create assignment", "", "");
return false;
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
if (! peekTokenClass(EHTokComma))
return true;
return true;
}
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
// Accept a conditional expression, which associates right-to-left,
// accomplished by the "true" expression calling down to lower
// precedence levels than this level.
//
// conditional_expression
// : binary_expression
// | binary_expression QUESTION expression COLON assignment_expression
//
bool HlslGrammar::acceptConditionalExpression(TIntermTyped*& node)
{
// binary_expression
if (! acceptBinaryExpression(node, PlLogicalOr))
return false;
if (! acceptTokenClass(EHTokQuestion))
return true;
HLSL: Support vector 'cond ? :' -> EOpMix -> OpSelect.
2017-04-12 01:45:00 +00:00
node = parseContext.convertConditionalExpression(token.loc, node, false);
HLSL: Implicit bool conversions for conditional expressions and related. Covers if(cond), while(cond), do-while(cond), for(;cond;), and (cond ? :). Fixes #778.
2017-03-31 04:09:30 +00:00
if (node == nullptr)
return false;
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
++parseContext.controlFlowNestingLevel; // this only needs to work right if no errors
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
TIntermTyped* trueNode = nullptr;
if (! acceptExpression(trueNode)) {
expected("expression after ?");
return false;
}
TSourceLoc loc = token.loc;
if (! acceptTokenClass(EHTokColon)) {
expected(":");
return false;
}
TIntermTyped* falseNode = nullptr;
if (! acceptAssignmentExpression(falseNode)) {
expected("expression after :");
return false;
}
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
--parseContext.controlFlowNestingLevel;
HLSL: Implement ?: grammar productions. Missing are implicit conversions between int/bool/etc.
2016-07-27 16:39:57 +00:00
node = intermediate.addSelection(node, trueNode, falseNode, loc);
return true;
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// Accept a binary expression, for binary operations that
// associate left-to-right. This is, it is implicit, for example
//
// ((a op b) op c) op d
//
// binary_expression
// : expression op expression op expression ...
//
// where 'expression' is the next higher level in precedence.
//
bool HlslGrammar::acceptBinaryExpression(TIntermTyped*& node, PrecedenceLevel precedenceLevel)
{
if (precedenceLevel > PlMul)
return acceptUnaryExpression(node);
// assignment_expression
if (! acceptBinaryExpression(node, (PrecedenceLevel)(precedenceLevel + 1)))
return false;
do {
HLSL: Fix binary-expression associativity and termination issue.
2016-07-29 03:43:17 +00:00
TOperator op = HlslOpMap::binary(peek());
PrecedenceLevel tokenLevel = HlslOpMap::precedenceLevel(op);
if (tokenLevel < precedenceLevel)
return true;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// ... op
TSourceLoc loc = token.loc;
advanceToken();
// ... expression
TIntermTyped* rightNode = nullptr;
if (! acceptBinaryExpression(rightNode, (PrecedenceLevel)(precedenceLevel + 1))) {
expected("expression");
return false;
}
node = intermediate.addBinaryMath(op, node, rightNode, loc);
HLSL: Add shape conversions for scalar -> vector assigments. Also, this allows turning on the error check for a failed assigment when parsing. This makes 39 HLSL tests have a working assignment that was previously silently dropped, due to lack of this functionality.
2016-07-28 23:53:56 +00:00
if (node == nullptr) {
parseContext.error(loc, "Could not perform requested binary operation", "", "");
return false;
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
} while (true);
}
// unary_expression
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
// : (type) unary_expression
// | + unary_expression
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// | - unary_expression
// | ! unary_expression
// | ~ unary_expression
// | ++ unary_expression
// | -- unary_expression
// | postfix_expression
//
bool HlslGrammar::acceptUnaryExpression(TIntermTyped*& node)
{
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
// (type) unary_expression
// Have to look two steps ahead, because this could be, e.g., a
// postfix_expression instead, since that also starts with at "(".
if (acceptTokenClass(EHTokLeftParen)) {
TType castType;
if (acceptType(castType)) {
HLSL: Fix #924: Convert between two different arrays with cast.
2017-06-14 05:13:10 +00:00
// recognize any array_specifier as part of the type
TArraySizes* arraySizes = nullptr;
acceptArraySpecifier(arraySizes);
if (arraySizes != nullptr)
Types: Fix #1290: Rationalize and correct "mixed" style array dimensioning. There a couple functional problems, which when reduced down also led to some good simplifications and rationalization. So, this commit: - corrects "mixed" functionality: int[A] f[B] -> f[B][A] - correct multi-identifier decls: int[A] f[B], g[C] -> f and g are independently sized. - increases symmetry between different places in the code that do this - makes fewer ways to do the same thing; several methods are just gone now - makes more clear when something is copied or shared
2018-03-26 06:38:53 +00:00
castType.transferArraySizes(arraySizes);
HLSL: Fix #924: Convert between two different arrays with cast.
2017-06-14 05:13:10 +00:00
TSourceLoc loc = token.loc;
HLSL: Fix a grammar error related to constructors in parenthetical expressions
2016-07-30 13:38:55 +00:00
if (acceptTokenClass(EHTokRightParen)) {
// We've matched "(type)" now, get the expression to cast
if (! acceptUnaryExpression(node))
return false;
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
HLSL: Fix a grammar error related to constructors in parenthetical expressions
2016-07-30 13:38:55 +00:00
// Hook it up like a constructor
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TFunction* constructorFunction = parseContext.makeConstructorCall(loc, castType);
HLSL: Fix a grammar error related to constructors in parenthetical expressions
2016-07-30 13:38:55 +00:00
if (constructorFunction == nullptr) {
expected("type that can be constructed");
return false;
}
TIntermTyped* arguments = nullptr;
parseContext.handleFunctionArgument(constructorFunction, arguments, node);
node = parseContext.handleFunctionCall(loc, constructorFunction, arguments);
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
HLSL: Validate implicit initializer assignment to opaque members. Fixes #1091.
2017-10-07 19:23:09 +00:00
return node != nullptr;
HLSL: Fix a grammar error related to constructors in parenthetical expressions
2016-07-30 13:38:55 +00:00
} else {
// This could be a parenthesized constructor, ala (int(3)), and we just accepted
// the '(int' part. We must back up twice.
recedeToken();
recedeToken();
HLSL: Fix #924: Convert between two different arrays with cast.
2017-06-14 05:13:10 +00:00
// Note, there are no array constructors like
// (float[2](...))
if (arraySizes != nullptr)
parseContext.error(loc, "parenthesized array constructor not allowed", "([]())", "", "");
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
}
} else {
// This isn't a type cast, but it still started "(", so if it is a
// unary expression, it can only be a postfix_expression, so try that.
// Back it up first.
recedeToken();
return acceptPostfixExpression(node);
}
}
// peek for "op unary_expression"
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
TOperator unaryOp = HlslOpMap::preUnary(peek());
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: 1) Implement lookahead buffers/stacks for token advance/recede, 2) use it for cast operation. The grammar now accepts type casts, like "(int)x", but that has to be disambiguated from "(a + b)", needed deeper lookahead and backing up than what existed so far.
2016-06-03 22:55:49 +00:00
// postfix_expression (if no unary operator)
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
if (unaryOp == EOpNull)
return acceptPostfixExpression(node);
// op unary_expression
TSourceLoc loc = token.loc;
advanceToken();
if (! acceptUnaryExpression(node))
return false;
// + is a no-op
if (unaryOp == EOpAdd)
return true;
node = intermediate.addUnaryMath(unaryOp, node, loc);
HLSL: Fix unary and binary operator type conversion issues This fixes defects as follows: 1. handleLvalue could be called on a non-L-value, and it shouldn't be. 2. HLSL allows unary negation on non-bool values. TUnaryOperator::promote can now promote other types (e.g, int, float) to bool for this op. 3. HLSL allows binary logical operations (&&, ||) on arbitrary types, similar (2). 4. HLSL allows mod operation on arbitrary types, which will be promoted. E.g, int % float -> float % float.
2016-10-15 16:29:58 +00:00
// These unary ops require lvalues
if (unaryOp == EOpPreIncrement || unaryOp == EOpPreDecrement)
node = parseContext.handleLvalue(loc, "unary operator", node);
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
return node != nullptr;
}
// postfix_expression
// : LEFT_PAREN expression RIGHT_PAREN
// | literal
// | constructor
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// | IDENTIFIER [ COLONCOLON IDENTIFIER [ COLONCOLON IDENTIFIER ... ] ]
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// | function_call
// | postfix_expression LEFT_BRACKET integer_expression RIGHT_BRACKET
// | postfix_expression DOT IDENTIFIER
HLSL: Non-functional: Drive existing method recognition by syntax, not by name. This (and previous commit) is a better foundation to build real methods on.
2017-03-09 03:09:03 +00:00
// | postfix_expression DOT IDENTIFIER arguments
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// | postfix_expression arguments
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// | postfix_expression INC_OP
// | postfix_expression DEC_OP
//
bool HlslGrammar::acceptPostfixExpression(TIntermTyped*& node)
{
// Not implemented as self-recursive:
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// The logical "right recursion" is done with a loop at the end
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// idToken will pick up either a variable or a function name in a function call
HlslToken idToken;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// Find something before the postfix operations, as they can't operate
// on nothing. So, no "return true", they fall through, only "return false".
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
if (acceptTokenClass(EHTokLeftParen)) {
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// LEFT_PAREN expression RIGHT_PAREN
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
if (! acceptExpression(node)) {
expected("expression");
return false;
}
if (! acceptTokenClass(EHTokRightParen)) {
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
expected(")");
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return false;
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
} else if (acceptLiteral(node)) {
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// literal (nothing else to do yet)
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
} else if (acceptConstructor(node)) {
// constructor (nothing else to do yet)
} else if (acceptIdentifier(idToken)) {
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
// user-type, namespace name, variable, or function name
TString* fullName = idToken.string;
while (acceptTokenClass(EHTokColonColon)) {
// user-type or namespace name
fullName = NewPoolTString(fullName->c_str());
fullName->append(parseContext.scopeMangler);
if (acceptIdentifier(idToken))
fullName->append(*idToken.string);
else {
expected("identifier after ::");
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
return false;
}
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
}
if (! peekTokenClass(EHTokLeftParen)) {
node = parseContext.handleVariable(idToken.loc, fullName);
HLSL: Fix #1215: propagate error on seeing a type name instead of a variable.
2018-01-10 04:35:44 +00:00
if (node == nullptr)
return false;
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
} else if (acceptFunctionCall(idToken.loc, *fullName, node, nullptr)) {
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// function_call (nothing else to do yet)
} else {
expected("function call arguments");
return false;
}
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
} else {
// nothing found, can't post operate
return false;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
}
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// Something was found, chain as many postfix operations as exist.
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
do {
TSourceLoc loc = token.loc;
TOperator postOp = HlslOpMap::postUnary(peek());
// Consume only a valid post-unary operator, otherwise we are done.
switch (postOp) {
case EOpIndexDirectStruct:
case EOpIndexIndirect:
case EOpPostIncrement:
case EOpPostDecrement:
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
case EOpScoping:
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
advanceToken();
break;
default:
return true;
}
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// We have a valid post-unary operator, process it.
switch (postOp) {
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
case EOpScoping:
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
case EOpIndexDirectStruct:
HLSL: Handle "." for structure dereference and swizzle.
2016-06-17 23:16:27 +00:00
{
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// DOT IDENTIFIER
HLSL: Non-functional: Drive existing method recognition by syntax, not by name. This (and previous commit) is a better foundation to build real methods on.
2017-03-09 03:09:03 +00:00
// includes swizzles, member variables, and member functions
HLSL: Handle "." for structure dereference and swizzle.
2016-06-17 23:16:27 +00:00
HlslToken field;
if (! acceptIdentifier(field)) {
expected("swizzle or member");
return false;
}
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Non-functional: Drive existing method recognition by syntax, not by name. This (and previous commit) is a better foundation to build real methods on.
2017-03-09 03:09:03 +00:00
if (peekTokenClass(EHTokLeftParen)) {
// member function
TIntermTyped* thisNode = node;
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Non-functional: Drive existing method recognition by syntax, not by name. This (and previous commit) is a better foundation to build real methods on.
2017-03-09 03:09:03 +00:00
// arguments
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
if (! acceptFunctionCall(field.loc, *field.string, node, thisNode)) {
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
expected("function parameters");
return false;
}
HLSL: Non-functional: Drive existing method recognition by syntax, not by name. This (and previous commit) is a better foundation to build real methods on.
2017-03-09 03:09:03 +00:00
} else
node = parseContext.handleDotDereference(field.loc, node, *field.string);
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
break;
HLSL: Handle "." for structure dereference and swizzle.
2016-06-17 23:16:27 +00:00
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
case EOpIndexIndirect:
{
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// LEFT_BRACKET integer_expression RIGHT_BRACKET
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
TIntermTyped* indexNode = nullptr;
if (! acceptExpression(indexNode) ||
! peekTokenClass(EHTokRightBracket)) {
expected("expression followed by ']'");
return false;
}
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
advanceToken();
node = parseContext.handleBracketDereference(indexNode->getLoc(), node, indexNode);
HLSL: cast bracket dereference index to int type if not. HLSL can index arrays using operator[] with non-integer types, and inserts a conversion to a uint if needed.
2017-04-07 02:22:20 +00:00
if (node == nullptr)
return false;
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
break;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
}
case EOpPostIncrement:
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// INC_OP
// fall through
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
case EOpPostDecrement:
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// DEC_OP
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
node = intermediate.addUnaryMath(postOp, node, loc);
HLSL: phase 2d: minor cleanup, & allow operator[] on non-rw textures Improve comments. A few tweaked lines allow [] on non-rw tx. Add test case for this. Improve VectorTimesScalar handling.
2016-10-10 16:00:14 +00:00
node = parseContext.handleLvalue(loc, "unary operator", node);
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
break;
default:
assert(0);
break;
}
} while (true);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
}
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
// constructor
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// : type argument_list
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
//
bool HlslGrammar::acceptConstructor(TIntermTyped*& node)
{
// type
TType type;
if (acceptType(type)) {
HLSL: Non-functional: rationalize making constructors. Improves foundation for adding scalar casts. Makes handle/make names more sane, better commented, uses more precise subclass typing, and removes mutual recursion between converting initializer lists and making constructors.
2017-04-04 03:48:37 +00:00
TFunction* constructorFunction = parseContext.makeConstructorCall(token.loc, type);
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
if (constructorFunction == nullptr)
return false;
// arguments
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
TIntermTyped* arguments = nullptr;
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
if (! acceptArguments(constructorFunction, arguments)) {
HLSL: allow scalar type keywords as identifiers, and add half type support. HLSL allows type keywords to also be identifiers, so a sequence such as "float half = 3" is valid, or more bizzarely, something like "float.float = int.uint + bool;" There are places this is not supported. E.g, it's permitted for struct members, but not struct names or functions. Also, vector or matrix types such as "float3" are not permitted as identifiers. This PR adds that support, as well as support for the "half" type. In production shaders, this was seen with variables named "half". The PR attempts to support this without breaking useful grammar errors such as "; expected" at the end of unterminated statements, so it errs on that side at the possible expense of failing to accept valid constructs containing a type keyword identifier. If others are discovered, they can be added. Also, half is now accepted as a valid type, alongside the min*float types.
2016-12-27 01:45:52 +00:00
// It's possible this is a type keyword used as an identifier. Put the token back
// for later use.
recedeToken();
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
return false;
}
// hook it up
node = parseContext.handleFunctionCall(arguments->getLoc(), constructorFunction, arguments);
HLSL: Validate implicit initializer assignment to opaque members. Fixes #1091.
2017-10-07 19:23:09 +00:00
return node != nullptr;
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
}
return false;
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// The function_call identifier was already recognized, and passed in as idToken.
//
// function_call
// : [idToken] arguments
//
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
bool HlslGrammar::acceptFunctionCall(const TSourceLoc& loc, TString& name, TIntermTyped*& node, TIntermTyped* baseObject)
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
{
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// name
TString* functionName = nullptr;
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
if (baseObject == nullptr) {
functionName = &name;
} else if (parseContext.isBuiltInMethod(loc, baseObject, name)) {
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
// Built-in methods are not in the symbol table as methods, but as global functions
// taking an explicit 'this' as the first argument.
HLSL: use prefix for builtin functions names to avoid namespace collisions It would have been possible for globally scoped user functions to collide with builtin method names. This adds a prefix to avoid polluting the namespace. Ideally this would be an invalid character to use in user identifiers, but as that requires changing the scanner, for the moment it's an unlikely yet valid prefix.
2017-03-20 00:12:37 +00:00
functionName = NewPoolTString(BUILTIN_PREFIX);
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
functionName->append(name);
HLSL: Basic turn on of non-static member functions. Still need: pass by reference in SPIR-V and symbol-table level for accessing 'this' members from member functions.
2017-03-20 00:09:59 +00:00
} else {
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
if (! baseObject->getType().isStruct()) {
expected("structure");
return false;
}
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
functionName = NewPoolTString("");
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
functionName->append(baseObject->getType().getTypeName());
HLSL non-functional: Generalize namespace nesting. Also use this to move deferred member-function-body parsing to a better place. This should also be well poised for implementing the 'namespace' keyword.
2017-03-19 18:24:29 +00:00
parseContext.addScopeMangler(*functionName);
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
functionName->append(name);
HLSL: non-functional: simplify handleBuiltInMethod() to isBuiltInMethod().
2017-03-11 16:39:55 +00:00
}
HLSL: Sampler/texture declarations, method syntax, partial Sample method
2016-06-29 16:58:58 +00:00
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// function
TFunction* function = new TFunction(functionName, TType(EbtVoid));
// arguments
TIntermTyped* arguments = nullptr;
HLSL: Add implicit-this tracking to TFunction.
2017-03-19 19:10:28 +00:00
if (baseObject != nullptr) {
// Non-static member functions have an implicit first argument of the base object.
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
parseContext.handleFunctionArgument(function, arguments, baseObject);
HLSL: Add implicit-this tracking to TFunction.
2017-03-19 19:10:28 +00:00
}
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
if (! acceptArguments(function, arguments))
return false;
HLSL: Add scoping operator, accept static member functions, and support calling them.
2017-03-11 21:13:00 +00:00
// call
HLSL: Add namespace grammar and some basic semantics. Unknown how extensive the semantics need to be yet. Need real feedback from workloads. This is just done as part of unifying it with the class/struct namespaces and grammar productions.
2017-03-30 22:22:26 +00:00
node = parseContext.handleFunctionCall(loc, function, arguments);
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
HLSL: Validate implicit initializer assignment to opaque members. Fixes #1091.
2017-10-07 19:23:09 +00:00
return node != nullptr;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
}
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
// arguments
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// : LEFT_PAREN expression COMMA expression COMMA ... RIGHT_PAREN
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
//
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
// The arguments are pushed onto the 'function' argument list and
// onto the 'arguments' aggregate.
//
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
bool HlslGrammar::acceptArguments(TFunction* function, TIntermTyped*& arguments)
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
{
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// LEFT_PAREN
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
if (! acceptTokenClass(EHTokLeftParen))
return false;
HLSL: Address #839: avoid crash by distinguishing between bad argument and no argument.
2017-04-18 20:47:33 +00:00
// RIGHT_PAREN
if (acceptTokenClass(EHTokRightParen))
return true;
// must now be at least one expression...
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
do {
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
// expression
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
TIntermTyped* arg;
HLSL: Add function call syntax and AST building.
2016-05-13 15:33:42 +00:00
if (! acceptAssignmentExpression(arg))
HLSL: Address #839: avoid crash by distinguishing between bad argument and no argument.
2017-04-18 20:47:33 +00:00
return false;
HLSL: Hook up constructor expressions through the AST.
2016-03-13 17:24:20 +00:00
// hook it up
parseContext.handleFunctionArgument(function, arguments, arg);
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// COMMA
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
if (! acceptTokenClass(EHTokComma))
break;
} while (true);
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
// RIGHT_PAREN
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
if (! acceptTokenClass(EHTokRightParen)) {
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
expected(")");
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
return false;
}
return true;
}
bool HlslGrammar::acceptLiteral(TIntermTyped*& node)
{
switch (token.tokenClass) {
case EHTokIntConstant:
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
node = intermediate.addConstantUnion(token.i, token.loc, true);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
HLSL: allow uint literals, and add test for numeric suffixes
2016-07-28 20:49:48 +00:00
case EHTokUintConstant:
node = intermediate.addConstantUnion(token.u, token.loc, true);
break;
HLSL: Correct some mistakes for min16 types - Add missing constructor ops to support float16/int16/uint16 types - Allow half float literals - Correct two errors of double literal parse in HLSL: extension check and postfix
2018-03-12 15:15:11 +00:00
case EHTokFloat16Constant:
node = intermediate.addConstantUnion(token.d, EbtFloat16, token.loc, true);
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
case EHTokFloatConstant:
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
node = intermediate.addConstantUnion(token.d, EbtFloat, token.loc, true);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokDoubleConstant:
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
node = intermediate.addConstantUnion(token.d, EbtDouble, token.loc, true);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
case EHTokBoolConstant:
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
node = intermediate.addConstantUnion(token.b, token.loc, true);
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
break;
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
case EHTokStringConstant:
Add basic HS/DS implementation. This obsoletes WIP PR #704, which was built on the pre entry point wrapping master. New version here uses entry point wrapping. This is a limited implementation of tessellation shaders. In particular, the following are not functional, and will be added as separate stages to reduce the size of each PR. * patchconstantfunctions accepting per-control-point input values, such as const OutputPatch <hs_out_t, 3> cpv are not implemented. * patchconstantfunctions whose signature requires an aggregate input type such as a structure containing builtin variables. Code to synthesize such calls is not yet present. These restrictions will be relaxed as soon as possible. Simple cases can compile now: see for example Test/hulsl.hull.1.tesc - e.g, writing to inner and outer tessellation factors. PCF invocation is synthesized as an entry point epilogue protected behind a barrier and a test on invocation ID == 0. If there is an existing invocation ID variable it will be used, otherwise one is added to the linkage. The PCF and the shader EP interfaces are unioned and builtins appearing in the PCF but not the EP are also added to the linkage and synthesized as shader inputs. Parameter matching to (eventually arbitrary) PCF signatures is by builtin variable type. Any user variables in the PCF signature will result in an error. Overloaded PCF functions will also result in an error. [domain()], [partitioning()], [outputtopology()], [outputcontrolpoints()], and [patchconstantfunction()] attributes to the shader entry point are in place, with the exception of the Pow2 partitioning mode.
2017-01-07 15:54:10 +00:00
node = intermediate.addConstantUnion(token.string, token.loc, true);
HLSL: Add string basic type and recognize string declaration grammar. This includes the "< decl ; decl ; >" syntax which has its own namespace. This functionality is not implemented, just silently accepted.
2016-09-20 02:23:18 +00:00
break;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
default:
return false;
}
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
advanceToken();
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
return true;
}
HLSL: Fix #919: for-init-statement is arbitrary declaration or expression. Unlike "if (XXX)" and "while (XXX)", with "for (YYY...", the YYY can be more kinds of statements than the XXX.
2017-06-06 17:37:33 +00:00
// simple_statement
// : SEMICOLON
// | declaration_statement
// | expression SEMICOLON
//
bool HlslGrammar::acceptSimpleStatement(TIntermNode*& statement)
{
// SEMICOLON
if (acceptTokenClass(EHTokSemicolon))
return true;
// declaration
if (acceptDeclaration(statement))
return true;
// expression
TIntermTyped* node;
if (acceptExpression(node))
statement = node;
else
return false;
// SEMICOLON (following an expression)
if (acceptTokenClass(EHTokSemicolon))
return true;
else {
expected(";");
return false;
}
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// compound_statement
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// : LEFT_CURLY statement statement ... RIGHT_CURLY
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
//
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
bool HlslGrammar::acceptCompoundStatement(TIntermNode*& retStatement)
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
{
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
TIntermAggregate* compoundStatement = nullptr;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// LEFT_CURLY
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
if (! acceptTokenClass(EHTokLeftBrace))
return false;
// statement statement ...
TIntermNode* statement = nullptr;
while (acceptStatement(statement)) {
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
TIntermBranch* branch = statement ? statement->getAsBranchNode() : nullptr;
if (branch != nullptr && (branch->getFlowOp() == EOpCase ||
branch->getFlowOp() == EOpDefault)) {
// hook up individual subsequences within a switch statement
parseContext.wrapupSwitchSubsequence(compoundStatement, statement);
compoundStatement = nullptr;
} else {
// hook it up to the growing compound statement
compoundStatement = intermediate.growAggregate(compoundStatement, statement);
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
}
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
if (compoundStatement)
compoundStatement->setOperator(EOpSequence);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
retStatement = compoundStatement;
HLSL: Add (almost) full expression grammar: Binary, unary (pre/post-fix), assign, ...
2016-05-04 05:17:20 +00:00
// RIGHT_CURLY
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
return acceptTokenClass(EHTokRightBrace);
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
bool HlslGrammar::acceptScopedStatement(TIntermNode*& statement)
{
parseContext.pushScope();
HLSL: Implement proper nesting of symbol-table scopes and identifier searching.
2016-06-09 08:02:17 +00:00
bool result = acceptStatement(statement);
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
parseContext.popScope();
return result;
}
HLSL: Implement proper nesting of symbol-table scopes and identifier searching.
2016-06-09 08:02:17 +00:00
bool HlslGrammar::acceptScopedCompoundStatement(TIntermNode*& statement)
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
{
HLSL: Implement proper nesting of symbol-table scopes and identifier searching.
2016-06-09 08:02:17 +00:00
parseContext.pushScope();
bool result = acceptCompoundStatement(statement);
parseContext.popScope();
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
return result;
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// statement
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// : attributes attributed_statement
//
// attributed_statement
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
// : compound_statement
HLSL: Fix #919: for-init-statement is arbitrary declaration or expression. Unlike "if (XXX)" and "while (XXX)", with "for (YYY...", the YYY can be more kinds of statements than the XXX.
2017-06-06 17:37:33 +00:00
// | simple_statement
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// | selection_statement
// | switch_statement
// | case_label
HLSL: Fix #919: for-init-statement is arbitrary declaration or expression. Unlike "if (XXX)" and "while (XXX)", with "for (YYY...", the YYY can be more kinds of statements than the XXX.
2017-06-06 17:37:33 +00:00
// | default_label
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// | iteration_statement
// | jump_statement
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
//
bool HlslGrammar::acceptStatement(TIntermNode*& statement)
{
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
statement = nullptr;
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// attributes
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
TAttributes attributes;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
acceptAttributes(attributes);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// attributed_statement
switch (peek()) {
case EHTokLeftBrace:
HLSL: Implement proper nesting of symbol-table scopes and identifier searching.
2016-06-09 08:02:17 +00:00
return acceptScopedCompoundStatement(statement);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
case EHTokIf:
HLSL: Translate directive [flatten] and [branch] to SPV control mask.
2017-07-04 15:23:40 +00:00
return acceptSelectionStatement(statement, attributes);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
case EHTokSwitch:
HLSL: Translate directive [flatten] and [branch] to SPV control mask.
2017-07-04 15:23:40 +00:00
return acceptSwitchStatement(statement, attributes);
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
case EHTokFor:
case EHTokDo:
case EHTokWhile:
HLSL: implement [unroll] and [loop] attributes This adds infrastructure suitable for any front end to create SPIR-V loop control flags. The only current front end doing so is HLSL. [unroll] turns into spv::LoopControlUnrollMask [loop] turns into spv::LoopControlDontUnrollMask no specification means spv::LoopControlMaskNone
2017-05-03 02:14:50 +00:00
return acceptIterationStatement(statement, attributes);
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
case EHTokContinue:
case EHTokBreak:
case EHTokDiscard:
case EHTokReturn:
return acceptJumpStatement(statement);
case EHTokCase:
return acceptCaseLabel(statement);
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
case EHTokDefault:
return acceptDefaultLabel(statement);
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
case EHTokRightBrace:
// Performance: not strictly necessary, but stops a bunch of hunting early,
// and is how sequences of statements end.
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
return false;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
default:
HLSL: Fix #919: for-init-statement is arbitrary declaration or expression. Unlike "if (XXX)" and "while (XXX)", with "for (YYY...", the YYY can be more kinds of statements than the XXX.
2017-06-06 17:37:33 +00:00
return acceptSimpleStatement(statement);
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
}
HLSL: Accept basic funtion definitions. (Not yet mapping input/output for entry point.)
2016-03-13 23:58:25 +00:00
return true;
HLSL: Add basic declaration syntax and AST generation.
2016-03-13 03:24:24 +00:00
}
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
// attributes
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
// : [zero or more:] bracketed-attribute
//
// bracketed-attribute:
// : LEFT_BRACKET scoped-attribute RIGHT_BRACKET
// : LEFT_BRACKET LEFT_BRACKET scoped-attribute RIGHT_BRACKET RIGHT_BRACKET
//
// scoped-attribute:
// : attribute
// | namespace COLON COLON attribute
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
//
// attribute:
// : UNROLL
// | UNROLL LEFT_PAREN literal RIGHT_PAREN
// | FASTOPT
// | ALLOW_UAV_CONDITION
// | BRANCH
// | FLATTEN
// | FORCECASE
// | CALL
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
// | DOMAIN
// | EARLYDEPTHSTENCIL
// | INSTANCE
// | MAXTESSFACTOR
// | OUTPUTCONTROLPOINTS
// | OUTPUTTOPOLOGY
// | PARTITIONING
// | PATCHCONSTANTFUNC
// | NUMTHREADS LEFT_PAREN x_size, y_size,z z_size RIGHT_PAREN
//
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
void HlslGrammar::acceptAttributes(TAttributes& attributes)
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
{
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
// For now, accept the [ XXX(X) ] syntax, but drop all but
// numthreads, which is used to set the CS local size.
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// TODO: subset to correct set? Pass on?
do {
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
HlslToken attributeToken;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// LEFT_BRACKET?
if (! acceptTokenClass(EHTokLeftBracket))
return;
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
// another LEFT_BRACKET?
bool doubleBrackets = false;
if (acceptTokenClass(EHTokLeftBracket))
doubleBrackets = true;
// attribute? (could be namespace; will adjust later)
if (!acceptIdentifier(attributeToken)) {
if (!peekTokenClass(EHTokRightBracket)) {
expected("namespace or attribute identifier");
advanceToken();
}
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
TString nameSpace;
if (acceptTokenClass(EHTokColonColon)) {
// namespace COLON COLON
nameSpace = *attributeToken.string;
// attribute
if (!acceptIdentifier(attributeToken)) {
expected("attribute identifier");
return;
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
}
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
TIntermAggregate* expressions = nullptr;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
// (x, ...)
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
if (acceptTokenClass(EHTokLeftParen)) {
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
expressions = new TIntermAggregate;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
TIntermTyped* node;
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
bool expectingExpression = false;
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
while (acceptAssignmentExpression(node)) {
expectingExpression = false;
expressions->getSequence().push_back(node);
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
if (acceptTokenClass(EHTokComma))
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
expectingExpression = true;
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
}
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
// 'expressions' is an aggregate with the expressions in it
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
if (! acceptTokenClass(EHTokRightParen))
expected(")");
HLSL: Allow expressions in attributes For example: [numthreads(2+2, 2*3, (1+FOO)*BAR)] This will result in a thread count (4, 6, 8).
2016-11-11 15:17:44 +00:00
// Error for partial or missing expression
if (expectingExpression || expressions->getSequence().empty())
expected("expression");
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
}
// RIGHT_BRACKET
HLSL: implement numthreads for compute shaders This PR adds handling of the numthreads attribute for compute shaders, as well as a general infrastructure for returning attribute values from acceptAttributes, which may be needed in other cases, e.g, unroll(x), or merely to know if some attribute without params was given. A map of enum values from TAttributeType to TIntermAggregate nodes is built and returned. It can be queried with operator[] on the map. In the future there may be a need to also handle strings (e.g, for patchconstantfunc), and those can be easily added into the class if needed. New test is in hlsl.numthreads.comp.
2016-10-20 19:07:10 +00:00
if (!acceptTokenClass(EHTokRightBracket)) {
expected("]");
return;
}
HLSL: Additional attribute support: [[]], namespace, parameters: - support C++11 style brackets [[...]] - support namespaces [[vk::...]] - support these on parameter declarations in functions - support location, binding/set, input attachments
2017-09-30 20:34:50 +00:00
// another RIGHT_BRACKET?
if (doubleBrackets && !acceptTokenClass(EHTokRightBracket)) {
expected("]]");
return;
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
// Add any values we found into the attribute map.
if (attributeToken.string != nullptr) {
TAttributeType attributeType = parseContext.attributeFromName(nameSpace, *attributeToken.string);
if (attributeType == EatNone)
parseContext.warn(attributeToken.loc, "unrecognized attribute", attributeToken.string->c_str(), "");
else {
TAttributeArgs attributeArgs = { attributeType, expressions };
attributes.push_back(attributeArgs);
}
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
} while (true);
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
}
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// selection_statement
// : IF LEFT_PAREN expression RIGHT_PAREN statement
// : IF LEFT_PAREN expression RIGHT_PAREN statement ELSE statement
//
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
bool HlslGrammar::acceptSelectionStatement(TIntermNode*& statement, const TAttributes& attributes)
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
{
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
TSourceLoc loc = token.loc;
// IF
if (! acceptTokenClass(EHTokIf))
return false;
// so that something declared in the condition is scoped to the lifetimes
// of the then-else statements
parseContext.pushScope();
// LEFT_PAREN expression RIGHT_PAREN
TIntermTyped* condition;
if (! acceptParenExpression(condition))
return false;
HLSL: Implicit bool conversions for conditional expressions and related. Covers if(cond), while(cond), do-while(cond), for(;cond;), and (cond ? :). Fixes #778.
2017-03-31 04:09:30 +00:00
condition = parseContext.convertConditionalExpression(loc, condition);
if (condition == nullptr)
return false;
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// create the child statements
TIntermNodePair thenElse = { nullptr, nullptr };
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
++parseContext.controlFlowNestingLevel; // this only needs to work right if no errors
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
// then statement
if (! acceptScopedStatement(thenElse.node1)) {
expected("then statement");
return false;
}
// ELSE
if (acceptTokenClass(EHTokElse)) {
// else statement
if (! acceptScopedStatement(thenElse.node2)) {
expected("else statement");
return false;
}
}
// Put the pieces together
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
statement = intermediate.addSelection(condition, thenElse, loc);
parseContext.handleSelectionAttributes(loc, statement->getAsSelectionNode(), attributes);
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
parseContext.popScope();
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
--parseContext.controlFlowNestingLevel;
HLSL: Attribute grammar and if-else grammar/productions.
2016-06-05 17:23:11 +00:00
return true;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
}
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
// switch_statement
// : SWITCH LEFT_PAREN expression RIGHT_PAREN compound_statement
//
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
bool HlslGrammar::acceptSwitchStatement(TIntermNode*& statement, const TAttributes& attributes)
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
{
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
// SWITCH
TSourceLoc loc = token.loc;
HLSL: Translate directive [flatten] and [branch] to SPV control mask.
2017-07-04 15:23:40 +00:00
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
if (! acceptTokenClass(EHTokSwitch))
return false;
// LEFT_PAREN expression RIGHT_PAREN
parseContext.pushScope();
TIntermTyped* switchExpression;
if (! acceptParenExpression(switchExpression)) {
parseContext.popScope();
return false;
}
// compound_statement
parseContext.pushSwitchSequence(new TIntermSequence);
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
++parseContext.controlFlowNestingLevel;
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
bool statementOkay = acceptCompoundStatement(statement);
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
--parseContext.controlFlowNestingLevel;
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
if (statementOkay)
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
statement = parseContext.addSwitch(loc, switchExpression, statement ? statement->getAsAggregate() : nullptr,
attributes);
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
parseContext.popSwitchSequence();
parseContext.popScope();
return statementOkay;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
}
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
// iteration_statement
// : WHILE LEFT_PAREN condition RIGHT_PAREN statement
// | DO LEFT_BRACE statement RIGHT_BRACE WHILE LEFT_PAREN expression RIGHT_PAREN SEMICOLON
// | FOR LEFT_PAREN for_init_statement for_rest_statement RIGHT_PAREN statement
//
// Non-speculative, only call if it needs to be found; WHILE or DO or FOR already seen.
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
bool HlslGrammar::acceptIterationStatement(TIntermNode*& statement, const TAttributes& attributes)
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
{
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
TSourceLoc loc = token.loc;
TIntermTyped* condition = nullptr;
EHlslTokenClass loop = peek();
assert(loop == EHTokDo || loop == EHTokFor || loop == EHTokWhile);
// WHILE or DO or FOR
advanceToken();
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
TIntermLoop* loopNode = nullptr;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
switch (loop) {
case EHTokWhile:
// so that something declared in the condition is scoped to the lifetime
// of the while sub-statement
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
parseContext.pushScope(); // this only needs to work right if no errors
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
parseContext.nestLooping();
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
++parseContext.controlFlowNestingLevel;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
// LEFT_PAREN condition RIGHT_PAREN
if (! acceptParenExpression(condition))
return false;
HLSL: Implicit bool conversions for conditional expressions and related. Covers if(cond), while(cond), do-while(cond), for(;cond;), and (cond ? :). Fixes #778.
2017-03-31 04:09:30 +00:00
condition = parseContext.convertConditionalExpression(loc, condition);
if (condition == nullptr)
return false;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
// statement
if (! acceptScopedStatement(statement)) {
expected("while sub-statement");
return false;
}
parseContext.unnestLooping();
parseContext.popScope();
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
--parseContext.controlFlowNestingLevel;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
loopNode = intermediate.addLoop(statement, condition, nullptr, true, loc);
statement = loopNode;
break;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
case EHTokDo:
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
parseContext.nestLooping(); // this only needs to work right if no errors
++parseContext.controlFlowNestingLevel;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
// statement
HLSL: Fix #96: Support do-while loop substatements with no curly braces.
2017-04-20 17:08:24 +00:00
if (! acceptScopedStatement(statement)) {
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
expected("do sub-statement");
return false;
}
// WHILE
if (! acceptTokenClass(EHTokWhile)) {
expected("while");
return false;
}
// LEFT_PAREN condition RIGHT_PAREN
if (! acceptParenExpression(condition))
return false;
HLSL: Implicit bool conversions for conditional expressions and related. Covers if(cond), while(cond), do-while(cond), for(;cond;), and (cond ? :). Fixes #778.
2017-03-31 04:09:30 +00:00
condition = parseContext.convertConditionalExpression(loc, condition);
if (condition == nullptr)
return false;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
if (! acceptTokenClass(EHTokSemicolon))
expected(";");
parseContext.unnestLooping();
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
--parseContext.controlFlowNestingLevel;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
loopNode = intermediate.addLoop(statement, condition, 0, false, loc);
statement = loopNode;
break;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
case EHTokFor:
{
// LEFT_PAREN
if (! acceptTokenClass(EHTokLeftParen))
expected("(");
// so that something declared in the condition is scoped to the lifetime
// of the for sub-statement
parseContext.pushScope();
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
// initializer
TIntermNode* initNode = nullptr;
HLSL: Fix #919: for-init-statement is arbitrary declaration or expression. Unlike "if (XXX)" and "while (XXX)", with "for (YYY...", the YYY can be more kinds of statements than the XXX.
2017-06-06 17:37:33 +00:00
if (! acceptSimpleStatement(initNode))
expected("for-loop initializer statement");
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
parseContext.nestLooping(); // this only needs to work right if no errors
++parseContext.controlFlowNestingLevel;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
// condition SEMI_COLON
acceptExpression(condition);
if (! acceptTokenClass(EHTokSemicolon))
expected(";");
HLSL: Implicit bool conversions for conditional expressions and related. Covers if(cond), while(cond), do-while(cond), for(;cond;), and (cond ? :). Fixes #778.
2017-03-31 04:09:30 +00:00
if (condition != nullptr) {
condition = parseContext.convertConditionalExpression(loc, condition);
if (condition == nullptr)
return false;
}
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
// iterator SEMI_COLON
TIntermTyped* iterator = nullptr;
acceptExpression(iterator);
if (! acceptTokenClass(EHTokRightParen))
expected(")");
// statement
if (! acceptScopedStatement(statement)) {
expected("for sub-statement");
return false;
}
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
statement = intermediate.addForLoop(statement, initNode, condition, iterator, true, loc, loopNode);
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
parseContext.popScope();
parseContext.unnestLooping();
HLSL: Track control-flow nesting and warn on aliasing under it.
2017-06-07 01:52:55 +00:00
--parseContext.controlFlowNestingLevel;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
break;
HLSL: Flesh out the loop grammar and productions.
2016-06-05 21:44:07 +00:00
}
default:
return false;
}
HLSL: Refactor attribute implementation. - make it sharable with GLSL - correct the case insensitivity - remove the map; queries are not needed, all entries need processing - make it easier to build bottom up (will help GLSL parsing) - support semantic checking and reporting - allow front-end dependent semantics and attribute name mapping
2018-01-30 18:01:39 +00:00
parseContext.handleLoopAttributes(loc, loopNode, attributes);
return true;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
}
// jump_statement
// : CONTINUE SEMICOLON
// | BREAK SEMICOLON
// | DISCARD SEMICOLON
// | RETURN SEMICOLON
// | RETURN expression SEMICOLON
//
bool HlslGrammar::acceptJumpStatement(TIntermNode*& statement)
{
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
EHlslTokenClass jump = peek();
switch (jump) {
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
case EHTokContinue:
case EHTokBreak:
case EHTokDiscard:
case EHTokReturn:
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
advanceToken();
break;
default:
// not something we handle in this function
return false;
}
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
switch (jump) {
case EHTokContinue:
statement = intermediate.addBranch(EOpContinue, token.loc);
HLSL: Protect against 'continue' outside of loops.
2018-01-10 10:50:42 +00:00
if (parseContext.loopNestingLevel == 0) {
expected("loop");
return false;
}
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
break;
case EHTokBreak:
statement = intermediate.addBranch(EOpBreak, token.loc);
HLSL: Fix #1214: check for nesting in loop/switch of break statements.
2018-01-10 05:32:42 +00:00
if (parseContext.loopNestingLevel == 0 && parseContext.switchSequenceStack.size() == 0) {
expected("loop or switch");
return false;
}
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
break;
case EHTokDiscard:
statement = intermediate.addBranch(EOpKill, token.loc);
break;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
case EHTokReturn:
{
// expression
TIntermTyped* node;
if (acceptExpression(node)) {
// hook it up
HLSL: add implicit promotions for assignments and function returns.
2016-08-09 17:28:03 +00:00
statement = parseContext.handleReturnValue(token.loc, node);
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
} else
statement = intermediate.addBranch(EOpReturn, token.loc);
break;
}
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
default:
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
assert(0);
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
return false;
}
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
// SEMICOLON
if (! acceptTokenClass(EHTokSemicolon))
expected(";");
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
2016-06-20 07:22:38 +00:00
return true;
}
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
// case_label
// : CASE expression COLON
//
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
bool HlslGrammar::acceptCaseLabel(TIntermNode*& statement)
{
HLSL: Implement switch/case/default.
2016-07-01 06:04:11 +00:00
TSourceLoc loc = token.loc;
if (! acceptTokenClass(EHTokCase))
return false;
TIntermTyped* expression;
if (! acceptExpression(expression)) {
expected("case expression");
return false;
}
if (! acceptTokenClass(EHTokColon)) {
expected(":");
return false;
}
statement = parseContext.intermediate.addBranch(EOpCase, expression, loc);
return true;
}
// default_label
// : DEFAULT COLON
//
bool HlslGrammar::acceptDefaultLabel(TIntermNode*& statement)
{
TSourceLoc loc = token.loc;
if (! acceptTokenClass(EHTokDefault))
return false;
if (! acceptTokenClass(EHTokColon)) {
expected(":");
return false;
}
statement = parseContext.intermediate.addBranch(EOpDefault, loc);
return true;
HLSL: Finish skeletan of the "statement" grammar.
2016-06-04 17:46:33 +00:00
}
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
// array_specifier
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
// : LEFT_BRACKET integer_expression RGHT_BRACKET ... // optional
// : LEFT_BRACKET RGHT_BRACKET // optional
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
//
void HlslGrammar::acceptArraySpecifier(TArraySizes*& arraySizes)
{
arraySizes = nullptr;
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
// Early-out if there aren't any array dimensions
if (!peekTokenClass(EHTokLeftBracket))
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
return;
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
// If we get here, we have at least one array dimension. This will track the sizes we find.
arraySizes = new TArraySizes;
HLSL: allow implicit array sizing. In HLSL array sizes need not be provided explicitly in all circumstances. For example, this is valid (note no number between the [ ]): // no explicit array size uniform float g_array[] = { 1, 2, 3, 4, 5 }; This PR does not attempt to validate most invalid cases. A new test is added to verify the resulting linker objects.
2016-09-27 16:57:35 +00:00
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
// Collect each array dimension.
while (acceptTokenClass(EHTokLeftBracket)) {
TSourceLoc loc = token.loc;
TIntermTyped* sizeExpr = nullptr;
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
HLSL: Fix #754: recognize type casts in if-statements separately from declarations.
2017-03-07 01:18:37 +00:00
// Array sizing expression is optional. If omitted, array will be later sized by initializer list.
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
const bool hasArraySize = acceptAssignmentExpression(sizeExpr);
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
HLSL: allow multi-dimensional arrays All the underpinnings are there; this just parses multiple array dimensions and passes them through to the existing mechanisms. Also, minor comment fixes, and add a new test for multi-dim arrays.
2016-10-13 18:26:18 +00:00
if (! acceptTokenClass(EHTokRightBracket)) {
expected("]");
return;
}
if (hasArraySize) {
TArraySize arraySize;
parseContext.arraySizeCheck(loc, sizeExpr, arraySize);
arraySizes->addInnerSize(arraySize);
} else {
arraySizes->addInnerSize(0); // sized by initializers.
}
HLSL: allow implicit array sizing. In HLSL array sizes need not be provided explicitly in all circumstances. For example, this is valid (note no number between the [ ]): // no explicit array size uniform float g_array[] = { 1, 2, 3, 4, 5 }; This PR does not attempt to validate most invalid cases. A new test is added to verify the resulting linker objects.
2016-09-27 16:57:35 +00:00
}
HLSL: Basic array grammar.
2016-06-19 17:50:34 +00:00
}
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
// post_decls
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
// : COLON semantic // optional
// COLON PACKOFFSET LEFT_PAREN c[Subcomponent][.component] RIGHT_PAREN // optional
// COLON REGISTER LEFT_PAREN [shader_profile,] Type#[subcomp]opt (COMMA SPACEN)opt RIGHT_PAREN // optional
HLSL: Accept layout(...) also as a post-decl. Issue #454.
2016-09-05 20:37:03 +00:00
// COLON LAYOUT layout_qualifier_list
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
// annotations // optional
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
//
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
// Return true if any tokens were accepted. That is,
// false can be returned on successfully recognizing nothing,
// not necessarily meaning bad syntax.
//
bool HlslGrammar::acceptPostDecls(TQualifier& qualifier)
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
{
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
bool found = false;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
do {
Non-Functional: Whitespace, comments, replace accidentally deleted comment. - fixed ParseHelper.cpp newlines (crlf -> lf) - removed trailing white space in most source files - fix some spelling issues - extra blank lines - tabs to spaces - replace #include comment about no location
2017-01-06 07:34:48 +00:00
// COLON
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
if (acceptTokenClass(EHTokColon)) {
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
found = true;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
HlslToken idToken;
HLSL: Accept layout(...) also as a post-decl. Issue #454.
2016-09-05 20:37:03 +00:00
if (peekTokenClass(EHTokLayout))
acceptLayoutQualifierList(qualifier);
else if (acceptTokenClass(EHTokPackOffset)) {
HLSL: Implement the register production.
2016-07-29 20:28:39 +00:00
// PACKOFFSET LEFT_PAREN c[Subcomponent][.component] RIGHT_PAREN
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
if (! acceptTokenClass(EHTokLeftParen)) {
expected("(");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
}
HLSL: Implement packoffset production.
2016-07-29 19:03:05 +00:00
HlslToken locationToken;
if (! acceptIdentifier(locationToken)) {
expected("c[subcomponent][.component]");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Implement packoffset production.
2016-07-29 19:03:05 +00:00
}
HlslToken componentToken;
if (acceptTokenClass(EHTokDot)) {
if (! acceptIdentifier(componentToken)) {
expected("component");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Implement packoffset production.
2016-07-29 19:03:05 +00:00
}
}
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
if (! acceptTokenClass(EHTokRightParen)) {
expected(")");
break;
}
HLSL Non-Functional: Move to more robust capturing of postDecls into a qualifier. This will prevent a possible future defect of thinking the type can be changed, where there is a code path today that would drop that change.
2016-09-05 18:40:06 +00:00
parseContext.handlePackOffset(locationToken.loc, qualifier, *locationToken.string, componentToken.string);
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
} else if (! acceptIdentifier(idToken)) {
HLSL: Accept layout(...) also as a post-decl. Issue #454.
2016-09-05 20:37:03 +00:00
expected("layout, semantic, packoffset, or register");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
} else if (*idToken.string == "register") {
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
// REGISTER LEFT_PAREN [shader_profile,] Type#[subcomp]opt (COMMA SPACEN)opt RIGHT_PAREN
// LEFT_PAREN
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
if (! acceptTokenClass(EHTokLeftParen)) {
expected("(");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
}
HLSL: Add back in the [subcomponent] part of a 'register' decl.
2016-07-30 16:29:54 +00:00
HlslToken registerDesc; // for Type#
HlslToken profile;
HLSL: Implement the register production.
2016-07-29 20:28:39 +00:00
if (! acceptIdentifier(registerDesc)) {
expected("register number description");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Implement the register production.
2016-07-29 20:28:39 +00:00
}
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
if (registerDesc.string->size() > 1 && !isdigit((*registerDesc.string)[1]) &&
acceptTokenClass(EHTokComma)) {
HLSL: Add back in the [subcomponent] part of a 'register' decl.
2016-07-30 16:29:54 +00:00
// Then we didn't really see the registerDesc yet, it was
// actually the profile. Adjust...
HLSL: Implement the register production.
2016-07-29 20:28:39 +00:00
profile = registerDesc;
if (! acceptIdentifier(registerDesc)) {
expected("register number description");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Implement the register production.
2016-07-29 20:28:39 +00:00
}
}
HLSL: Add back in the [subcomponent] part of a 'register' decl.
2016-07-30 16:29:54 +00:00
int subComponent = 0;
if (acceptTokenClass(EHTokLeftBracket)) {
// LEFT_BRACKET subcomponent RIGHT_BRACKET
if (! peekTokenClass(EHTokIntConstant)) {
expected("literal integer");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Add back in the [subcomponent] part of a 'register' decl.
2016-07-30 16:29:54 +00:00
}
subComponent = token.i;
advanceToken();
if (! acceptTokenClass(EHTokRightBracket)) {
expected("]");
break;
}
}
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
// (COMMA SPACEN)opt
HlslToken spaceDesc;
if (acceptTokenClass(EHTokComma)) {
if (! acceptIdentifier(spaceDesc)) {
expected ("space identifier");
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return false;
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
}
}
// RIGHT_PAREN
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
if (! acceptTokenClass(EHTokRightParen)) {
expected(")");
break;
}
HLSL: Support register(..., spaceN) for setting the descriptor set. This was suggested in issue #454.
2016-09-05 22:03:12 +00:00
parseContext.handleRegister(registerDesc.loc, qualifier, profile.string, *registerDesc.string, subComponent, spaceDesc.string);
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
} else {
// semantic, in idToken.string
Merge branch 'TiemoJung-semantic_handling'
2017-03-15 03:50:06 +00:00
TString semanticUpperCase = *idToken.string;
std::transform(semanticUpperCase.begin(), semanticUpperCase.end(), semanticUpperCase.begin(), ::toupper);
parseContext.handleSemantic(idToken.loc, qualifier, mapSemantic(semanticUpperCase.c_str()), semanticUpperCase);
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
}
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
} else if (peekTokenClass(EHTokLeftAngle)) {
found = true;
HLSL: Move to correct parsing of annotations, improving all annotations and recent string grammar.
2016-09-20 19:22:58 +00:00
acceptAnnotations(qualifier);
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
} else
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
break;
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
HLSL: Flesh out misc. declaration grammar: semantics/registers/annotations/precise/etc. Details within these bear even more fleshing out, but would like to have that driven by actual need.
2016-06-13 05:52:12 +00:00
} while (true);
HLSL: Fix #747: accept 'struct' in front of previously user-defined type name.
2017-03-02 21:30:59 +00:00
return found;
HLSL: Simplify appearances a bit to make easier to read.
2016-03-14 16:02:11 +00:00
}
HLSL: Member-functions: capture body token stream for deferred syntax/semantics. This is needed for accessing types/variables within a member function body that are not known until after the struct is finished being declared. However, that funtionality is not yet present, this is just the deferred processing, which is working for static member functions.
2017-03-12 02:32:47 +00:00
//
// Get the stream of tokens from the scanner, but skip all syntactic/semantic
// processing.
//
bool HlslGrammar::captureBlockTokens(TVector<HlslToken>& tokens)
{
if (! peekTokenClass(EHTokLeftBrace))
return false;
int braceCount = 0;
do {
switch (peek()) {
case EHTokLeftBrace:
++braceCount;
break;
case EHTokRightBrace:
--braceCount;
break;
case EHTokNone:
// End of input before balance { } is bad...
return false;
default:
break;
}
tokens.push_back(token);
advanceToken();
} while (braceCount > 0);
return true;
}
HLSL: Recognize types declared as identifiers as identifiers. E.g., in float float; (float) * float; The "(float)" is not a type cast, it is an expression.
2017-06-14 04:22:52 +00:00
// Return a string for just the types that can also be declared as an identifier.
const char* HlslGrammar::getTypeString(EHlslTokenClass tokenClass) const
{
switch (tokenClass) {
case EHTokSample: return "sample";
case EHTokHalf: return "half";
case EHTokHalf1x1: return "half1x1";
case EHTokHalf1x2: return "half1x2";
case EHTokHalf1x3: return "half1x3";
case EHTokHalf1x4: return "half1x4";
case EHTokHalf2x1: return "half2x1";
case EHTokHalf2x2: return "half2x2";
case EHTokHalf2x3: return "half2x3";
case EHTokHalf2x4: return "half2x4";
case EHTokHalf3x1: return "half3x1";
case EHTokHalf3x2: return "half3x2";
case EHTokHalf3x3: return "half3x3";
case EHTokHalf3x4: return "half3x4";
case EHTokHalf4x1: return "half4x1";
case EHTokHalf4x2: return "half4x2";
case EHTokHalf4x3: return "half4x3";
case EHTokHalf4x4: return "half4x4";
case EHTokBool: return "bool";
case EHTokFloat: return "float";
case EHTokDouble: return "double";
case EHTokInt: return "int";
case EHTokUint: return "uint";
case EHTokMin16float: return "min16float";
case EHTokMin10float: return "min10float";
case EHTokMin16int: return "min16int";
case EHTokMin12int: return "min12int";
HLSL: allow keyword-identifiers as cbuffer/struct names. Issue #791 was partially fixed by PR #1161 (the mat mul implicit truncations were its main point), but it still wouldn't compile due to the use of ConstantBuffer as an identifier. Apparently those fall into the same class as "float float", where float is both a type and an identifier. This allows struct definitions with such keyword-identifiers, and adds ConstantBuffer to the set. 'cbuffer int' is legal in HLSL, and 'struct int' appears to only be rejected due to the redefinition of the 'int' type. Fixes #791
2017-11-27 21:45:36 +00:00
case EHTokConstantBuffer: return "ConstantBuffer";
HLSL: Fix 1201: Accept 'layout' as an identifier.
2017-12-30 03:59:13 +00:00
case EHTokLayout: return "layout";
HLSL: Recognize types declared as identifiers as identifiers. E.g., in float float; (float) * float; The "(float)" is not a type cast, it is an expression.
2017-06-14 04:22:52 +00:00
default:
return nullptr;
}
}
HLSL: Plumb in HLSL parse context and keywords, and most basic HLSL parser and test.
2016-03-13 03:11:22 +00:00
} // end namespace glslang
Reference in New Issue Copy Permalink