mirror of
https://github.com/OpenMW/openmw.git
synced 2025-11-03 08:26:39 +00:00
106 lines
3.3 KiB
C++
106 lines
3.3 KiB
C++
#ifndef COMPILER_EXPRPARSER_H_INCLUDED
|
|
#define COMPILER_EXPRPARSER_H_INCLUDED
|
|
|
|
#include <vector>
|
|
|
|
#include <components/interpreter/types.hpp>
|
|
|
|
#include "parser.hpp"
|
|
#include "tokenloc.hpp"
|
|
|
|
namespace Compiler
|
|
{
|
|
class Locals;
|
|
class Literals;
|
|
|
|
class ExprParser : public Parser
|
|
{
|
|
Locals& mLocals;
|
|
Literals& mLiterals;
|
|
std::vector<char> mOperands;
|
|
std::vector<char> mOperators;
|
|
bool mNextOperand;
|
|
TokenLoc mTokenLoc;
|
|
std::vector<Interpreter::Type_Code> mCode;
|
|
bool mFirst;
|
|
bool mArgument;
|
|
std::string mExplicit;
|
|
bool mRefOp;
|
|
|
|
int getPriority (char op) const;
|
|
|
|
char getOperandType (int Index = 0) const;
|
|
|
|
char getOperator() const;
|
|
|
|
bool isOpen() const;
|
|
|
|
void popOperator();
|
|
|
|
void popOperand();
|
|
|
|
void replaceBinaryOperands();
|
|
|
|
void pop();
|
|
|
|
void pushIntegerLiteral (int value);
|
|
|
|
void pushFloatLiteral (float value);
|
|
|
|
void pushBinaryOperator (char c);
|
|
|
|
void close();
|
|
|
|
int parseArguments (const std::string& arguments, Scanner& scanner);
|
|
|
|
public:
|
|
|
|
ExprParser (ErrorHandler& errorHandler, Context& context, Locals& locals,
|
|
Literals& literals, bool argument = false);
|
|
///< constructor
|
|
/// \param argument Parser is used to parse function- or instruction-
|
|
/// arguments (this influences the precedence rules).
|
|
|
|
char getType() const;
|
|
///< Return type of parsed expression ('l' integer, 'f' float)
|
|
|
|
virtual bool parseInt (int value, const TokenLoc& loc, Scanner& scanner);
|
|
///< Handle an int token.
|
|
/// \return fetch another token?
|
|
|
|
virtual bool parseFloat (float value, const TokenLoc& loc, Scanner& scanner);
|
|
///< Handle a float token.
|
|
/// \return fetch another token?
|
|
|
|
virtual bool parseName (const std::string& name, const TokenLoc& loc,
|
|
Scanner& scanner);
|
|
///< Handle a name token.
|
|
/// \return fetch another token?
|
|
|
|
virtual bool parseKeyword (int keyword, const TokenLoc& loc, Scanner& scanner);
|
|
///< Handle a keyword token.
|
|
/// \return fetch another token?
|
|
|
|
virtual bool parseSpecial (int code, const TokenLoc& loc, Scanner& scanner);
|
|
///< Handle a special character token.
|
|
/// \return fetch another token?
|
|
|
|
void reset();
|
|
///< Reset parser to clean state.
|
|
|
|
char append (std::vector<Interpreter::Type_Code>& code);
|
|
///< Generate code for parsed expression.
|
|
/// \return Type ('l': integer, 'f': float)
|
|
|
|
int parseArguments (const std::string& arguments, Scanner& scanner,
|
|
std::vector<Interpreter::Type_Code>& code, bool invert = false);
|
|
///< Parse sequence of arguments specified by \a arguments.
|
|
/// \param arguments Each character represents one arguments ('l': integer,
|
|
/// 'f': float, 'S': string, 'c': string (case smashed), '/': following arguments are
|
|
/// optional)
|
|
/// \param invert Store arguments in reverted order.
|
|
/// \return number of optional arguments
|
|
};
|
|
}
|
|
|
|
#endif
|