diff options
Diffstat (limited to '3rdparty/bgfx/3rdparty/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp')
-rw-r--r-- | 3rdparty/bgfx/3rdparty/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp | 326 |
1 files changed, 326 insertions, 0 deletions
diff --git a/3rdparty/bgfx/3rdparty/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp b/3rdparty/bgfx/3rdparty/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp new file mode 100644 index 00000000000..471f26c028c --- /dev/null +++ b/3rdparty/bgfx/3rdparty/glslang/glslang/MachineIndependent/preprocessor/PpTokens.cpp @@ -0,0 +1,326 @@ +// +//Copyright (C) 2002-2005 3Dlabs Inc. Ltd. +//Copyright (C) 2013 LunarG, Inc. +//All rights reserved. +// +//Redistribution and use in source and binary forms, with or without +//modification, are permitted provided that the following conditions +//are met: +// +// 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 3Dlabs Inc. Ltd. nor the names of its +// contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +//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. +// +/****************************************************************************\ +Copyright (c) 2002, NVIDIA Corporation. + +NVIDIA Corporation("NVIDIA") supplies this software to you in +consideration of your agreement to the following terms, and your use, +installation, modification or redistribution of this NVIDIA software +constitutes acceptance of these terms. If you do not agree with these +terms, please do not use, install, modify or redistribute this NVIDIA +software. + +In consideration of your agreement to abide by the following terms, and +subject to these terms, NVIDIA grants you a personal, non-exclusive +license, under NVIDIA's copyrights in this original NVIDIA software (the +"NVIDIA Software"), to use, reproduce, modify and redistribute the +NVIDIA Software, with or without modifications, in source and/or binary +forms; provided that if you redistribute the NVIDIA Software, you must +retain the copyright notice of NVIDIA, this notice and the following +text and disclaimers in all such redistributions of the NVIDIA Software. +Neither the name, trademarks, service marks nor logos of NVIDIA +Corporation may be used to endorse or promote products derived from the +NVIDIA Software without specific prior written permission from NVIDIA. +Except as expressly stated in this notice, no other rights or licenses +express or implied, are granted by NVIDIA herein, including but not +limited to any patent rights that may be infringed by your derivative +works or by other works in which the NVIDIA Software may be +incorporated. No hardware is licensed hereunder. + +THE NVIDIA SOFTWARE IS BEING PROVIDED ON AN "AS IS" BASIS, WITHOUT +WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, +INCLUDING WITHOUT LIMITATION, WARRANTIES OR CONDITIONS OF TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR +ITS USE AND OPERATION EITHER ALONE OR IN COMBINATION WITH OTHER +PRODUCTS. + +IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, +INCIDENTAL, EXEMPLARY, CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED +TO, LOST PROFITS; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) OR ARISING IN ANY WAY +OUT OF THE USE, REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE +NVIDIA SOFTWARE, HOWEVER CAUSED AND WHETHER UNDER THEORY OF CONTRACT, +TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN IF +NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +\****************************************************************************/ + +// +// For recording and playing back the stream of tokens in a macro definition. +// + +#if (defined(_MSC_VER) && _MSC_VER < 1900 /*vs2015*/) +#define _CRT_SECURE_NO_WARNINGS +#define snprintf sprintf_s +#endif + +#include <cassert> +#include <cstdlib> +#include <cstring> +#include <cctype> + +#include "PpContext.h" +#include "PpTokens.h" + +namespace glslang { + +void TPpContext::lAddByte(TokenStream& fTok, unsigned char fVal) +{ + fTok.data.push_back(fVal); +} + +/* +* Get the next byte from a stream. +*/ +int TPpContext::lReadByte(TokenStream& pTok) +{ + if (pTok.current < pTok.data.size()) + return pTok.data[pTok.current++]; + else + return EndOfInput; +} + +void TPpContext::lUnreadByte(TokenStream& pTok) +{ + if (pTok.current > 0) + --pTok.current; +} + +/* +* Add a token to the end of a list for later playback. +*/ +void TPpContext::RecordToken(TokenStream& pTok, int token, TPpToken* ppToken) +{ + const char* s; + char* str = NULL; + + if (token > PpAtomMaxSingle) + lAddByte(pTok, (unsigned char)((token & 0x7f) + 0x80)); + else + lAddByte(pTok, (unsigned char)(token & 0x7f)); + + switch (token) { + case PpAtomIdentifier: + case PpAtomConstString: + s = ppToken->name; + while (*s) + lAddByte(pTok, (unsigned char) *s++); + lAddByte(pTok, 0); + break; + case PpAtomConstInt: + case PpAtomConstUint: + case PpAtomConstInt64: + case PpAtomConstUint64: + case PpAtomConstFloat: + case PpAtomConstDouble: +#ifdef AMD_EXTENSIONS + case PpAtomConstFloat16: +#endif + str = ppToken->name; + while (*str) { + lAddByte(pTok, (unsigned char) *str); + str++; + } + lAddByte(pTok, 0); + break; + default: + break; + } +} + +/* +* Reset a token stream in preparation for reading. +*/ +void TPpContext::RewindTokenStream(TokenStream& pTok) +{ + pTok.current = 0; +} + +/* +* Read the next token from a token stream (not the source stream, but stream used to hold a tokenized macro). +*/ +int TPpContext::ReadToken(TokenStream& pTok, TPpToken *ppToken) +{ + int ltoken, len; + int ch; + + ltoken = lReadByte(pTok); + ppToken->loc = parseContext.getCurrentLoc(); + if (ltoken > 127) + ltoken += 128; + switch (ltoken) { + case '#': + // Check for ##, unless the current # is the last character + if (pTok.current < pTok.data.size()) { + if (lReadByte(pTok) == '#') { + parseContext.requireProfile(ppToken->loc, ~EEsProfile, "token pasting (##)"); + parseContext.profileRequires(ppToken->loc, ~EEsProfile, 130, 0, "token pasting (##)"); + ltoken = PpAtomPaste; + } else + lUnreadByte(pTok); + } + break; + case PpAtomConstString: + case PpAtomIdentifier: + case PpAtomConstFloat: + case PpAtomConstDouble: +#ifdef AMD_EXTENSIONS + case PpAtomConstFloat16: +#endif + case PpAtomConstInt: + case PpAtomConstUint: + case PpAtomConstInt64: + case PpAtomConstUint64: + len = 0; + ch = lReadByte(pTok); + while (ch != 0 && ch != EndOfInput) { + if (len < MaxTokenLength) { + ppToken->name[len] = (char)ch; + len++; + ch = lReadByte(pTok); + } else { + parseContext.error(ppToken->loc, "token too long", "", ""); + break; + } + } + ppToken->name[len] = 0; + + switch (ltoken) { + case PpAtomIdentifier: + break; + case PpAtomConstString: + break; + case PpAtomConstFloat: + case PpAtomConstDouble: +#ifdef AMD_EXTENSIONS + case PpAtomConstFloat16: +#endif + ppToken->dval = atof(ppToken->name); + break; + case PpAtomConstInt: + if (len > 0 && ppToken->name[0] == '0') { + if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X')) + ppToken->ival = (int)strtol(ppToken->name, 0, 16); + else + ppToken->ival = (int)strtol(ppToken->name, 0, 8); + } else + ppToken->ival = atoi(ppToken->name); + break; + case PpAtomConstUint: + if (len > 0 && ppToken->name[0] == '0') { + if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X')) + ppToken->ival = (int)strtoul(ppToken->name, 0, 16); + else + ppToken->ival = (int)strtoul(ppToken->name, 0, 8); + } else + ppToken->ival = (int)strtoul(ppToken->name, 0, 10); + break; + case PpAtomConstInt64: + if (len > 0 && ppToken->name[0] == '0') { + if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X')) + ppToken->i64val = strtoll(ppToken->name, nullptr, 16); + else + ppToken->i64val = strtoll(ppToken->name, nullptr, 8); + } else + ppToken->i64val = atoll(ppToken->name); + break; + case PpAtomConstUint64: + if (len > 0 && ppToken->name[0] == '0') { + if (len > 1 && (ppToken->name[1] == 'x' || ppToken->name[1] == 'X')) + ppToken->i64val = (long long)strtoull(ppToken->name, nullptr, 16); + else + ppToken->i64val = (long long)strtoull(ppToken->name, nullptr, 8); + } else + ppToken->i64val = (long long)strtoull(ppToken->name, 0, 10); + break; + } + } + + return ltoken; +} + +int TPpContext::tTokenInput::scan(TPpToken* ppToken) +{ + return pp->ReadToken(*tokens, ppToken); +} + +// We are pasting if the entire macro is preceding a pasting operator +// (lastTokenPastes) and we are also on the last token. +bool TPpContext::tTokenInput::peekPasting() +{ + if (! lastTokenPastes) + return false; + // Getting here means the last token will be pasted. + + // Are we at the last non-whitespace token? + size_t savePos = tokens->current; + bool moreTokens = false; + do { + int byte = pp->lReadByte(*tokens); + if (byte == EndOfInput) + break; + if (byte != ' ') { + moreTokens = true; + break; + } + } while (true); + tokens->current = savePos; + + return !moreTokens; +} + +void TPpContext::pushTokenStreamInput(TokenStream& ts, bool prepasting) +{ + pushInput(new tTokenInput(this, &ts, prepasting)); + RewindTokenStream(ts); +} + +int TPpContext::tUngotTokenInput::scan(TPpToken* ppToken) +{ + if (done) + return EndOfInput; + + int ret = token; + *ppToken = lval; + done = true; + + return ret; +} + +void TPpContext::UngetToken(int token, TPpToken* ppToken) +{ + pushInput(new tUngotTokenInput(this, token, ppToken)); +} + +} // end namespace glslang |