510 lines
14 KiB
Plaintext
510 lines
14 KiB
Plaintext
%require "3.0.2"
|
|
%defines
|
|
%define parser_class_name {RezParser}
|
|
%skeleton "lalr1.cc"
|
|
|
|
%locations;
|
|
|
|
%define api.token.constructor
|
|
%define api.value.type variant
|
|
%define parse.assert
|
|
|
|
%token<std::string> IDENTIFIER;
|
|
%token<int> CHARLIT;
|
|
%token<std::string> STRINGLIT;
|
|
%token<int> INTLIT;
|
|
|
|
%token<std::string> BADTOKEN;
|
|
|
|
|
|
%token LEFTBRACE "{";
|
|
%token RIGHTBRACE "}";
|
|
%token LEFTBRACKET "[";
|
|
%token RIGHTBRACKET "]";
|
|
%token LEFTPAREN "(";
|
|
%token RIGHTPAREN ")";
|
|
%token SEMICOLON ";";
|
|
%token COMMA ",";
|
|
%token PLUS "+";
|
|
%token MINUS "-";
|
|
%token DIVIDE "/";
|
|
%token STAR "*";
|
|
%token ASSIGN "=";
|
|
%token COLON ":";
|
|
%token SHIFTLEFT "<<";
|
|
%token SHIFTRIGHT ">>";
|
|
%token EQUAL "==";
|
|
%token NOTEQUAL "!=";
|
|
%token AND "&";
|
|
%token OR "|";
|
|
%token XOR "^";
|
|
%token COMPL "~";
|
|
%token DOLLAR "$";
|
|
|
|
%token TYPE "type";
|
|
%token RESOURCE "resource";
|
|
%token DATA "data";
|
|
%token READ "read";
|
|
%token INCLUDE "include";
|
|
%token CHANGE "change";
|
|
%token DELETE "delete";
|
|
|
|
|
|
%token ARRAY "array";
|
|
%token SWITCH "switch";
|
|
%token CASE "case";
|
|
%token AS "as";
|
|
%token FILL "fill";
|
|
%token ALIGN "align";
|
|
%token HEX "hex";
|
|
%token KEY "key";
|
|
%token WIDE "wide";
|
|
%token LITERAL "literal";
|
|
%token UNSIGNED "unsigned";
|
|
%token BINARY "binary";
|
|
|
|
%token BOOLEAN "boolean";
|
|
%token BIT "bit";
|
|
%token NIBBLE "nibble";
|
|
%token BYTE "byte";
|
|
%token CHAR "char";
|
|
%token WORD "word";
|
|
%token INTEGER "integer";
|
|
%token LONG "long";
|
|
%token LONGINT "longint";
|
|
%token PSTRING "pstring";
|
|
%token WSTRING "wstring";
|
|
%token STRING "string";
|
|
%token POINT "point";
|
|
%token RECT "rect";
|
|
%token BITSTRING "bitstring";
|
|
|
|
%token FUN_COUNTOF "$$countof";
|
|
%token FUN_ARRAYINDEX "$$arrayindex";
|
|
%token FUN_READ "$$read";
|
|
%token FUN_BITFIELD "$$bitfield";
|
|
%token FUN_WORD "$$word";
|
|
%token FUN_BYTE "$$byte";
|
|
%token FUN_LONG "$$long";
|
|
|
|
/*
|
|
%left "|";
|
|
%left "^";
|
|
%left "&";
|
|
%left "==" "!=";
|
|
%left ">>" "<<";
|
|
%left "+" "-";
|
|
%left "*" "/";
|
|
*/
|
|
|
|
%param { RezLexer& lexer }
|
|
%param { RezWorld& world }
|
|
|
|
%code requires {
|
|
#include "ResourceDefinitions.h"
|
|
#include "Expression.h"
|
|
#include "ResSpec.h"
|
|
|
|
#define YY_NULLPTR nullptr
|
|
class RezLexer;
|
|
class RezWorld;
|
|
}
|
|
|
|
%code provides {
|
|
using yy::RezParser;
|
|
//using RezSymbol = yy::RezParser::symbol_type;
|
|
|
|
class RezSymbol : public yy::RezParser::symbol_type
|
|
{
|
|
public:
|
|
RezSymbol() = default;
|
|
RezSymbol(yy::RezParser::symbol_type&& x) : yy::RezParser::symbol_type(std::move(x)) {}
|
|
};
|
|
}
|
|
|
|
%code {
|
|
#include "RezLexer.h"
|
|
#include "RezWorld.h"
|
|
#include "ResourceCompiler.h"
|
|
#include "Diagnostic.h"
|
|
|
|
static yy::RezParser::symbol_type yylex(RezLexer& lexer, RezWorld&)
|
|
{
|
|
return lexer.nextToken();
|
|
}
|
|
|
|
void yy::RezParser::error(const location_type& loc, std::string const& err)
|
|
{
|
|
world.problem(Diagnostic(Diagnostic::error, err, loc));
|
|
}
|
|
|
|
static std::string fromHex(std::string hex)
|
|
{
|
|
std::string bin;
|
|
int nibble;
|
|
bool haveNibble = false;
|
|
for(std::string::iterator p = hex.begin(); p != hex.end(); ++p)
|
|
{
|
|
if(std::isspace(*p))
|
|
continue;
|
|
assert(isdigit(*p) || (tolower(*p) >= 'a' && tolower(*p) <= 'f'));
|
|
int digit;
|
|
if(isdigit(*p))
|
|
digit = *p - '0';
|
|
else
|
|
digit = tolower(*p) - 'a' + 0xA;
|
|
|
|
if(haveNibble)
|
|
{
|
|
bin += (char) ((nibble << 4) | digit);
|
|
haveNibble = false;
|
|
}
|
|
else
|
|
{
|
|
nibble = digit;
|
|
haveNibble = true;
|
|
}
|
|
}
|
|
return bin;
|
|
}
|
|
|
|
}
|
|
|
|
%%
|
|
%start rez;
|
|
|
|
rez : %empty
|
|
| rez type_definition ";"
|
|
| rez resource ";"
|
|
| rez data ";"
|
|
;
|
|
|
|
type_definition : "type" type_spec
|
|
{
|
|
TypeDefinitionPtr td = std::make_shared<TypeDefinition>();
|
|
world.addTypeDefinition($type_spec, td);
|
|
world.fieldLists.push(td);
|
|
}
|
|
"{" field_definitions "}"
|
|
{ world.fieldLists.pop(); if(world.verboseFlag) std::cout << "TYPE " << $2 << std::endl; }
|
|
| "type" type_spec "as" type_spec
|
|
{
|
|
if(world.verboseFlag) std::cout << "TYPE " << $2 << std::endl;
|
|
auto spec = $4;
|
|
world.addTypeDefinition($2, world.getTypeDefinition(spec.getType(), spec.getID(), @4));
|
|
}
|
|
;
|
|
|
|
%type <ResType> res_type;
|
|
res_type : CHARLIT { $$ = ResType($1); } ;
|
|
|
|
%type <TypeSpec> type_spec;
|
|
type_spec : res_type { $$ = TypeSpec($res_type); }
|
|
| res_type "(" INTLIT ")" { $$ = TypeSpec($res_type, $INTLIT); }
|
|
;
|
|
|
|
field_definitions : %empty
|
|
| field_definitions IDENTIFIER ":" { world.fieldLists.top()->addLabel($2, @2); }
|
|
| field_definitions ";"
|
|
| field_definitions field_definition ";" { world.fieldLists.top()->addField($2, @2); }
|
|
;
|
|
|
|
%type <FieldPtr> field_definition;
|
|
field_definition: simple_field_definition { $$ = $1; }
|
|
| array_definition { $$ = $1; }
|
|
| switch_definition { $$ = $1; }
|
|
| fill_statement { $$ = $1; }
|
|
| align_statement { $$ = $1; }
|
|
;
|
|
|
|
%type <SimpleFieldPtr> simple_field_definition;
|
|
simple_field_definition: field_attributes simpletype array_count_opt value_spec_opt
|
|
{
|
|
$$ = std::make_shared<SimpleField>();
|
|
$$->attrs = $field_attributes;
|
|
$$->type = $simpletype;
|
|
$$->arrayCount = $array_count_opt;
|
|
$$->value = $value_spec_opt;
|
|
}
|
|
| simple_field_definition IDENTIFIER
|
|
{ $$ = $1; $$->addNamedValue($IDENTIFIER); }
|
|
| simple_field_definition IDENTIFIER "=" value
|
|
{ $$ = $1; $$->addNamedValue($IDENTIFIER, $value); }
|
|
| simple_field_definition "," IDENTIFIER
|
|
{ $$ = $1; $$->addNamedValue($IDENTIFIER); }
|
|
| simple_field_definition "," IDENTIFIER "=" value
|
|
{ $$ = $1; $$->addNamedValue($IDENTIFIER, $value); }
|
|
;
|
|
|
|
%type <ExprPtr> array_count array_count_opt value_spec_opt value resource_item;
|
|
%type <ExprPtr> expression expression1 expression2 ;
|
|
%type <ExprPtr> expression3 expression4 expression5 ;
|
|
%type <ExprPtr> expression6 expression7 expression8;
|
|
|
|
value_spec_opt : %empty { $$ = nullptr; } | "=" value { $$ = $2; } ;
|
|
|
|
%type <SimpleField::Type> simpletype;
|
|
simpletype : "boolean" { $$ = SimpleField::Type::boolean; }
|
|
| "byte" { $$ = SimpleField::Type::byte; }
|
|
| "integer" { $$ = SimpleField::Type::integer; }
|
|
| "longint" { $$ = SimpleField::Type::longint; }
|
|
| "rect" { $$ = SimpleField::Type::rect; }
|
|
| "point" { $$ = SimpleField::Type::point; }
|
|
| "char" { $$ = SimpleField::Type::char_; }
|
|
| "pstring" { $$ = SimpleField::Type::pstring; }
|
|
| "wstring" { $$ = SimpleField::Type::wstring; }
|
|
| "string" { $$ = SimpleField::Type::string; }
|
|
| "bitstring" { $$ = SimpleField::Type::bitstring; }
|
|
;
|
|
|
|
%type <FieldPtr> fill_statement align_statement;
|
|
fill_statement : "fill" fill_unit array_count_opt
|
|
{ $$ = std::make_shared<FillAlignField>($fill_unit, false, $array_count_opt); }
|
|
;
|
|
align_statement : "align" fill_unit
|
|
{ $$ = std::make_shared<FillAlignField>($fill_unit, true); }
|
|
;
|
|
|
|
%type <FillAlignField::Type> fill_unit;
|
|
fill_unit : "bit" { $$ = FillAlignField::Type::bit; }
|
|
| "nibble" { $$ = FillAlignField::Type::nibble; }
|
|
| "byte" { $$ = FillAlignField::Type::byte; }
|
|
| "word" { $$ = FillAlignField::Type::word; }
|
|
| "long" { $$ = FillAlignField::Type::long_; }
|
|
;
|
|
|
|
%type <FieldPtr> array_definition;
|
|
array_definition:
|
|
array_attributes "array" array_name_opt array_count_opt
|
|
{
|
|
ArrayFieldPtr af = std::make_shared<ArrayField>($array_name_opt, $array_count_opt);
|
|
world.fieldLists.push(af);
|
|
}
|
|
"{" field_definitions "}"
|
|
{
|
|
$$ = world.fieldLists.top();
|
|
world.fieldLists.pop();
|
|
}
|
|
;
|
|
|
|
array_count : "[" expression "]" { $$ = $2; }
|
|
array_count_opt : %empty { $$ = nullptr; } | array_count { $$ = $1; };
|
|
|
|
%type <std::string> array_name_opt;
|
|
array_name_opt : %empty { $$ = ""; } | IDENTIFIER { $$ = $1; } ;
|
|
|
|
array_attributes: %empty | "wide" ;
|
|
|
|
%type <SimpleField::Attrs> field_attributes field_attribute;
|
|
field_attributes: %empty { $$ = SimpleField::Attrs::none; }
|
|
| field_attributes field_attribute { $$ = $1 | $2; }
|
|
;
|
|
|
|
field_attribute : "hex" { $$ = SimpleField::Attrs::hex; }
|
|
| "key" { $$ = SimpleField::Attrs::key; }
|
|
| "unsigned" { $$ = SimpleField::Attrs::unsigned_; }
|
|
| "literal" { $$ = SimpleField::Attrs::literal; }
|
|
| "binary" { $$ = SimpleField::Attrs::binary; }
|
|
;
|
|
|
|
%type <FieldPtr> switch_definition;
|
|
switch_definition:
|
|
"switch"
|
|
{ world.switches.push(std::make_shared<SwitchField>()); }
|
|
"{"
|
|
switch_cases
|
|
"}"
|
|
{
|
|
$$ = world.switches.top();
|
|
world.switches.pop();
|
|
}
|
|
;
|
|
|
|
switch_cases : %empty | switch_cases switch_case ;
|
|
|
|
switch_case : "case" IDENTIFIER ":"
|
|
{
|
|
world.fieldLists.push(std::make_shared<FieldList>());
|
|
}
|
|
field_definitions
|
|
{
|
|
world.switches.top()->addCase($IDENTIFIER, world.fieldLists.top());
|
|
world.fieldLists.pop();
|
|
}
|
|
;
|
|
|
|
|
|
value : expression { $$ = $1; }
|
|
| "{" resource_body "}" { $$ = $2; }
|
|
| string_expression { $$ = $1; }
|
|
;
|
|
|
|
expression : expression1 { $$ = $1; }
|
|
| expression "^" expression1 { $$ = std::make_shared<BinaryExpr>(BinaryOp::XOR, $1, $3, @1); }
|
|
;
|
|
|
|
expression1 : expression2 { $$ = $1; }
|
|
| expression1 "&" expression2 { $$ = std::make_shared<BinaryExpr>(BinaryOp::AND, $1, $3, @1); }
|
|
;
|
|
|
|
expression2 : expression3 { $$ = $1; }
|
|
| expression2 "|" expression3 { $$ = std::make_shared<BinaryExpr>(BinaryOp::OR, $1, $3, @1); }
|
|
;
|
|
|
|
expression3 : expression4 { $$ = $1; }
|
|
| expression3 "==" expression4 { $$ = std::make_shared<BinaryExpr>(BinaryOp::EQUAL, $1, $3, @1); }
|
|
| expression3 "!=" expression4 { $$ = std::make_shared<BinaryExpr>(BinaryOp::NOTEQUAL, $1, $3, @1); }
|
|
;
|
|
|
|
expression4 : expression5 { $$ = $1; }
|
|
| expression4 ">>" expression5 { $$ = std::make_shared<BinaryExpr>(BinaryOp::SHIFTRIGHT, $1, $3, @1); }
|
|
| expression4 "<<" expression5 { $$ = std::make_shared<BinaryExpr>(BinaryOp::SHIFTLEFT, $1, $3, @1); }
|
|
;
|
|
|
|
expression5 : expression6 { $$ = $1; }
|
|
| expression5 "+" expression6 { $$ = std::make_shared<BinaryExpr>(BinaryOp::PLUS, $1, $3, @1); }
|
|
| expression5 "-" expression6 { $$ = std::make_shared<BinaryExpr>(BinaryOp::MINUS, $1, $3, @1); }
|
|
;
|
|
|
|
expression6 : expression7 { $$ = $1; }
|
|
| expression6 "*" expression7 { $$ = std::make_shared<BinaryExpr>(BinaryOp::MULTIPLY, $1, $3, @1); }
|
|
| expression6 "/" expression7 { $$ = std::make_shared<BinaryExpr>(BinaryOp::DIVIDE, $1, $3, @1); }
|
|
;
|
|
expression7 : expression8 { $$ = $1; }
|
|
| "-" expression7 { $$ = std::make_shared<UnaryExpr>(UnaryOp::MINUS, $2, @1); }
|
|
| "+" expression7 { $$ = $2; }
|
|
| "~" expression7 { $$ = std::make_shared<UnaryExpr>(UnaryOp::COMPLEMENT, $2, @1); }
|
|
;
|
|
|
|
expression8 : INTLIT { $$ = std::make_shared<IntExpr>($1, @1); }
|
|
| CHARLIT { $$ = std::make_shared<IntExpr>($1, @1); }
|
|
|
|
| identifier_expression { $$ = $1; }
|
|
| "(" expression ")" { $$ = $2; }
|
|
|
|
| "$$countof" "(" identifier_expression ")"
|
|
{ $$ = std::make_shared<CountOfExpr>($identifier_expression, @1); }
|
|
| "$$arrayindex" "(" identifier_expression ")"
|
|
{ $$ = std::make_shared<ArrayIndexExpr>($identifier_expression, @1); }
|
|
| "$$bitfield" "(" expression "," expression "," expression ")"
|
|
{ $$ = std::make_shared<PeekExpr>($3, $5, $7, @1); }
|
|
| "$$word" "(" expression ")"
|
|
{ $$ = std::make_shared<PeekExpr>($3, 16, @1); }
|
|
| "$$byte" "(" expression ")"
|
|
{ $$ = std::make_shared<PeekExpr>($3, 8, @1); }
|
|
| "$$long" "(" expression ")"
|
|
{ $$ = std::make_shared<PeekExpr>($3, 32, @1); }
|
|
;
|
|
|
|
%type <IdentifierExprPtr> identifier_expression;
|
|
identifier_expression : IDENTIFIER { $$ = std::make_shared<IdentifierExpr>($1, @1); }
|
|
| IDENTIFIER
|
|
{ world.functionCalls.push(std::make_shared<IdentifierExpr>($1, @1)); }
|
|
"[" function_argument_list1 "]"
|
|
{ $$ = world.functionCalls.top(); world.functionCalls.pop(); }
|
|
;
|
|
|
|
function_argument_list : %empty | function_argument_list1 ;
|
|
function_argument_list1 : expression
|
|
{ world.functionCalls.top()->addArgument($expression); }
|
|
| function_argument_list "," expression
|
|
{ world.functionCalls.top()->addArgument($expression); }
|
|
;
|
|
|
|
%type <ExprPtr> string_expression string_expression1;
|
|
string_expression : string_expression1 { $$ = $1; }
|
|
| string_expression string_expression1
|
|
{ $$ = std::make_shared<BinaryExpr>(BinaryOp::CONCAT, $1, $2, @1); }
|
|
;
|
|
|
|
%type <std::string> stringlit;
|
|
stringlit : STRINGLIT { $$ = $1; }
|
|
| DOLLAR STRINGLIT { $$ = fromHex($2); }
|
|
;
|
|
|
|
string_expression1 : stringlit { $$ = std::make_shared<StringExpr>($1, @1); }
|
|
| "$$read" "(" string_expression ")"
|
|
{ $$ = std::make_shared<ReadExpr>($string_expression, @1); }
|
|
;
|
|
|
|
resource : "resource" res_spec "{" resource_body "}"
|
|
{
|
|
world.addResource($res_spec, $resource_body, @1);
|
|
}
|
|
;
|
|
|
|
%type <ResSpec> res_spec;
|
|
%type <ResSpec> resource_attributes;
|
|
|
|
res_spec : res_type "(" expression resource_attributes ")"
|
|
{
|
|
$$ = $resource_attributes;
|
|
$$.type() = $res_type;
|
|
$$.id() = $expression->evaluateInt(nullptr);
|
|
}
|
|
;
|
|
|
|
resource_attributes : %empty { $$ = ResSpec(); }
|
|
| resource_attributes "," IDENTIFIER
|
|
{
|
|
$$ = $1;
|
|
if($IDENTIFIER == "changed")
|
|
$$.attr() |= 2;
|
|
else if($IDENTIFIER == "preload")
|
|
$$.attr() |= 4;
|
|
else if($IDENTIFIER == "protected")
|
|
$$.attr() |= 8;
|
|
else if($IDENTIFIER == "locked")
|
|
$$.attr() |= 16;
|
|
else if($IDENTIFIER == "purgeable")
|
|
$$.attr() |= 32;
|
|
else if($IDENTIFIER == "sysheap")
|
|
$$.attr() |= 64;
|
|
else if($IDENTIFIER == "unchanged")
|
|
$$.attr() &= ~2;
|
|
else if($IDENTIFIER == "nonpreload")
|
|
$$.attr() &= ~4;
|
|
else if($IDENTIFIER == "unprotected")
|
|
$$.attr() &= ~8;
|
|
else if($IDENTIFIER == "unlocked")
|
|
$$.attr() &= ~16;
|
|
else if($IDENTIFIER == "nonpurgeable")
|
|
$$.attr() &= ~32;
|
|
else if($IDENTIFIER == "appheap")
|
|
$$.attr() &= ~64;
|
|
else
|
|
world.problem(Diagnostic(Diagnostic::error, "illegal attribute " + $IDENTIFIER, @1));
|
|
}
|
|
| resource_attributes "," string_expression
|
|
{
|
|
$$ = $1;
|
|
$$.name() = $3->evaluateString(nullptr);
|
|
}
|
|
;
|
|
|
|
|
|
|
|
%type <CompoundExprPtr> resource_body resource_body1;
|
|
resource_body : %empty { $$ = std::make_shared<CompoundExpr>(yy::location()); }
|
|
| resource_body1 { $$ = $1; $$->location = @1; }
|
|
;
|
|
resource_body1 : resource_item { $$ = std::make_shared<CompoundExpr>(@1); $$->addItem($1); }
|
|
| resource_body1 "," resource_item { $$ = $1; $$->addItem($3); }
|
|
| resource_body1 ";" resource_item { $$ = $1; $$->addItem($3); }
|
|
| resource_body1 ";" { $$ = $1; }
|
|
| resource_body1 "," { $$ = $1; }
|
|
;
|
|
|
|
resource_item : value { $$ = $1; }
|
|
| IDENTIFIER "{" resource_body "}" { $$ = std::make_shared<CaseExpr>($IDENTIFIER, $resource_body, @1); }
|
|
;
|
|
|
|
|
|
data : "data" res_spec "{" string_expression "}"
|
|
{
|
|
world.addData($res_spec, $string_expression->evaluateString(nullptr), @1);
|
|
}
|
|
;
|
|
|
|
%%
|