587 lines
19 KiB
Plaintext
587 lines
19 KiB
Plaintext
/* Syntax analyzer.
|
|
Copyright (C) 2025 Free Software Foundation, Inc.
|
|
|
|
GCC is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 3, or (at your option)
|
|
any later version.
|
|
|
|
GCC is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
%require "3.4"
|
|
%language "c++"
|
|
|
|
%code {
|
|
using namespace elna;
|
|
}
|
|
|
|
%code requires {
|
|
#include <cstdint>
|
|
#include <iostream>
|
|
#include "elna/boot/driver.h"
|
|
|
|
#if !defined(yyFlexLexerOnce)
|
|
#include <FlexLexer.h>
|
|
#endif
|
|
|
|
namespace elna
|
|
{
|
|
namespace boot
|
|
{
|
|
class lexer;
|
|
}
|
|
}
|
|
}
|
|
|
|
%code provides {
|
|
namespace elna
|
|
{
|
|
namespace boot
|
|
{
|
|
|
|
class lexer: public yyFlexLexer
|
|
{
|
|
public:
|
|
yy::location location;
|
|
|
|
lexer(std::istream& arg_yyin)
|
|
: yyFlexLexer(&arg_yyin)
|
|
{
|
|
}
|
|
|
|
yy::parser::symbol_type lex(driver& driver);
|
|
};
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
%define api.token.raw
|
|
%define api.token.constructor
|
|
%define api.value.type variant
|
|
|
|
%parse-param {elna::boot::lexer& lexer}
|
|
%param {elna::boot::driver& driver}
|
|
%locations
|
|
|
|
%header
|
|
|
|
%code {
|
|
#define yylex lexer.lex
|
|
}
|
|
%start program;
|
|
|
|
%token <std::string> IDENTIFIER
|
|
%token <std::string> TRAIT
|
|
%token <std::int32_t> INTEGER
|
|
%token <std::uint32_t> WORD
|
|
%token <float> FLOAT
|
|
%token <std::string> CHARACTER
|
|
%token <std::string> STRING
|
|
%token <bool> BOOLEAN
|
|
%token LEFT_PAREN "(" RIGHT_PAREN ")" LEFT_SQUARE "[" RIGHT_SQUARE "]"
|
|
%token ASSIGNMENT ":="
|
|
ARROW "->" EXCLAMATION "!"
|
|
AT "@" HAT "^"
|
|
COLON ":" SEMICOLON ";" DOT "." COMMA ","
|
|
%token NOT "~"
|
|
CAST "cast"
|
|
NIL "nil"
|
|
CONST "const"
|
|
VAR "var"
|
|
PROCEDURE "proc"
|
|
TYPE "type"
|
|
RECORD "record"
|
|
UNION "union"
|
|
EXTERN "extern"
|
|
IF "if"
|
|
WHILE "while"
|
|
DO "do"
|
|
THEN "then"
|
|
ELSE "else"
|
|
ELSIF "elsif"
|
|
RETURN "return"
|
|
BEGIN_BLOCK "begin"
|
|
END_BLOCK "end"
|
|
DEFER "defer"
|
|
%token OR "|" AND "&" XOR "xor"
|
|
EQUALS "=" NOT_EQUAL "<>" LESS_THAN "<" GREATER_THAN ">" LESS_EQUAL "<=" GREATER_EQUAL ">="
|
|
SHIFT_LEFT "<<" SHIFT_RIGHT ">>"
|
|
PLUS "+" MINUS "-"
|
|
MULTIPLICATION "*" DIVISION "/" REMAINDER "%"
|
|
|
|
%left "|" "&" "xor"
|
|
%left "=" "<>" "<" ">" "<=" ">="
|
|
%left "<<" ">>"
|
|
%left "+" "-"
|
|
%left "*" "/" "%"
|
|
|
|
%type <elna::boot::literal_expression *> literal;
|
|
%type <elna::boot::constant_definition *> constant_definition;
|
|
%type <std::vector<elna::boot::constant_definition *>> constant_part constant_definitions;
|
|
%type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration;
|
|
%type <std::shared_ptr<elna::boot::type_expression>> type_expression;
|
|
%type <std::vector<std::shared_ptr<elna::boot::type_expression>>> type_expressions;
|
|
%type <elna::boot::traits_expression *> traits_expression;
|
|
%type <elna::boot::expression *> expression operand qualident;
|
|
%type <elna::boot::unary_expression *> unary_expression;
|
|
%type <elna::boot::binary_expression *> binary_expression;
|
|
%type <std::vector<elna::boot::expression *>> expressions actual_parameter_list;
|
|
%type <elna::boot::designator_expression *> designator_expression;
|
|
%type <elna::boot::assign_statement *> assign_statement;
|
|
%type <elna::boot::procedure_call*> call_expression;
|
|
%type <elna::boot::while_statement *> while_statement;
|
|
%type <elna::boot::if_statement *> if_statement;
|
|
%type <elna::boot::return_statement *> return_statement;
|
|
%type <elna::boot::statement *> statement;
|
|
%type <std::vector<elna::boot::statement *>> statements;
|
|
%type <elna::boot::procedure_definition *> procedure_definition;
|
|
%type <std::pair<std::vector<std::string>, std::shared_ptr<elna::boot::procedure_type_expression>>> procedure_heading;
|
|
%type <elna::boot::return_declaration> return_declaration;
|
|
%type <std::vector<elna::boot::procedure_definition *>> procedure_definitions procedure_part;
|
|
%type <elna::boot::type_definition *> type_definition;
|
|
%type <std::vector<elna::boot::type_definition *>> type_definitions type_part;
|
|
%type <elna::boot::block *> block;
|
|
%type <elna::boot::field_declaration> field_declaration formal_parameter;
|
|
%type <std::vector<std::pair<std::string, std::shared_ptr<elna::boot::type_expression>>>>
|
|
optional_fields required_fields formal_parameters;
|
|
%type <std::vector<elna::boot::conditional_statements *>> elsif_then_statements elsif_do_statements;
|
|
%type <elna::boot::cast_expression *> cast_expression;
|
|
%type <elna::boot::defer_statement *> defer_statement;
|
|
%type <std::pair<std::string, bool>> identifier_definition;
|
|
%type <std::vector<std::pair<std::string, bool>>> identifier_definitions;
|
|
%%
|
|
program:
|
|
constant_part type_part variable_part procedure_part "begin" statements "end" "."
|
|
{
|
|
auto tree = new boot::program(boot::make_position(@5));
|
|
|
|
std::swap(tree->constants, $1);
|
|
std::swap(tree->types , $2);
|
|
std::swap(tree->variables, $3);
|
|
std::swap(tree->procedures, $4);
|
|
std::swap(tree->body, $6);
|
|
|
|
driver.tree.reset(tree);
|
|
}
|
|
block: constant_part variable_part "begin" statements "end"
|
|
{
|
|
$$ = new boot::block(boot::make_position(@3));
|
|
|
|
std::swap($$->constants, $1);
|
|
std::swap($$->variables, $2);
|
|
std::swap($$->body, $4);
|
|
}
|
|
identifier_definition:
|
|
IDENTIFIER "*"
|
|
{
|
|
$$ = std::make_pair($1, true);
|
|
}
|
|
| IDENTIFIER
|
|
{
|
|
$$ = std::make_pair($1, false);
|
|
}
|
|
identifier_definitions:
|
|
identifier_definition "," identifier_definitions
|
|
{
|
|
std::swap($$, $3);
|
|
$$.emplace($$.cbegin(), $1);
|
|
}
|
|
| identifier_definition { $$.emplace_back(std::move($1)); }
|
|
return_declaration:
|
|
/* proper procedure */ {}
|
|
| "->" "!" { $$ = boot::return_declaration(std::monostate{}); }
|
|
| "->" type_expression { $$ = boot::return_declaration($2); }
|
|
procedure_heading:
|
|
"(" formal_parameters ")" return_declaration
|
|
{
|
|
$$.second = std::make_shared<boot::procedure_type_expression>(boot::make_position(@1),
|
|
std::move($4));
|
|
for (auto& [name, type] : $2)
|
|
{
|
|
$$.first.emplace_back(std::move(name));
|
|
$$.second->parameters.push_back(type);
|
|
}
|
|
}
|
|
procedure_definition:
|
|
"proc" identifier_definition procedure_heading ";" block
|
|
{
|
|
$$ = new boot::procedure_definition(boot::make_position(@1),
|
|
$2.first, $2.second, $3.second, $5);
|
|
std::swap($3.first, $$->parameter_names);
|
|
}
|
|
| "proc" identifier_definition procedure_heading ";" "extern"
|
|
{
|
|
$$ = new boot::procedure_definition(boot::make_position(@1), $2.first, $2.second, $3.second);
|
|
std::swap($3.first, $$->parameter_names);
|
|
}
|
|
procedure_definitions:
|
|
procedure_definition procedure_definitions
|
|
{
|
|
std::swap($$, $2);
|
|
$$.emplace($$.cbegin(), std::move($1));
|
|
}
|
|
| procedure_definition { $$.emplace_back(std::move($1)); }
|
|
procedure_part:
|
|
/* no procedure definitions */ {}
|
|
| procedure_definitions { std::swap($$, $1); }
|
|
assign_statement: designator_expression ":=" expression
|
|
{
|
|
$$ = new boot::assign_statement(boot::make_position(@1), $1, $3);
|
|
}
|
|
call_expression: designator_expression actual_parameter_list
|
|
{
|
|
$$ = new boot::procedure_call(boot::make_position(@1), $1);
|
|
std::swap($$->arguments, $2);
|
|
}
|
|
cast_expression: "cast" "(" expression ":" type_expression ")"
|
|
{
|
|
$$ = new boot::cast_expression(boot::make_position(@1), $5, $3);
|
|
}
|
|
elsif_do_statements:
|
|
"elsif" expression "do" statements elsif_do_statements
|
|
{
|
|
boot::conditional_statements *branch = new boot::conditional_statements($2);
|
|
std::swap(branch->statements, $4);
|
|
std::swap($5, $$);
|
|
$$.emplace($$.begin(), branch);
|
|
}
|
|
| {}
|
|
while_statement: "while" expression "do" statements elsif_do_statements "end"
|
|
{
|
|
auto body = new boot::conditional_statements($2);
|
|
std::swap($4, body->statements);
|
|
$$ = new boot::while_statement(boot::make_position(@1), body);
|
|
std::swap($5, $$->branches);
|
|
}
|
|
elsif_then_statements:
|
|
"elsif" expression "then" statements elsif_then_statements
|
|
{
|
|
boot::conditional_statements *branch = new boot::conditional_statements($2);
|
|
std::swap(branch->statements, $4);
|
|
std::swap($5, $$);
|
|
$$.emplace($$.begin(), branch);
|
|
}
|
|
| {}
|
|
if_statement:
|
|
"if" expression "then" statements elsif_then_statements "end"
|
|
{
|
|
auto then = new boot::conditional_statements($2);
|
|
std::swap($4, then->statements);
|
|
$$ = new boot::if_statement(boot::make_position(@1), then);
|
|
std::swap($5, $$->branches);
|
|
}
|
|
| "if" expression "then" statements elsif_then_statements "else" statements "end"
|
|
{
|
|
auto then = new boot::conditional_statements($2);
|
|
std::swap($4, then->statements);
|
|
auto _else = new std::vector<boot::statement *>(std::move($7));
|
|
$$ = new boot::if_statement(boot::make_position(@1), then, _else);
|
|
std::swap($5, $$->branches);
|
|
}
|
|
return_statement:
|
|
"return" expression
|
|
{
|
|
$$ = new boot::return_statement(boot::make_position(@1), $2);
|
|
}
|
|
| "return"
|
|
{
|
|
$$ = new boot::return_statement(boot::make_position(@1));
|
|
}
|
|
defer_statement: DEFER statements "end"
|
|
{
|
|
$$ = new boot::defer_statement(boot::make_position(@1));
|
|
std::swap($2, $$->statements);
|
|
}
|
|
literal:
|
|
INTEGER
|
|
{
|
|
$$ = new boot::literal<std::int32_t>(boot::make_position(@1), $1);
|
|
}
|
|
| WORD
|
|
{
|
|
$$ = new boot::literal<std::uint32_t>(boot::make_position(@1), $1);
|
|
}
|
|
| FLOAT
|
|
{
|
|
$$ = new boot::literal<double>(boot::make_position(@1), $1);
|
|
}
|
|
| BOOLEAN
|
|
{
|
|
$$ = new boot::literal<bool>(boot::make_position(@1), $1);
|
|
}
|
|
| CHARACTER
|
|
{
|
|
$$ = new boot::literal<unsigned char>(boot::make_position(@1), $1.at(0));
|
|
}
|
|
| "nil"
|
|
{
|
|
$$ = new boot::literal<std::nullptr_t>(boot::make_position(@1), nullptr);
|
|
}
|
|
| STRING
|
|
{
|
|
$$ = new boot::literal<std::string>(boot::make_position(@1), $1);
|
|
}
|
|
traits_expression:
|
|
TRAIT "(" type_expressions ")"
|
|
{
|
|
$$ = new boot::traits_expression(boot::make_position(@1), $1);
|
|
std::swap($3, $$->parameters);
|
|
}
|
|
qualident:
|
|
literal { $$ = $1; }
|
|
| designator_expression { $$ = $1; }
|
|
| traits_expression { $$ = $1; }
|
|
| cast_expression { $$ = $1; }
|
|
| call_expression { $$ = $1; }
|
|
| "(" expression ")" { $$ = $2; }
|
|
operand:
|
|
unary_expression { $$ = $1; }
|
|
| qualident { $$ = $1; }
|
|
expression:
|
|
binary_expression { $$ = $1; }
|
|
| operand { $$ = $1; }
|
|
binary_expression:
|
|
expression "*" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::multiplication);
|
|
}
|
|
| expression "/" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::division);
|
|
}
|
|
| expression "%" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::remainder);
|
|
}
|
|
| expression "+" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::sum);
|
|
}
|
|
| expression "-" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::subtraction);
|
|
}
|
|
| expression "=" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::equals);
|
|
}
|
|
| expression "<>" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::not_equals);
|
|
}
|
|
| expression "<" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::less);
|
|
}
|
|
| expression ">" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater);
|
|
}
|
|
| expression "<=" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3,
|
|
boot::binary_operator::less_equal);
|
|
}
|
|
| expression ">=" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::greater_equal);
|
|
}
|
|
| expression "&" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::conjunction);
|
|
}
|
|
| expression "|" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::disjunction);
|
|
}
|
|
| expression "xor" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3,
|
|
boot::binary_operator::exclusive_disjunction);
|
|
}
|
|
| expression "<<" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_left);
|
|
}
|
|
| expression ">>" expression
|
|
{
|
|
$$ = new boot::binary_expression(boot::make_position(@2), $1, $3, boot::binary_operator::shift_right);
|
|
}
|
|
unary_expression:
|
|
"@" operand
|
|
{
|
|
$$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::reference);
|
|
}
|
|
| "~" operand
|
|
{
|
|
$$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::negation);
|
|
}
|
|
| "-" operand
|
|
{
|
|
$$ = new boot::unary_expression(boot::make_position(@1), $2, boot::unary_operator::minus);
|
|
}
|
|
expressions:
|
|
expression "," expressions
|
|
{
|
|
std::swap($$, $3);
|
|
$$.emplace($$.cbegin(), $1);
|
|
}
|
|
| expression { $$.push_back($1); }
|
|
type_expressions:
|
|
type_expression "," type_expressions
|
|
{
|
|
std::swap($$, $3);
|
|
$$.emplace($$.cbegin(), $1);
|
|
}
|
|
| type_expression { $$.push_back($1); }
|
|
designator_expression:
|
|
qualident "[" expression "]"
|
|
{
|
|
$$ = new boot::array_access_expression(boot::make_position(@2), $1, $3);
|
|
}
|
|
| qualident "." IDENTIFIER
|
|
{
|
|
$$ = new boot::field_access_expression(boot::make_position(@2), $1, $3);
|
|
}
|
|
| qualident "^"
|
|
{
|
|
$$ = new boot::dereference_expression(boot::make_position(@1), $1);
|
|
}
|
|
| IDENTIFIER
|
|
{
|
|
$$ = new boot::variable_expression(boot::make_position(@1), $1);
|
|
}
|
|
statement:
|
|
assign_statement { $$ = $1; }
|
|
| while_statement { $$ = $1; }
|
|
| if_statement { $$ = $1; }
|
|
| return_statement { $$ = $1; }
|
|
| call_expression { $$ = $1; }
|
|
| defer_statement { $$ = $1; }
|
|
statements:
|
|
statement ";" statements
|
|
{
|
|
std::swap($$, $3);
|
|
$$.insert($$.cbegin(), $1);
|
|
}
|
|
| statement { $$.push_back($1); }
|
|
| /* no statements */ {}
|
|
field_declaration:
|
|
IDENTIFIER ":" type_expression { $$ = std::make_pair($1, $3); }
|
|
required_fields:
|
|
field_declaration required_fields
|
|
{
|
|
std::swap($$, $2);
|
|
$$.emplace($$.cbegin(), $1);
|
|
}
|
|
| field_declaration { $$.emplace_back($1); }
|
|
optional_fields:
|
|
required_fields { std::swap($$, $1); }
|
|
| /* no fields */ {}
|
|
type_expression:
|
|
"[" INTEGER "]" type_expression
|
|
{
|
|
$$ = std::make_shared<boot::array_type_expression>(boot::make_position(@1), $4, $2);
|
|
}
|
|
| "^" type_expression
|
|
{
|
|
$$ = std::make_shared<boot::pointer_type_expression>(boot::make_position(@1), $2);
|
|
}
|
|
| "record" optional_fields "end"
|
|
{
|
|
$$ = std::make_shared<boot::record_type_expression>(boot::make_position(@1), std::move($2));
|
|
}
|
|
| "union" required_fields "end"
|
|
{
|
|
$$ = std::make_shared<boot::union_type_expression>(boot::make_position(@1), std::move($2));
|
|
}
|
|
| "proc" "(" type_expressions ")" return_declaration
|
|
{
|
|
auto result = std::make_shared<boot::procedure_type_expression>(boot::make_position(@1),
|
|
std::move($5));
|
|
std::swap(result->parameters, $3);
|
|
$$ = result;
|
|
}
|
|
| IDENTIFIER
|
|
{
|
|
$$ = std::make_shared<boot::primitive_type_expression>(boot::make_position(@1), $1);
|
|
}
|
|
variable_declaration: identifier_definitions ":" type_expression
|
|
{
|
|
for (const std::pair<std::string, bool>& identifier : $1)
|
|
{
|
|
boot::variable_declaration *declaration = new boot::variable_declaration(
|
|
boot::make_position(@2), identifier.first, $3, identifier.second);
|
|
$$.push_back(declaration);
|
|
}
|
|
}
|
|
variable_declarations:
|
|
variable_declaration variable_declarations
|
|
{
|
|
std::swap($$, $1);
|
|
$$.reserve($$.size() + $2.size());
|
|
$$.insert(std::end($$), std::begin($2), std::end($2));
|
|
}
|
|
| variable_declaration { std::swap($$, $1); }
|
|
variable_part:
|
|
/* no variable declarations */ {}
|
|
| "var" variable_declarations { std::swap($$, $2); }
|
|
constant_definition: identifier_definition "=" literal
|
|
{
|
|
$$ = new boot::constant_definition(boot::make_position(@1), $1.first, $1.second, $3);
|
|
}
|
|
constant_definitions:
|
|
constant_definition constant_definitions
|
|
{
|
|
std::swap($$, $2);
|
|
$$.insert($$.cbegin(), $1);
|
|
}
|
|
| /* no constant definitions */ {}
|
|
constant_part:
|
|
{}
|
|
| "const" constant_definitions { std::swap($$, $2); }
|
|
type_definition: identifier_definition "=" type_expression
|
|
{
|
|
$$ = new boot::type_definition(boot::make_position(@1), $1.first, $1.second, $3);
|
|
}
|
|
type_definitions:
|
|
type_definition type_definitions
|
|
{
|
|
std::swap($$, $2);
|
|
$$.insert($$.cbegin(), $1);
|
|
}
|
|
| type_definition { $$.push_back($1); }
|
|
type_part:
|
|
/* no type definitions */ {}
|
|
| "type" {}
|
|
| "type" type_definitions { std::swap($$, $2); }
|
|
formal_parameter: IDENTIFIER ":" type_expression
|
|
{
|
|
$$ = std::make_pair($1, $3);
|
|
}
|
|
formal_parameters:
|
|
/* no formal parameters */ {}
|
|
| formal_parameter "," formal_parameters
|
|
{
|
|
std::swap($$, $3);
|
|
$$.emplace($$.cbegin(), $1);
|
|
}
|
|
| formal_parameter { $$.emplace_back(std::move($1)); }
|
|
actual_parameter_list:
|
|
"(" ")" {}
|
|
| "(" expressions ")" { std::swap($$, $2); }
|
|
%%
|
|
|
|
void yy::parser::error(const location_type& loc, const std::string& message)
|
|
{
|
|
driver.add_error<boot::syntax_error>(message, driver.input_file, loc);
|
|
}
|