mirror of
https://github.com/OpenMW/openmw.git
synced 2025-04-21 04:36:45 +00:00
65cdd489fb
Fixed some types removed useless header applied clang format fixed compile tests fixed clang tidy, and closer to logic before this MR Removed hardcoded refids unless there is a returned value we don't use static RefIds can use == between RefId and hardcoded string Fix clang format Fixed a few instances where std::string was used, when only const std::string& was needed removed unused variable
760 lines
20 KiB
C++
760 lines
20 KiB
C++
#include "exprparser.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <iterator>
|
|
#include <sstream>
|
|
#include <stack>
|
|
#include <stdexcept>
|
|
|
|
#include <components/esm/refid.hpp>
|
|
#include <components/misc/strings/lower.hpp>
|
|
|
|
#include "context.hpp"
|
|
#include "discardparser.hpp"
|
|
#include "errorhandler.hpp"
|
|
#include "extensions.hpp"
|
|
#include "generator.hpp"
|
|
#include "junkparser.hpp"
|
|
#include "locals.hpp"
|
|
#include "scanner.hpp"
|
|
#include "stringparser.hpp"
|
|
|
|
namespace Compiler
|
|
{
|
|
int ExprParser::getPriority(char op)
|
|
{
|
|
switch (op)
|
|
{
|
|
case '(':
|
|
|
|
return 0;
|
|
|
|
case 'e': // ==
|
|
case 'n': // !=
|
|
case 'l': // <
|
|
case 'L': // <=
|
|
case 'g': // <
|
|
case 'G': // >=
|
|
|
|
return 1;
|
|
|
|
case '+':
|
|
case '-':
|
|
|
|
return 2;
|
|
|
|
case '*':
|
|
case '/':
|
|
|
|
return 3;
|
|
|
|
case 'm':
|
|
|
|
return 4;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
char ExprParser::getOperandType(int Index) const
|
|
{
|
|
assert(!mOperands.empty());
|
|
assert(Index >= 0);
|
|
assert(Index < static_cast<int>(mOperands.size()));
|
|
return mOperands[mOperands.size() - 1 - Index];
|
|
}
|
|
|
|
char ExprParser::getOperator() const
|
|
{
|
|
assert(!mOperators.empty());
|
|
return mOperators[mOperators.size() - 1];
|
|
}
|
|
|
|
bool ExprParser::isOpen() const
|
|
{
|
|
return std::find(mOperators.begin(), mOperators.end(), '(') != mOperators.end();
|
|
}
|
|
|
|
void ExprParser::popOperator()
|
|
{
|
|
assert(!mOperators.empty());
|
|
mOperators.resize(mOperators.size() - 1);
|
|
}
|
|
|
|
void ExprParser::popOperand()
|
|
{
|
|
assert(!mOperands.empty());
|
|
mOperands.resize(mOperands.size() - 1);
|
|
}
|
|
|
|
void ExprParser::replaceBinaryOperands()
|
|
{
|
|
char t1 = getOperandType(1);
|
|
char t2 = getOperandType();
|
|
|
|
popOperand();
|
|
popOperand();
|
|
|
|
if (t1 == t2)
|
|
mOperands.push_back(t1);
|
|
else if (t1 == 'f' || t2 == 'f')
|
|
mOperands.push_back('f');
|
|
else
|
|
throw std::logic_error("Failed to determine result operand type");
|
|
}
|
|
|
|
void ExprParser::pop()
|
|
{
|
|
char op = getOperator();
|
|
|
|
switch (op)
|
|
{
|
|
case 'm':
|
|
|
|
Generator::negate(mCode, getOperandType());
|
|
popOperator();
|
|
break;
|
|
|
|
case '+':
|
|
|
|
Generator::add(mCode, getOperandType(1), getOperandType());
|
|
popOperator();
|
|
replaceBinaryOperands();
|
|
break;
|
|
|
|
case '-':
|
|
|
|
Generator::sub(mCode, getOperandType(1), getOperandType());
|
|
popOperator();
|
|
replaceBinaryOperands();
|
|
break;
|
|
|
|
case '*':
|
|
|
|
Generator::mul(mCode, getOperandType(1), getOperandType());
|
|
popOperator();
|
|
replaceBinaryOperands();
|
|
break;
|
|
|
|
case '/':
|
|
|
|
Generator::div(mCode, getOperandType(1), getOperandType());
|
|
popOperator();
|
|
replaceBinaryOperands();
|
|
break;
|
|
|
|
case 'e':
|
|
case 'n':
|
|
case 'l':
|
|
case 'L':
|
|
case 'g':
|
|
case 'G':
|
|
|
|
Generator::compare(mCode, op, getOperandType(1), getOperandType());
|
|
popOperator();
|
|
popOperand();
|
|
popOperand();
|
|
mOperands.push_back('l');
|
|
break;
|
|
|
|
default:
|
|
|
|
throw std::logic_error("Unknown operator");
|
|
}
|
|
}
|
|
|
|
void ExprParser::pushIntegerLiteral(int value)
|
|
{
|
|
mNextOperand = false;
|
|
mOperands.push_back('l');
|
|
Generator::pushInt(mCode, mLiterals, value);
|
|
}
|
|
|
|
void ExprParser::pushFloatLiteral(float value)
|
|
{
|
|
mNextOperand = false;
|
|
mOperands.push_back('f');
|
|
Generator::pushFloat(mCode, mLiterals, value);
|
|
}
|
|
|
|
void ExprParser::pushBinaryOperator(char c)
|
|
{
|
|
while (!mOperators.empty() && getPriority(getOperator()) >= getPriority(c))
|
|
pop();
|
|
|
|
mOperators.push_back(c);
|
|
mNextOperand = true;
|
|
}
|
|
|
|
void ExprParser::close()
|
|
{
|
|
while (getOperator() != '(')
|
|
pop();
|
|
|
|
popOperator();
|
|
}
|
|
|
|
int ExprParser::parseArguments(const std::string& arguments, Scanner& scanner)
|
|
{
|
|
return parseArguments(arguments, scanner, mCode);
|
|
}
|
|
|
|
bool ExprParser::handleMemberAccess(const std::string& name)
|
|
{
|
|
mMemberOp = false;
|
|
|
|
std::string name2 = Misc::StringUtils::lowerCase(name);
|
|
auto id = ESM::RefId::stringRefId(mExplicit);
|
|
|
|
std::pair<char, bool> type = getContext().getMemberType(name2, id);
|
|
|
|
if (type.first != ' ')
|
|
{
|
|
Generator::fetchMember(mCode, mLiterals, type.first, name2, id.getRefIdString(), !type.second);
|
|
|
|
mNextOperand = false;
|
|
mExplicit.clear();
|
|
mOperands.push_back(type.first == 'f' ? 'f' : 'l');
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
ExprParser::ExprParser(
|
|
ErrorHandler& errorHandler, const Context& context, Locals& locals, Literals& literals, bool argument)
|
|
: Parser(errorHandler, context)
|
|
, mLocals(locals)
|
|
, mLiterals(literals)
|
|
, mNextOperand(true)
|
|
, mFirst(true)
|
|
, mArgument(argument)
|
|
, mRefOp(false)
|
|
, mMemberOp(false)
|
|
{
|
|
}
|
|
|
|
bool ExprParser::parseInt(int value, const TokenLoc& loc, Scanner& scanner)
|
|
{
|
|
if (!mExplicit.empty())
|
|
return Parser::parseInt(value, loc, scanner);
|
|
|
|
mFirst = false;
|
|
|
|
if (mNextOperand)
|
|
{
|
|
start();
|
|
|
|
pushIntegerLiteral(value);
|
|
mTokenLoc = loc;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
scanner.putbackInt(value, loc);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ExprParser::parseFloat(float value, const TokenLoc& loc, Scanner& scanner)
|
|
{
|
|
if (!mExplicit.empty())
|
|
return Parser::parseFloat(value, loc, scanner);
|
|
|
|
mFirst = false;
|
|
|
|
if (mNextOperand)
|
|
{
|
|
start();
|
|
|
|
pushFloatLiteral(value);
|
|
mTokenLoc = loc;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
scanner.putbackFloat(value, loc);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ExprParser::parseName(const std::string& name, const TokenLoc& loc, Scanner& scanner)
|
|
{
|
|
if (!mExplicit.empty())
|
|
{
|
|
if (!mRefOp)
|
|
{
|
|
if (mMemberOp && handleMemberAccess(name))
|
|
return true;
|
|
|
|
return Parser::parseName(name, loc, scanner);
|
|
}
|
|
else
|
|
{
|
|
mExplicit.clear();
|
|
getErrorHandler().warning("Stray explicit reference", loc);
|
|
}
|
|
}
|
|
|
|
mFirst = false;
|
|
|
|
if (mNextOperand)
|
|
{
|
|
start();
|
|
|
|
char type = mLocals.getType(name);
|
|
|
|
if (type != ' ')
|
|
{
|
|
Generator::fetchLocal(mCode, type, mLocals.getIndex(name));
|
|
mNextOperand = false;
|
|
mOperands.push_back(type == 'f' ? 'f' : 'l');
|
|
return true;
|
|
}
|
|
|
|
type = getContext().getGlobalType(name);
|
|
|
|
if (type != ' ')
|
|
{
|
|
Generator::fetchGlobal(mCode, mLiterals, type, name);
|
|
mNextOperand = false;
|
|
mOperands.push_back(type == 'f' ? 'f' : 'l');
|
|
return true;
|
|
}
|
|
|
|
if (mExplicit.empty() && getContext().isId(ESM::RefId::stringRefId(name)))
|
|
{
|
|
mExplicit = name;
|
|
return true;
|
|
}
|
|
|
|
// This is terrible, but of course we must have this for legacy content.
|
|
// Convert the string to a number even if it's impossible and use it as a number literal.
|
|
// Can't use stof/atof or to_string out of locale concerns.
|
|
float number;
|
|
std::stringstream stream(name);
|
|
stream >> number;
|
|
stream.str(std::string());
|
|
stream.clear();
|
|
stream << number;
|
|
|
|
pushFloatLiteral(number);
|
|
mTokenLoc = loc;
|
|
getErrorHandler().warning("Parsing a non-variable string as a number: " + stream.str(), loc);
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
scanner.putbackName(name, loc);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ExprParser::parseKeyword(int keyword, const TokenLoc& loc, Scanner& scanner)
|
|
{
|
|
if (const Extensions* extensions = getContext().getExtensions())
|
|
{
|
|
char returnType; // ignored
|
|
std::string argumentType; // ignored
|
|
bool hasExplicit = false; // ignored
|
|
bool isInstruction = extensions->isInstruction(keyword, argumentType, hasExplicit);
|
|
|
|
if (isInstruction
|
|
|| (mExplicit.empty() && extensions->isFunction(keyword, returnType, argumentType, hasExplicit)))
|
|
{
|
|
std::string name = loc.mLiteral;
|
|
if (name.size() >= 2 && name[0] == '"' && name[name.size() - 1] == '"')
|
|
name = name.substr(1, name.size() - 2);
|
|
if (isInstruction || mLocals.getType(Misc::StringUtils::lowerCase(name)) != ' ')
|
|
{
|
|
// pretend this is not a keyword
|
|
return parseName(name, loc, scanner);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (keyword == Scanner::K_end || keyword == Scanner::K_begin || keyword == Scanner::K_short
|
|
|| keyword == Scanner::K_long || keyword == Scanner::K_float || keyword == Scanner::K_if
|
|
|| keyword == Scanner::K_endif || keyword == Scanner::K_else || keyword == Scanner::K_elseif
|
|
|| keyword == Scanner::K_while || keyword == Scanner::K_endwhile || keyword == Scanner::K_return
|
|
|| keyword == Scanner::K_messagebox || keyword == Scanner::K_set || keyword == Scanner::K_to)
|
|
{
|
|
return parseName(loc.mLiteral, loc, scanner);
|
|
}
|
|
|
|
mFirst = false;
|
|
|
|
if (!mExplicit.empty())
|
|
{
|
|
if (mRefOp && mNextOperand)
|
|
{
|
|
|
|
// check for custom extensions
|
|
if (const Extensions* extensions = getContext().getExtensions())
|
|
{
|
|
char returnType;
|
|
std::string argumentType;
|
|
|
|
bool hasExplicit = true;
|
|
if (extensions->isFunction(keyword, returnType, argumentType, hasExplicit))
|
|
{
|
|
if (!hasExplicit)
|
|
{
|
|
getErrorHandler().warning("Stray explicit reference", loc);
|
|
mExplicit.clear();
|
|
}
|
|
|
|
start();
|
|
|
|
mTokenLoc = loc;
|
|
int optionals = parseArguments(argumentType, scanner);
|
|
|
|
extensions->generateFunctionCode(keyword, mCode, mLiterals, mExplicit, optionals);
|
|
mOperands.push_back(returnType);
|
|
mExplicit.clear();
|
|
mRefOp = false;
|
|
|
|
mNextOperand = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return Parser::parseKeyword(keyword, loc, scanner);
|
|
}
|
|
|
|
if (mNextOperand)
|
|
{
|
|
// check for custom extensions
|
|
if (const Extensions* extensions = getContext().getExtensions())
|
|
{
|
|
start();
|
|
|
|
char returnType;
|
|
std::string argumentType;
|
|
|
|
bool hasExplicit = false;
|
|
|
|
if (extensions->isFunction(keyword, returnType, argumentType, hasExplicit))
|
|
{
|
|
mTokenLoc = loc;
|
|
int optionals = parseArguments(argumentType, scanner);
|
|
|
|
extensions->generateFunctionCode(keyword, mCode, mLiterals, "", optionals);
|
|
mOperands.push_back(returnType);
|
|
|
|
mNextOperand = false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
scanner.putbackKeyword(keyword, loc);
|
|
return false;
|
|
}
|
|
|
|
return Parser::parseKeyword(keyword, loc, scanner);
|
|
}
|
|
|
|
bool ExprParser::parseSpecial(int code, const TokenLoc& loc, Scanner& scanner)
|
|
{
|
|
if (!mExplicit.empty())
|
|
{
|
|
if (mRefOp && code == Scanner::S_open)
|
|
{
|
|
/// \todo add option to disable this workaround
|
|
mOperators.push_back('(');
|
|
mTokenLoc = loc;
|
|
return true;
|
|
}
|
|
|
|
if (!mRefOp && code == Scanner::S_ref)
|
|
{
|
|
mRefOp = true;
|
|
return true;
|
|
}
|
|
|
|
if (!mMemberOp && code == Scanner::S_member)
|
|
{
|
|
mMemberOp = true;
|
|
return true;
|
|
}
|
|
|
|
return Parser::parseSpecial(code, loc, scanner);
|
|
}
|
|
|
|
mFirst = false;
|
|
|
|
if (code == Scanner::S_newline)
|
|
{
|
|
// end marker
|
|
if (mTokenLoc.mLiteral.empty())
|
|
mTokenLoc = loc;
|
|
scanner.putbackSpecial(code, loc);
|
|
return false;
|
|
}
|
|
|
|
if (code == Scanner::S_minus && mNextOperand)
|
|
{
|
|
// unary
|
|
mOperators.push_back('m');
|
|
mTokenLoc = loc;
|
|
return true;
|
|
}
|
|
|
|
if (code == Scanner::S_plus && mNextOperand)
|
|
{
|
|
// Also unary, but +, just ignore it
|
|
mTokenLoc = loc;
|
|
return true;
|
|
}
|
|
|
|
if (code == Scanner::S_open)
|
|
{
|
|
if (mNextOperand)
|
|
{
|
|
mOperators.push_back('(');
|
|
mTokenLoc = loc;
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
scanner.putbackSpecial(code, loc);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (code == Scanner::S_close && !mNextOperand)
|
|
{
|
|
if (isOpen())
|
|
{
|
|
close();
|
|
return true;
|
|
}
|
|
|
|
mTokenLoc = loc;
|
|
scanner.putbackSpecial(code, loc);
|
|
return false;
|
|
}
|
|
|
|
if (!mNextOperand)
|
|
{
|
|
mTokenLoc = loc;
|
|
char c = 0; // comparison
|
|
|
|
switch (code)
|
|
{
|
|
case Scanner::S_plus:
|
|
c = '+';
|
|
break;
|
|
case Scanner::S_minus:
|
|
c = '-';
|
|
break;
|
|
case Scanner::S_mult:
|
|
pushBinaryOperator('*');
|
|
return true;
|
|
case Scanner::S_div:
|
|
pushBinaryOperator('/');
|
|
return true;
|
|
case Scanner::S_cmpEQ:
|
|
c = 'e';
|
|
break;
|
|
case Scanner::S_cmpNE:
|
|
c = 'n';
|
|
break;
|
|
case Scanner::S_cmpLT:
|
|
c = 'l';
|
|
break;
|
|
case Scanner::S_cmpLE:
|
|
c = 'L';
|
|
break;
|
|
case Scanner::S_cmpGT:
|
|
c = 'g';
|
|
break;
|
|
case Scanner::S_cmpGE:
|
|
c = 'G';
|
|
break;
|
|
}
|
|
|
|
if (c)
|
|
{
|
|
if (mArgument && !isOpen())
|
|
{
|
|
// expression ends here
|
|
// Thank you Morrowind for this rotten syntax :(
|
|
scanner.putbackSpecial(code, loc);
|
|
return false;
|
|
}
|
|
|
|
pushBinaryOperator(c);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return Parser::parseSpecial(code, loc, scanner);
|
|
}
|
|
|
|
void ExprParser::reset()
|
|
{
|
|
mOperands.clear();
|
|
mOperators.clear();
|
|
mNextOperand = true;
|
|
mCode.clear();
|
|
mFirst = true;
|
|
mExplicit.clear();
|
|
mRefOp = false;
|
|
mMemberOp = false;
|
|
Parser::reset();
|
|
}
|
|
|
|
char ExprParser::append(std::vector<Interpreter::Type_Code>& code)
|
|
{
|
|
if (mOperands.empty() && mOperators.empty())
|
|
{
|
|
getErrorHandler().error("Missing expression", mTokenLoc);
|
|
return 'l';
|
|
}
|
|
|
|
if (mNextOperand || mOperands.empty())
|
|
{
|
|
getErrorHandler().error("Syntax error in expression", mTokenLoc);
|
|
return 'l';
|
|
}
|
|
|
|
while (!mOperators.empty())
|
|
pop();
|
|
|
|
std::copy(mCode.begin(), mCode.end(), std::back_inserter(code));
|
|
|
|
assert(mOperands.size() == 1);
|
|
return mOperands[0];
|
|
}
|
|
|
|
int ExprParser::parseArguments(const std::string& arguments, Scanner& scanner,
|
|
std::vector<Interpreter::Type_Code>& code, int ignoreKeyword, bool expectNames)
|
|
{
|
|
bool optional = false;
|
|
int optionalCount = 0;
|
|
|
|
ExprParser parser(getErrorHandler(), getContext(), mLocals, mLiterals, true);
|
|
StringParser stringParser(getErrorHandler(), getContext(), mLiterals);
|
|
DiscardParser discardParser(getErrorHandler(), getContext());
|
|
JunkParser junkParser(getErrorHandler(), getContext(), ignoreKeyword);
|
|
|
|
std::stack<std::vector<Interpreter::Type_Code>> stack;
|
|
|
|
for (char argument : arguments)
|
|
{
|
|
if (argument == '/')
|
|
{
|
|
optional = true;
|
|
}
|
|
else if (argument == 'S' || argument == 'c' || argument == 'x')
|
|
{
|
|
stringParser.reset();
|
|
|
|
if (optional || argument == 'x')
|
|
stringParser.setOptional(true);
|
|
|
|
if (argument == 'c')
|
|
stringParser.smashCase();
|
|
if (argument == 'x')
|
|
stringParser.discard();
|
|
scanner.enableExpectName();
|
|
scanner.scan(stringParser);
|
|
|
|
if ((optional || argument == 'x') && stringParser.isEmpty())
|
|
break;
|
|
|
|
if (argument != 'x')
|
|
{
|
|
std::vector<Interpreter::Type_Code> tmp;
|
|
stringParser.append(tmp);
|
|
|
|
stack.push(tmp);
|
|
|
|
if (optional)
|
|
++optionalCount;
|
|
}
|
|
else
|
|
getErrorHandler().warning("Extra argument", stringParser.getTokenLoc());
|
|
}
|
|
else if (argument == 'X')
|
|
{
|
|
parser.reset();
|
|
|
|
parser.setOptional(true);
|
|
|
|
scanner.scan(parser);
|
|
|
|
if (parser.isEmpty())
|
|
break;
|
|
else
|
|
getErrorHandler().warning("Extra argument", parser.getTokenLoc());
|
|
}
|
|
else if (argument == 'z')
|
|
{
|
|
discardParser.reset();
|
|
discardParser.setOptional(true);
|
|
|
|
scanner.scan(discardParser);
|
|
|
|
if (discardParser.isEmpty())
|
|
break;
|
|
else
|
|
getErrorHandler().warning("Extra argument", discardParser.getTokenLoc());
|
|
}
|
|
else if (argument == 'j')
|
|
{
|
|
/// \todo disable this when operating in strict mode
|
|
junkParser.reset();
|
|
|
|
scanner.scan(junkParser);
|
|
}
|
|
else
|
|
{
|
|
parser.reset();
|
|
|
|
if (optional)
|
|
parser.setOptional(true);
|
|
if (expectNames)
|
|
scanner.enableExpectName();
|
|
|
|
scanner.scan(parser);
|
|
|
|
if (optional && parser.isEmpty())
|
|
break;
|
|
|
|
std::vector<Interpreter::Type_Code> tmp;
|
|
|
|
char type = parser.append(tmp);
|
|
|
|
if (type != argument)
|
|
Generator::convert(tmp, type, argument);
|
|
|
|
stack.push(tmp);
|
|
|
|
if (optional)
|
|
++optionalCount;
|
|
}
|
|
}
|
|
|
|
while (!stack.empty())
|
|
{
|
|
std::vector<Interpreter::Type_Code>& tmp = stack.top();
|
|
|
|
std::copy(tmp.begin(), tmp.end(), std::back_inserter(code));
|
|
|
|
stack.pop();
|
|
}
|
|
|
|
return optionalCount;
|
|
}
|
|
|
|
const TokenLoc& ExprParser::getTokenLoc() const
|
|
{
|
|
return mTokenLoc;
|
|
}
|
|
}
|