Rim/gsc-tool
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 3 Wiki Activity

new lexer and update headers

Browse Source
This commit is contained in:
xensik 2022-01-26 12:08:28 +01:00
parent aaa54304cc
commit 0824e52aa0
237 changed files with 14009 additions and 40363 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
gen/h1/Makefile
View File

@ -3,10 +3,7 @@ generate: H1
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
H1: lexer.lpp parser.ypp
flex lexer.lpp
H1: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/h1/xsk/
mv parser.hpp parser.cpp ../../src/h1/xsk/

240
gen/h1/lexer.lpp
View File

@ -1,240 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="h1_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "h1.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void h1_push_header(xsk::gsc::context* ctx, const std::string& file);
void h1_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw h1::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw h1::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw h1::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return h1::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw h1::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return h1::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw h1::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw h1::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return h1::parser::make_INLINE(ctx->loc); }
"#include" { return h1::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return h1::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return h1::parser::make_ANIMTREE(ctx->loc); }
"endon" { return h1::parser::make_ENDON(ctx->loc); }
"notify" { return h1::parser::make_NOTIFY(ctx->loc); }
"wait" { return h1::parser::make_WAIT(ctx->loc); }
"waittill" { return h1::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return h1::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return h1::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"waitframe" { return h1::parser::make_WAITFRAME(ctx->loc); }
"if" { return h1::parser::make_IF(ctx->loc); }
"else" { return h1::parser::make_ELSE(ctx->loc); }
"do" { return h1::parser::make_DO(ctx->loc); }
"while" { return h1::parser::make_WHILE(ctx->loc); }
"for" { return h1::parser::make_FOR(ctx->loc); }
"foreach" { return h1::parser::make_FOREACH(ctx->loc); }
"in" { return h1::parser::make_IN(ctx->loc); }
"switch" { return h1::parser::make_SWITCH(ctx->loc); }
"case" { return h1::parser::make_CASE(ctx->loc); }
"default" { return h1::parser::make_DEFAULT(ctx->loc); }
"break" { return h1::parser::make_BREAK(ctx->loc); }
"continue" { return h1::parser::make_CONTINUE(ctx->loc); }
"return" { return h1::parser::make_RETURN(ctx->loc); }
"breakpoint" { return h1::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return h1::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return h1::parser::make_PROFEND(ctx->loc); }
"thread" { return h1::parser::make_THREAD(ctx->loc); }
"childthread" { return h1::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return h1::parser::make_THISTHREAD(ctx->loc); }
"call" { return h1::parser::make_CALL(ctx->loc); }
"true" { return h1::parser::make_TRUE(ctx->loc); }
"false" { return h1::parser::make_FALSE(ctx->loc); }
"undefined" { return h1::parser::make_UNDEFINED(ctx->loc); }
".size" { return h1::parser::make_SIZE(ctx->loc); }
"game" { return h1::parser::make_GAME(ctx->loc); }
"self" { return h1::parser::make_SELF(ctx->loc); }
"anim" { return h1::parser::make_ANIM(ctx->loc); }
"level" { return h1::parser::make_LEVEL(ctx->loc); }
\( { return h1::parser::make_LPAREN(ctx->loc); }
\) { return h1::parser::make_RPAREN(ctx->loc); }
\{ { return h1::parser::make_LBRACE(ctx->loc); }
\} { return h1::parser::make_RBRACE(ctx->loc); }
\[ { return h1::parser::make_LBRACKET(ctx->loc); }
\] { return h1::parser::make_RBRACKET(ctx->loc); }
\, { return h1::parser::make_COMMA(ctx->loc); }
\. { return h1::parser::make_DOT(ctx->loc); }
\:\: { return h1::parser::make_DOUBLECOLON(ctx->loc); }
\: { return h1::parser::make_COLON(ctx->loc); }
\; { return h1::parser::make_SEMICOLON(ctx->loc); }
\? { return h1::parser::make_QMARK(ctx->loc); }
\+\+ { return h1::parser::make_INCREMENT(ctx->loc); }
\-\- { return h1::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return h1::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return h1::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return h1::parser::make_LSHIFT(ctx->loc); }
\>\> { return h1::parser::make_RSHIFT(ctx->loc); }
\|\| { return h1::parser::make_OR(ctx->loc); }
\&\& { return h1::parser::make_AND(ctx->loc); }
\=\= { return h1::parser::make_EQUALITY(ctx->loc); }
\!\= { return h1::parser::make_INEQUALITY(ctx->loc); }
\<\= { return h1::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return h1::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return h1::parser::make_LESS(ctx->loc); }
\> { return h1::parser::make_GREATER(ctx->loc); }
\+\= { return h1::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return h1::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return h1::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return h1::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return h1::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return h1::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return h1::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return h1::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return h1::parser::make_ASSIGN(ctx->loc); }
\+ { return h1::parser::make_ADD(ctx->loc); }
\- { return h1::parser::make_SUB(ctx->loc); }
\* { return h1::parser::make_MUL(ctx->loc); }
\/ { return h1::parser::make_DIV(ctx->loc); }
\% { return h1::parser::make_MOD(ctx->loc); }
\! { return h1::parser::make_NOT(ctx->loc); }
\~ { return h1::parser::make_COMPLEMENT(ctx->loc); }
\| { return h1::parser::make_BITWISE_OR(ctx->loc); }
\& { return h1::parser::make_BITWISE_AND(ctx->loc); }
\^ { return h1::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return h1::parser::make_PATH(xsk::gsc::h1::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return h1::parser::make_IDENTIFIER(xsk::gsc::h1::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return h1::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return h1::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return h1::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return h1::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return h1::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return h1::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return h1::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return h1::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return h1::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) h1_pop_header(ctx); else return h1::parser::make_H1EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw h1::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void h1_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void h1_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/h1/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::h1::lexer& lexer }
%parse-param { xsk::gsc::h1::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "h1.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::h1::parser::symbol_type H1lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::h1 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::h1::parser::symbol_type H1lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::h1::parser::symbol_type H1lex(xsk::gsc::h1::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -268,7 +262,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { h1_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -286,7 +280,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -296,7 +290,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/h2/Makefile
View File

@ -3,10 +3,7 @@ generate: H2
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
H2: lexer.lpp parser.ypp
flex lexer.lpp
H2: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/h2/xsk/
mv parser.hpp parser.cpp ../../src/h2/xsk/

240
gen/h2/lexer.lpp
View File

@ -1,240 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="h2_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "h2.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void h2_push_header(xsk::gsc::context* ctx, const std::string& file);
void h2_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw h2::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw h2::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw h2::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return h2::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw h2::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return h2::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw h2::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw h2::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return h2::parser::make_INLINE(ctx->loc); }
"#include" { return h2::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return h2::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return h2::parser::make_ANIMTREE(ctx->loc); }
"endon" { return h2::parser::make_ENDON(ctx->loc); }
"notify" { return h2::parser::make_NOTIFY(ctx->loc); }
"wait" { return h2::parser::make_WAIT(ctx->loc); }
"waittill" { return h2::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return h2::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return h2::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"waitframe" { return h2::parser::make_WAITFRAME(ctx->loc); }
"if" { return h2::parser::make_IF(ctx->loc); }
"else" { return h2::parser::make_ELSE(ctx->loc); }
"do" { return h2::parser::make_DO(ctx->loc); }
"while" { return h2::parser::make_WHILE(ctx->loc); }
"for" { return h2::parser::make_FOR(ctx->loc); }
"foreach" { return h2::parser::make_FOREACH(ctx->loc); }
"in" { return h2::parser::make_IN(ctx->loc); }
"switch" { return h2::parser::make_SWITCH(ctx->loc); }
"case" { return h2::parser::make_CASE(ctx->loc); }
"default" { return h2::parser::make_DEFAULT(ctx->loc); }
"break" { return h2::parser::make_BREAK(ctx->loc); }
"continue" { return h2::parser::make_CONTINUE(ctx->loc); }
"return" { return h2::parser::make_RETURN(ctx->loc); }
"breakpoint" { return h2::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return h2::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return h2::parser::make_PROFEND(ctx->loc); }
"thread" { return h2::parser::make_THREAD(ctx->loc); }
"childthread" { return h2::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return h2::parser::make_THISTHREAD(ctx->loc); }
"call" { return h2::parser::make_CALL(ctx->loc); }
"true" { return h2::parser::make_TRUE(ctx->loc); }
"false" { return h2::parser::make_FALSE(ctx->loc); }
"undefined" { return h2::parser::make_UNDEFINED(ctx->loc); }
".size" { return h2::parser::make_SIZE(ctx->loc); }
"game" { return h2::parser::make_GAME(ctx->loc); }
"self" { return h2::parser::make_SELF(ctx->loc); }
"anim" { return h2::parser::make_ANIM(ctx->loc); }
"level" { return h2::parser::make_LEVEL(ctx->loc); }
\( { return h2::parser::make_LPAREN(ctx->loc); }
\) { return h2::parser::make_RPAREN(ctx->loc); }
\{ { return h2::parser::make_LBRACE(ctx->loc); }
\} { return h2::parser::make_RBRACE(ctx->loc); }
\[ { return h2::parser::make_LBRACKET(ctx->loc); }
\] { return h2::parser::make_RBRACKET(ctx->loc); }
\, { return h2::parser::make_COMMA(ctx->loc); }
\. { return h2::parser::make_DOT(ctx->loc); }
\:\: { return h2::parser::make_DOUBLECOLON(ctx->loc); }
\: { return h2::parser::make_COLON(ctx->loc); }
\; { return h2::parser::make_SEMICOLON(ctx->loc); }
\? { return h2::parser::make_QMARK(ctx->loc); }
\+\+ { return h2::parser::make_INCREMENT(ctx->loc); }
\-\- { return h2::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return h2::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return h2::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return h2::parser::make_LSHIFT(ctx->loc); }
\>\> { return h2::parser::make_RSHIFT(ctx->loc); }
\|\| { return h2::parser::make_OR(ctx->loc); }
\&\& { return h2::parser::make_AND(ctx->loc); }
\=\= { return h2::parser::make_EQUALITY(ctx->loc); }
\!\= { return h2::parser::make_INEQUALITY(ctx->loc); }
\<\= { return h2::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return h2::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return h2::parser::make_LESS(ctx->loc); }
\> { return h2::parser::make_GREATER(ctx->loc); }
\+\= { return h2::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return h2::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return h2::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return h2::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return h2::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return h2::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return h2::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return h2::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return h2::parser::make_ASSIGN(ctx->loc); }
\+ { return h2::parser::make_ADD(ctx->loc); }
\- { return h2::parser::make_SUB(ctx->loc); }
\* { return h2::parser::make_MUL(ctx->loc); }
\/ { return h2::parser::make_DIV(ctx->loc); }
\% { return h2::parser::make_MOD(ctx->loc); }
\! { return h2::parser::make_NOT(ctx->loc); }
\~ { return h2::parser::make_COMPLEMENT(ctx->loc); }
\| { return h2::parser::make_BITWISE_OR(ctx->loc); }
\& { return h2::parser::make_BITWISE_AND(ctx->loc); }
\^ { return h2::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return h2::parser::make_PATH(xsk::gsc::h2::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return h2::parser::make_IDENTIFIER(xsk::gsc::h2::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return h2::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return h2::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return h2::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return h2::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return h2::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return h2::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return h2::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return h2::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return h2::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) h2_pop_header(ctx); else return h2::parser::make_H2EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw h2::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void h2_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void h2_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/h2/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::h2::lexer& lexer }
%parse-param { xsk::gsc::h2::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "h2.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::h2::parser::symbol_type H2lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::h2 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::h2::parser::symbol_type H2lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::h2::parser::symbol_type H2lex(xsk::gsc::h2::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -268,7 +262,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { h2_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -286,7 +280,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -296,7 +290,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/iw5/Makefile
View File

@ -3,10 +3,7 @@ generate: IW5
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
IW5: lexer.lpp parser.ypp
flex lexer.lpp
IW5: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/iw5/xsk/
mv parser.hpp parser.cpp ../../src/iw5/xsk/

239
gen/iw5/lexer.lpp
View File

@ -1,239 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="iw5_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "iw5.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void iw5_push_header(xsk::gsc::context* ctx, const std::string& file);
void iw5_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw iw5::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw iw5::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw iw5::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return iw5::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw iw5::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return iw5::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw iw5::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw iw5::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return iw5::parser::make_INLINE(ctx->loc); }
"#include" { return iw5::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return iw5::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return iw5::parser::make_ANIMTREE(ctx->loc); }
"endon" { return iw5::parser::make_ENDON(ctx->loc); }
"notify" { return iw5::parser::make_NOTIFY(ctx->loc); }
"wait" { return iw5::parser::make_WAIT(ctx->loc); }
"waittill" { return iw5::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return iw5::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return iw5::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"if" { return iw5::parser::make_IF(ctx->loc); }
"else" { return iw5::parser::make_ELSE(ctx->loc); }
"do" { return iw5::parser::make_DO(ctx->loc); }
"while" { return iw5::parser::make_WHILE(ctx->loc); }
"for" { return iw5::parser::make_FOR(ctx->loc); }
"foreach" { return iw5::parser::make_FOREACH(ctx->loc); }
"in" { return iw5::parser::make_IN(ctx->loc); }
"switch" { return iw5::parser::make_SWITCH(ctx->loc); }
"case" { return iw5::parser::make_CASE(ctx->loc); }
"default" { return iw5::parser::make_DEFAULT(ctx->loc); }
"break" { return iw5::parser::make_BREAK(ctx->loc); }
"continue" { return iw5::parser::make_CONTINUE(ctx->loc); }
"return" { return iw5::parser::make_RETURN(ctx->loc); }
"breakpoint" { return iw5::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return iw5::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return iw5::parser::make_PROFEND(ctx->loc); }
"thread" { return iw5::parser::make_THREAD(ctx->loc); }
"childthread" { return iw5::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return iw5::parser::make_THISTHREAD(ctx->loc); }
"call" { return iw5::parser::make_CALL(ctx->loc); }
"true" { return iw5::parser::make_TRUE(ctx->loc); }
"false" { return iw5::parser::make_FALSE(ctx->loc); }
"undefined" { return iw5::parser::make_UNDEFINED(ctx->loc); }
".size" { return iw5::parser::make_SIZE(ctx->loc); }
"game" { return iw5::parser::make_GAME(ctx->loc); }
"self" { return iw5::parser::make_SELF(ctx->loc); }
"anim" { return iw5::parser::make_ANIM(ctx->loc); }
"level" { return iw5::parser::make_LEVEL(ctx->loc); }
\( { return iw5::parser::make_LPAREN(ctx->loc); }
\) { return iw5::parser::make_RPAREN(ctx->loc); }
\{ { return iw5::parser::make_LBRACE(ctx->loc); }
\} { return iw5::parser::make_RBRACE(ctx->loc); }
\[ { return iw5::parser::make_LBRACKET(ctx->loc); }
\] { return iw5::parser::make_RBRACKET(ctx->loc); }
\, { return iw5::parser::make_COMMA(ctx->loc); }
\. { return iw5::parser::make_DOT(ctx->loc); }
\:\: { return iw5::parser::make_DOUBLECOLON(ctx->loc); }
\: { return iw5::parser::make_COLON(ctx->loc); }
\; { return iw5::parser::make_SEMICOLON(ctx->loc); }
\? { return iw5::parser::make_QMARK(ctx->loc); }
\+\+ { return iw5::parser::make_INCREMENT(ctx->loc); }
\-\- { return iw5::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return iw5::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return iw5::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return iw5::parser::make_LSHIFT(ctx->loc); }
\>\> { return iw5::parser::make_RSHIFT(ctx->loc); }
\|\| { return iw5::parser::make_OR(ctx->loc); }
\&\& { return iw5::parser::make_AND(ctx->loc); }
\=\= { return iw5::parser::make_EQUALITY(ctx->loc); }
\!\= { return iw5::parser::make_INEQUALITY(ctx->loc); }
\<\= { return iw5::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return iw5::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return iw5::parser::make_LESS(ctx->loc); }
\> { return iw5::parser::make_GREATER(ctx->loc); }
\+\= { return iw5::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return iw5::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return iw5::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return iw5::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return iw5::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return iw5::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return iw5::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return iw5::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return iw5::parser::make_ASSIGN(ctx->loc); }
\+ { return iw5::parser::make_ADD(ctx->loc); }
\- { return iw5::parser::make_SUB(ctx->loc); }
\* { return iw5::parser::make_MUL(ctx->loc); }
\/ { return iw5::parser::make_DIV(ctx->loc); }
\% { return iw5::parser::make_MOD(ctx->loc); }
\! { return iw5::parser::make_NOT(ctx->loc); }
\~ { return iw5::parser::make_COMPLEMENT(ctx->loc); }
\| { return iw5::parser::make_BITWISE_OR(ctx->loc); }
\& { return iw5::parser::make_BITWISE_AND(ctx->loc); }
\^ { return iw5::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return iw5::parser::make_PATH(xsk::gsc::iw5::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return iw5::parser::make_IDENTIFIER(xsk::gsc::iw5::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return iw5::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return iw5::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return iw5::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return iw5::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return iw5::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return iw5::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return iw5::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return iw5::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return iw5::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) iw5_pop_header(ctx); else return iw5::parser::make_IW5EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw iw5::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void iw5_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void iw5_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/iw5/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::iw5::lexer& lexer }
%parse-param { xsk::gsc::iw5::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "iw5.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::iw5::parser::symbol_type IW5lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::iw5 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::iw5::parser::symbol_type IW5lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::iw5::parser::symbol_type IW5lex(xsk::gsc::iw5::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -266,7 +260,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { iw5_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -284,7 +278,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -294,7 +288,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/iw6/Makefile
View File

@ -3,10 +3,7 @@ generate: IW6
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
IW6: lexer.lpp parser.ypp
flex lexer.lpp
IW6: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/iw6/xsk/
mv parser.hpp parser.cpp ../../src/iw6/xsk/

239
gen/iw6/lexer.lpp
View File

@ -1,239 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="iw6_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "iw6.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void iw6_push_header(xsk::gsc::context* ctx, const std::string& file);
void iw6_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw iw6::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw iw6::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw iw6::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return iw6::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw iw6::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return iw6::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw iw6::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw iw6::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return iw6::parser::make_INLINE(ctx->loc); }
"#include" { return iw6::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return iw6::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return iw6::parser::make_ANIMTREE(ctx->loc); }
"endon" { return iw6::parser::make_ENDON(ctx->loc); }
"notify" { return iw6::parser::make_NOTIFY(ctx->loc); }
"wait" { return iw6::parser::make_WAIT(ctx->loc); }
"waittill" { return iw6::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return iw6::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return iw6::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"if" { return iw6::parser::make_IF(ctx->loc); }
"else" { return iw6::parser::make_ELSE(ctx->loc); }
"do" { return iw6::parser::make_DO(ctx->loc); }
"while" { return iw6::parser::make_WHILE(ctx->loc); }
"for" { return iw6::parser::make_FOR(ctx->loc); }
"foreach" { return iw6::parser::make_FOREACH(ctx->loc); }
"in" { return iw6::parser::make_IN(ctx->loc); }
"switch" { return iw6::parser::make_SWITCH(ctx->loc); }
"case" { return iw6::parser::make_CASE(ctx->loc); }
"default" { return iw6::parser::make_DEFAULT(ctx->loc); }
"break" { return iw6::parser::make_BREAK(ctx->loc); }
"continue" { return iw6::parser::make_CONTINUE(ctx->loc); }
"return" { return iw6::parser::make_RETURN(ctx->loc); }
"breakpoint" { return iw6::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return iw6::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return iw6::parser::make_PROFEND(ctx->loc); }
"thread" { return iw6::parser::make_THREAD(ctx->loc); }
"childthread" { return iw6::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return iw6::parser::make_THISTHREAD(ctx->loc); }
"call" { return iw6::parser::make_CALL(ctx->loc); }
"true" { return iw6::parser::make_TRUE(ctx->loc); }
"false" { return iw6::parser::make_FALSE(ctx->loc); }
"undefined" { return iw6::parser::make_UNDEFINED(ctx->loc); }
".size" { return iw6::parser::make_SIZE(ctx->loc); }
"game" { return iw6::parser::make_GAME(ctx->loc); }
"self" { return iw6::parser::make_SELF(ctx->loc); }
"anim" { return iw6::parser::make_ANIM(ctx->loc); }
"level" { return iw6::parser::make_LEVEL(ctx->loc); }
\( { return iw6::parser::make_LPAREN(ctx->loc); }
\) { return iw6::parser::make_RPAREN(ctx->loc); }
\{ { return iw6::parser::make_LBRACE(ctx->loc); }
\} { return iw6::parser::make_RBRACE(ctx->loc); }
\[ { return iw6::parser::make_LBRACKET(ctx->loc); }
\] { return iw6::parser::make_RBRACKET(ctx->loc); }
\, { return iw6::parser::make_COMMA(ctx->loc); }
\. { return iw6::parser::make_DOT(ctx->loc); }
\:\: { return iw6::parser::make_DOUBLECOLON(ctx->loc); }
\: { return iw6::parser::make_COLON(ctx->loc); }
\; { return iw6::parser::make_SEMICOLON(ctx->loc); }
\? { return iw6::parser::make_QMARK(ctx->loc); }
\+\+ { return iw6::parser::make_INCREMENT(ctx->loc); }
\-\- { return iw6::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return iw6::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return iw6::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return iw6::parser::make_LSHIFT(ctx->loc); }
\>\> { return iw6::parser::make_RSHIFT(ctx->loc); }
\|\| { return iw6::parser::make_OR(ctx->loc); }
\&\& { return iw6::parser::make_AND(ctx->loc); }
\=\= { return iw6::parser::make_EQUALITY(ctx->loc); }
\!\= { return iw6::parser::make_INEQUALITY(ctx->loc); }
\<\= { return iw6::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return iw6::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return iw6::parser::make_LESS(ctx->loc); }
\> { return iw6::parser::make_GREATER(ctx->loc); }
\+\= { return iw6::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return iw6::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return iw6::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return iw6::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return iw6::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return iw6::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return iw6::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return iw6::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return iw6::parser::make_ASSIGN(ctx->loc); }
\+ { return iw6::parser::make_ADD(ctx->loc); }
\- { return iw6::parser::make_SUB(ctx->loc); }
\* { return iw6::parser::make_MUL(ctx->loc); }
\/ { return iw6::parser::make_DIV(ctx->loc); }
\% { return iw6::parser::make_MOD(ctx->loc); }
\! { return iw6::parser::make_NOT(ctx->loc); }
\~ { return iw6::parser::make_COMPLEMENT(ctx->loc); }
\| { return iw6::parser::make_BITWISE_OR(ctx->loc); }
\& { return iw6::parser::make_BITWISE_AND(ctx->loc); }
\^ { return iw6::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return iw6::parser::make_PATH(xsk::gsc::iw6::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return iw6::parser::make_IDENTIFIER(xsk::gsc::iw6::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return iw6::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return iw6::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return iw6::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return iw6::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return iw6::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return iw6::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return iw6::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return iw6::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return iw6::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) iw6_pop_header(ctx); else return iw6::parser::make_IW6EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw iw6::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void iw6_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void iw6_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/iw6/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::iw6::lexer& lexer }
%parse-param { xsk::gsc::iw6::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "iw6.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::iw6::parser::symbol_type IW6lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::iw6 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::iw6::parser::symbol_type IW6lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::iw6::parser::symbol_type IW6lex(xsk::gsc::iw6::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -266,7 +260,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { iw6_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -284,7 +278,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -294,7 +288,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/iw7/Makefile
View File

@ -3,10 +3,7 @@ generate: IW7
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
IW7: lexer.lpp parser.ypp
flex lexer.lpp
IW7: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/iw7/xsk/
mv parser.hpp parser.cpp ../../src/iw7/xsk/

239
gen/iw7/lexer.lpp
View File

@ -1,239 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="iw7_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "iw7.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void iw7_push_header(xsk::gsc::context* ctx, const std::string& file);
void iw7_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw iw7::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw iw7::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw iw7::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return iw7::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw iw7::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return iw7::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw iw7::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw iw7::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return iw7::parser::make_INLINE(ctx->loc); }
"#include" { return iw7::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return iw7::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return iw7::parser::make_ANIMTREE(ctx->loc); }
"endon" { return iw7::parser::make_ENDON(ctx->loc); }
"notify" { return iw7::parser::make_NOTIFY(ctx->loc); }
"wait" { return iw7::parser::make_WAIT(ctx->loc); }
"waittill" { return iw7::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return iw7::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return iw7::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"if" { return iw7::parser::make_IF(ctx->loc); }
"else" { return iw7::parser::make_ELSE(ctx->loc); }
"do" { return iw7::parser::make_DO(ctx->loc); }
"while" { return iw7::parser::make_WHILE(ctx->loc); }
"for" { return iw7::parser::make_FOR(ctx->loc); }
"foreach" { return iw7::parser::make_FOREACH(ctx->loc); }
"in" { return iw7::parser::make_IN(ctx->loc); }
"switch" { return iw7::parser::make_SWITCH(ctx->loc); }
"case" { return iw7::parser::make_CASE(ctx->loc); }
"default" { return iw7::parser::make_DEFAULT(ctx->loc); }
"break" { return iw7::parser::make_BREAK(ctx->loc); }
"continue" { return iw7::parser::make_CONTINUE(ctx->loc); }
"return" { return iw7::parser::make_RETURN(ctx->loc); }
"breakpoint" { return iw7::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return iw7::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return iw7::parser::make_PROFEND(ctx->loc); }
"thread" { return iw7::parser::make_THREAD(ctx->loc); }
"childthread" { return iw7::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return iw7::parser::make_THISTHREAD(ctx->loc); }
"call" { return iw7::parser::make_CALL(ctx->loc); }
"true" { return iw7::parser::make_TRUE(ctx->loc); }
"false" { return iw7::parser::make_FALSE(ctx->loc); }
"undefined" { return iw7::parser::make_UNDEFINED(ctx->loc); }
".size" { return iw7::parser::make_SIZE(ctx->loc); }
"game" { return iw7::parser::make_GAME(ctx->loc); }
"self" { return iw7::parser::make_SELF(ctx->loc); }
"anim" { return iw7::parser::make_ANIM(ctx->loc); }
"level" { return iw7::parser::make_LEVEL(ctx->loc); }
\( { return iw7::parser::make_LPAREN(ctx->loc); }
\) { return iw7::parser::make_RPAREN(ctx->loc); }
\{ { return iw7::parser::make_LBRACE(ctx->loc); }
\} { return iw7::parser::make_RBRACE(ctx->loc); }
\[ { return iw7::parser::make_LBRACKET(ctx->loc); }
\] { return iw7::parser::make_RBRACKET(ctx->loc); }
\, { return iw7::parser::make_COMMA(ctx->loc); }
\. { return iw7::parser::make_DOT(ctx->loc); }
\:\: { return iw7::parser::make_DOUBLECOLON(ctx->loc); }
\: { return iw7::parser::make_COLON(ctx->loc); }
\; { return iw7::parser::make_SEMICOLON(ctx->loc); }
\? { return iw7::parser::make_QMARK(ctx->loc); }
\+\+ { return iw7::parser::make_INCREMENT(ctx->loc); }
\-\- { return iw7::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return iw7::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return iw7::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return iw7::parser::make_LSHIFT(ctx->loc); }
\>\> { return iw7::parser::make_RSHIFT(ctx->loc); }
\|\| { return iw7::parser::make_OR(ctx->loc); }
\&\& { return iw7::parser::make_AND(ctx->loc); }
\=\= { return iw7::parser::make_EQUALITY(ctx->loc); }
\!\= { return iw7::parser::make_INEQUALITY(ctx->loc); }
\<\= { return iw7::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return iw7::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return iw7::parser::make_LESS(ctx->loc); }
\> { return iw7::parser::make_GREATER(ctx->loc); }
\+\= { return iw7::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return iw7::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return iw7::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return iw7::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return iw7::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return iw7::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return iw7::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return iw7::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return iw7::parser::make_ASSIGN(ctx->loc); }
\+ { return iw7::parser::make_ADD(ctx->loc); }
\- { return iw7::parser::make_SUB(ctx->loc); }
\* { return iw7::parser::make_MUL(ctx->loc); }
\/ { return iw7::parser::make_DIV(ctx->loc); }
\% { return iw7::parser::make_MOD(ctx->loc); }
\! { return iw7::parser::make_NOT(ctx->loc); }
\~ { return iw7::parser::make_COMPLEMENT(ctx->loc); }
\| { return iw7::parser::make_BITWISE_OR(ctx->loc); }
\& { return iw7::parser::make_BITWISE_AND(ctx->loc); }
\^ { return iw7::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return iw7::parser::make_PATH(xsk::gsc::iw7::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return iw7::parser::make_IDENTIFIER(xsk::gsc::iw7::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return iw7::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return iw7::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return iw7::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return iw7::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return iw7::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return iw7::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return iw7::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return iw7::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return iw7::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) iw7_pop_header(ctx); else return iw7::parser::make_IW7EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw iw7::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void iw7_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void iw7_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/iw7/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::iw7::lexer& lexer }
%parse-param { xsk::gsc::iw7::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "iw7.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::iw7::parser::symbol_type IW7lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::iw7 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::iw7::parser::symbol_type IW7lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::iw7::parser::symbol_type IW7lex(xsk::gsc::iw7::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -266,7 +260,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { iw7_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -284,7 +278,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -294,7 +288,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/iw8/Makefile
View File

@ -3,10 +3,7 @@ generate: IW8
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
IW8: lexer.lpp parser.ypp
flex lexer.lpp
IW8: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/iw8/xsk/
mv parser.hpp parser.cpp ../../src/iw8/xsk/

242
gen/iw8/lexer.lpp
View File

@ -1,242 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="iw8_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "iw8.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void iw8_push_header(xsk::gsc::context* ctx, const std::string& file);
void iw8_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw iw8::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw iw8::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw iw8::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return iw8::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw iw8::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return iw8::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw iw8::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw iw8::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return iw8::parser::make_INLINE(ctx->loc); }
"#include" { return iw8::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return iw8::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return iw8::parser::make_ANIMTREE(ctx->loc); }
"endon" { return iw8::parser::make_ENDON(ctx->loc); }
"notify" { return iw8::parser::make_NOTIFY(ctx->loc); }
"wait" { return iw8::parser::make_WAIT(ctx->loc); }
"waittill" { return iw8::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return iw8::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return iw8::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"waitframe" { return iw8::parser::make_WAITFRAME(ctx->loc); }
"if" { return iw8::parser::make_IF(ctx->loc); }
"else" { return iw8::parser::make_ELSE(ctx->loc); }
"do" { return iw8::parser::make_DO(ctx->loc); }
"while" { return iw8::parser::make_WHILE(ctx->loc); }
"for" { return iw8::parser::make_FOR(ctx->loc); }
"foreach" { return iw8::parser::make_FOREACH(ctx->loc); }
"in" { return iw8::parser::make_IN(ctx->loc); }
"switch" { return iw8::parser::make_SWITCH(ctx->loc); }
"case" { return iw8::parser::make_CASE(ctx->loc); }
"default" { return iw8::parser::make_DEFAULT(ctx->loc); }
"break" { return iw8::parser::make_BREAK(ctx->loc); }
"continue" { return iw8::parser::make_CONTINUE(ctx->loc); }
"return" { return iw8::parser::make_RETURN(ctx->loc); }
"breakpoint" { return iw8::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return iw8::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return iw8::parser::make_PROFEND(ctx->loc); }
"thread" { return iw8::parser::make_THREAD(ctx->loc); }
"childthread" { return iw8::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return iw8::parser::make_THISTHREAD(ctx->loc); }
"call" { return iw8::parser::make_CALL(ctx->loc); }
"true" { return iw8::parser::make_TRUE(ctx->loc); }
"false" { return iw8::parser::make_FALSE(ctx->loc); }
"undefined" { return iw8::parser::make_UNDEFINED(ctx->loc); }
".size" { return iw8::parser::make_SIZE(ctx->loc); }
"game" { return iw8::parser::make_GAME(ctx->loc); }
"self" { return iw8::parser::make_SELF(ctx->loc); }
"anim" { return iw8::parser::make_ANIM(ctx->loc); }
"level" { return iw8::parser::make_LEVEL(ctx->loc); }
(?i:isdefined) { return iw8::parser::make_ISDEFINED(ctx->loc); }
(?i:istrue) { return iw8::parser::make_ISTRUE(ctx->loc); }
\( { return iw8::parser::make_LPAREN(ctx->loc); }
\) { return iw8::parser::make_RPAREN(ctx->loc); }
\{ { return iw8::parser::make_LBRACE(ctx->loc); }
\} { return iw8::parser::make_RBRACE(ctx->loc); }
\[ { return iw8::parser::make_LBRACKET(ctx->loc); }
\] { return iw8::parser::make_RBRACKET(ctx->loc); }
\, { return iw8::parser::make_COMMA(ctx->loc); }
\. { return iw8::parser::make_DOT(ctx->loc); }
\:\: { return iw8::parser::make_DOUBLECOLON(ctx->loc); }
\: { return iw8::parser::make_COLON(ctx->loc); }
\; { return iw8::parser::make_SEMICOLON(ctx->loc); }
\? { return iw8::parser::make_QMARK(ctx->loc); }
\+\+ { return iw8::parser::make_INCREMENT(ctx->loc); }
\-\- { return iw8::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return iw8::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return iw8::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return iw8::parser::make_LSHIFT(ctx->loc); }
\>\> { return iw8::parser::make_RSHIFT(ctx->loc); }
\|\| { return iw8::parser::make_OR(ctx->loc); }
\&\& { return iw8::parser::make_AND(ctx->loc); }
\=\= { return iw8::parser::make_EQUALITY(ctx->loc); }
\!\= { return iw8::parser::make_INEQUALITY(ctx->loc); }
\<\= { return iw8::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return iw8::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return iw8::parser::make_LESS(ctx->loc); }
\> { return iw8::parser::make_GREATER(ctx->loc); }
\+\= { return iw8::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return iw8::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return iw8::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return iw8::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return iw8::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return iw8::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return iw8::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return iw8::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return iw8::parser::make_ASSIGN(ctx->loc); }
\+ { return iw8::parser::make_ADD(ctx->loc); }
\- { return iw8::parser::make_SUB(ctx->loc); }
\* { return iw8::parser::make_MUL(ctx->loc); }
\/ { return iw8::parser::make_DIV(ctx->loc); }
\% { return iw8::parser::make_MOD(ctx->loc); }
\! { return iw8::parser::make_NOT(ctx->loc); }
\~ { return iw8::parser::make_COMPLEMENT(ctx->loc); }
\| { return iw8::parser::make_BITWISE_OR(ctx->loc); }
\& { return iw8::parser::make_BITWISE_AND(ctx->loc); }
\^ { return iw8::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return iw8::parser::make_PATH(xsk::gsc::iw8::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return iw8::parser::make_IDENTIFIER(xsk::gsc::iw8::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return iw8::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return iw8::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return iw8::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return iw8::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return iw8::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return iw8::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return iw8::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return iw8::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return iw8::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) iw8_pop_header(ctx); else return iw8::parser::make_IW8EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw iw8::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void iw8_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void iw8_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/iw8/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::iw8::lexer& lexer }
%parse-param { xsk::gsc::iw8::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "iw8.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::iw8::parser::symbol_type IW8lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::iw8 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::iw8::parser::symbol_type IW8lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::iw8::parser::symbol_type IW8lex(xsk::gsc::iw8::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -272,7 +266,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { iw8_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -290,7 +284,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -300,7 +294,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/s1/Makefile
View File

@ -3,10 +3,7 @@ generate: S1
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
S1: lexer.lpp parser.ypp
flex lexer.lpp
S1: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/s1/xsk/
mv parser.hpp parser.cpp ../../src/s1/xsk/

240
gen/s1/lexer.lpp
View File

@ -1,240 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="s1_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "s1.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void s1_push_header(xsk::gsc::context* ctx, const std::string& file);
void s1_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw s1::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw s1::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw s1::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return s1::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw s1::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return s1::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw s1::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw s1::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return s1::parser::make_INLINE(ctx->loc); }
"#include" { return s1::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return s1::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return s1::parser::make_ANIMTREE(ctx->loc); }
"endon" { return s1::parser::make_ENDON(ctx->loc); }
"notify" { return s1::parser::make_NOTIFY(ctx->loc); }
"wait" { return s1::parser::make_WAIT(ctx->loc); }
"waittill" { return s1::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return s1::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return s1::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"waitframe" { return s1::parser::make_WAITFRAME(ctx->loc); }
"if" { return s1::parser::make_IF(ctx->loc); }
"else" { return s1::parser::make_ELSE(ctx->loc); }
"do" { return s1::parser::make_DO(ctx->loc); }
"while" { return s1::parser::make_WHILE(ctx->loc); }
"for" { return s1::parser::make_FOR(ctx->loc); }
"foreach" { return s1::parser::make_FOREACH(ctx->loc); }
"in" { return s1::parser::make_IN(ctx->loc); }
"switch" { return s1::parser::make_SWITCH(ctx->loc); }
"case" { return s1::parser::make_CASE(ctx->loc); }
"default" { return s1::parser::make_DEFAULT(ctx->loc); }
"break" { return s1::parser::make_BREAK(ctx->loc); }
"continue" { return s1::parser::make_CONTINUE(ctx->loc); }
"return" { return s1::parser::make_RETURN(ctx->loc); }
"breakpoint" { return s1::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return s1::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return s1::parser::make_PROFEND(ctx->loc); }
"thread" { return s1::parser::make_THREAD(ctx->loc); }
"childthread" { return s1::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return s1::parser::make_THISTHREAD(ctx->loc); }
"call" { return s1::parser::make_CALL(ctx->loc); }
"true" { return s1::parser::make_TRUE(ctx->loc); }
"false" { return s1::parser::make_FALSE(ctx->loc); }
"undefined" { return s1::parser::make_UNDEFINED(ctx->loc); }
".size" { return s1::parser::make_SIZE(ctx->loc); }
"game" { return s1::parser::make_GAME(ctx->loc); }
"self" { return s1::parser::make_SELF(ctx->loc); }
"anim" { return s1::parser::make_ANIM(ctx->loc); }
"level" { return s1::parser::make_LEVEL(ctx->loc); }
\( { return s1::parser::make_LPAREN(ctx->loc); }
\) { return s1::parser::make_RPAREN(ctx->loc); }
\{ { return s1::parser::make_LBRACE(ctx->loc); }
\} { return s1::parser::make_RBRACE(ctx->loc); }
\[ { return s1::parser::make_LBRACKET(ctx->loc); }
\] { return s1::parser::make_RBRACKET(ctx->loc); }
\, { return s1::parser::make_COMMA(ctx->loc); }
\. { return s1::parser::make_DOT(ctx->loc); }
\:\: { return s1::parser::make_DOUBLECOLON(ctx->loc); }
\: { return s1::parser::make_COLON(ctx->loc); }
\; { return s1::parser::make_SEMICOLON(ctx->loc); }
\? { return s1::parser::make_QMARK(ctx->loc); }
\+\+ { return s1::parser::make_INCREMENT(ctx->loc); }
\-\- { return s1::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return s1::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return s1::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return s1::parser::make_LSHIFT(ctx->loc); }
\>\> { return s1::parser::make_RSHIFT(ctx->loc); }
\|\| { return s1::parser::make_OR(ctx->loc); }
\&\& { return s1::parser::make_AND(ctx->loc); }
\=\= { return s1::parser::make_EQUALITY(ctx->loc); }
\!\= { return s1::parser::make_INEQUALITY(ctx->loc); }
\<\= { return s1::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return s1::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return s1::parser::make_LESS(ctx->loc); }
\> { return s1::parser::make_GREATER(ctx->loc); }
\+\= { return s1::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return s1::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return s1::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return s1::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return s1::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return s1::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return s1::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return s1::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return s1::parser::make_ASSIGN(ctx->loc); }
\+ { return s1::parser::make_ADD(ctx->loc); }
\- { return s1::parser::make_SUB(ctx->loc); }
\* { return s1::parser::make_MUL(ctx->loc); }
\/ { return s1::parser::make_DIV(ctx->loc); }
\% { return s1::parser::make_MOD(ctx->loc); }
\! { return s1::parser::make_NOT(ctx->loc); }
\~ { return s1::parser::make_COMPLEMENT(ctx->loc); }
\| { return s1::parser::make_BITWISE_OR(ctx->loc); }
\& { return s1::parser::make_BITWISE_AND(ctx->loc); }
\^ { return s1::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return s1::parser::make_PATH(xsk::gsc::s1::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return s1::parser::make_IDENTIFIER(xsk::gsc::s1::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return s1::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return s1::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return s1::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return s1::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return s1::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return s1::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return s1::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return s1::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return s1::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) s1_pop_header(ctx); else return s1::parser::make_S1EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw s1::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void s1_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void s1_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/s1/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::s1::lexer& lexer }
%parse-param { xsk::gsc::s1::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "s1.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::s1::parser::symbol_type S1lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::s1 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::s1::parser::symbol_type S1lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::s1::parser::symbol_type S1lex(xsk::gsc::s1::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -268,7 +262,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { s1_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -286,7 +280,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -296,7 +290,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/s2/Makefile
View File

@ -3,10 +3,7 @@ generate: S2
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
S2: lexer.lpp parser.ypp
flex lexer.lpp
S2: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/s2/xsk/
mv parser.hpp parser.cpp ../../src/s2/xsk/

240
gen/s2/lexer.lpp
View File

@ -1,240 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="s2_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "s2.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void s2_push_header(xsk::gsc::context* ctx, const std::string& file);
void s2_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw s2::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw s2::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw s2::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return s2::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw s2::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return s2::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw s2::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw s2::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return s2::parser::make_INLINE(ctx->loc); }
"#include" { return s2::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return s2::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return s2::parser::make_ANIMTREE(ctx->loc); }
"endon" { return s2::parser::make_ENDON(ctx->loc); }
"notify" { return s2::parser::make_NOTIFY(ctx->loc); }
"wait" { return s2::parser::make_WAIT(ctx->loc); }
"waittill" { return s2::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return s2::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return s2::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"waitframe" { return s2::parser::make_WAITFRAME(ctx->loc); }
"if" { return s2::parser::make_IF(ctx->loc); }
"else" { return s2::parser::make_ELSE(ctx->loc); }
"do" { return s2::parser::make_DO(ctx->loc); }
"while" { return s2::parser::make_WHILE(ctx->loc); }
"for" { return s2::parser::make_FOR(ctx->loc); }
"foreach" { return s2::parser::make_FOREACH(ctx->loc); }
"in" { return s2::parser::make_IN(ctx->loc); }
"switch" { return s2::parser::make_SWITCH(ctx->loc); }
"case" { return s2::parser::make_CASE(ctx->loc); }
"default" { return s2::parser::make_DEFAULT(ctx->loc); }
"break" { return s2::parser::make_BREAK(ctx->loc); }
"continue" { return s2::parser::make_CONTINUE(ctx->loc); }
"return" { return s2::parser::make_RETURN(ctx->loc); }
"breakpoint" { return s2::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return s2::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return s2::parser::make_PROFEND(ctx->loc); }
"thread" { return s2::parser::make_THREAD(ctx->loc); }
"childthread" { return s2::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return s2::parser::make_THISTHREAD(ctx->loc); }
"call" { return s2::parser::make_CALL(ctx->loc); }
"true" { return s2::parser::make_TRUE(ctx->loc); }
"false" { return s2::parser::make_FALSE(ctx->loc); }
"undefined" { return s2::parser::make_UNDEFINED(ctx->loc); }
".size" { return s2::parser::make_SIZE(ctx->loc); }
"game" { return s2::parser::make_GAME(ctx->loc); }
"self" { return s2::parser::make_SELF(ctx->loc); }
"anim" { return s2::parser::make_ANIM(ctx->loc); }
"level" { return s2::parser::make_LEVEL(ctx->loc); }
\( { return s2::parser::make_LPAREN(ctx->loc); }
\) { return s2::parser::make_RPAREN(ctx->loc); }
\{ { return s2::parser::make_LBRACE(ctx->loc); }
\} { return s2::parser::make_RBRACE(ctx->loc); }
\[ { return s2::parser::make_LBRACKET(ctx->loc); }
\] { return s2::parser::make_RBRACKET(ctx->loc); }
\, { return s2::parser::make_COMMA(ctx->loc); }
\. { return s2::parser::make_DOT(ctx->loc); }
\:\: { return s2::parser::make_DOUBLECOLON(ctx->loc); }
\: { return s2::parser::make_COLON(ctx->loc); }
\; { return s2::parser::make_SEMICOLON(ctx->loc); }
\? { return s2::parser::make_QMARK(ctx->loc); }
\+\+ { return s2::parser::make_INCREMENT(ctx->loc); }
\-\- { return s2::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return s2::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return s2::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return s2::parser::make_LSHIFT(ctx->loc); }
\>\> { return s2::parser::make_RSHIFT(ctx->loc); }
\|\| { return s2::parser::make_OR(ctx->loc); }
\&\& { return s2::parser::make_AND(ctx->loc); }
\=\= { return s2::parser::make_EQUALITY(ctx->loc); }
\!\= { return s2::parser::make_INEQUALITY(ctx->loc); }
\<\= { return s2::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return s2::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return s2::parser::make_LESS(ctx->loc); }
\> { return s2::parser::make_GREATER(ctx->loc); }
\+\= { return s2::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return s2::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return s2::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return s2::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return s2::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return s2::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return s2::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return s2::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return s2::parser::make_ASSIGN(ctx->loc); }
\+ { return s2::parser::make_ADD(ctx->loc); }
\- { return s2::parser::make_SUB(ctx->loc); }
\* { return s2::parser::make_MUL(ctx->loc); }
\/ { return s2::parser::make_DIV(ctx->loc); }
\% { return s2::parser::make_MOD(ctx->loc); }
\! { return s2::parser::make_NOT(ctx->loc); }
\~ { return s2::parser::make_COMPLEMENT(ctx->loc); }
\| { return s2::parser::make_BITWISE_OR(ctx->loc); }
\& { return s2::parser::make_BITWISE_AND(ctx->loc); }
\^ { return s2::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return s2::parser::make_PATH(xsk::gsc::s2::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return s2::parser::make_IDENTIFIER(xsk::gsc::s2::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return s2::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return s2::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return s2::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return s2::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return s2::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return s2::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return s2::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return s2::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return s2::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) s2_pop_header(ctx); else return s2::parser::make_S2EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw s2::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void s2_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void s2_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/s2/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::s2::lexer& lexer }
%parse-param { xsk::gsc::s2::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "s2.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::s2::parser::symbol_type S2lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::s2 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::s2::parser::symbol_type S2lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::s2::parser::symbol_type S2lex(xsk::gsc::s2::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -268,7 +262,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { s2_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -286,7 +280,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -296,7 +290,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

7
gen/s4/Makefile
View File

@ -3,10 +3,7 @@ generate: S4
clean:
rm -rf ./parser.hpp
rm -rf ./parser.cpp
rm -rf ./lexer.hpp
rm -rf ./lexer.cpp
S4: lexer.lpp parser.ypp
flex lexer.lpp
S4: parser.ypp
bison parser.ypp -Wcounterexamples
mv lexer.hpp lexer.cpp parser.hpp parser.cpp ../../src/s4/xsk/
mv parser.hpp parser.cpp ../../src/s4/xsk/

242
gen/s4/lexer.lpp
View File

@ -1,242 +0,0 @@
/* Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
*/
%option outfile="lexer.cpp"
%option header-file="lexer.hpp"
%option prefix="s4_"
%option reentrant
%option noyywrap batch nounput noinput
%option never-interactive
%option nounistd
%top{
#include "stdafx.hpp"
#include "s4.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void s4_push_header(xsk::gsc::context* ctx, const std::string& file);
void s4_pop_header(xsk::gsc::context* ctx);
}
%{
#define YY_USER_ACTION ctx->loc.columns(yyleng);
%}
RGX_PATH ([_A-Za-z0-9]+\\)+[_A-Za-z0-9]+
RGX_IDENTIFIER [_A-Za-z][_A-Za-z0-9]*
RGX_STRING \"(?:\\.|[^\"])*?\"|\'(?:\\.|[^\'])*?\'
RGX_COLOR_S #[0-9a-fA-F]{3}
RGX_COLOR_L #[0-9a-fA-F]{6}
RGX_FLT_DEC [0-9]+\.(?:[0-9]*)?f?|\.[0-9]+f?
RGX_INT_OCT 0[1-7][0-7]*
RGX_INT_BIN 0[bB][01]+
RGX_INT_HEX 0[xX][0-9a-fA-F]+
RGX_INT_DEC [0-9]+
RGX_DEFAULT (.|\n)
%x COMMENT_STATE
%x DEV_OFF_STATE
%s DEV_ON_STATE
%%
%{
ctx->loc.step();
%}
[ \t\r] { ctx->loc.step(); }
\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
"//".*
"/*" { BEGIN(COMMENT_STATE); }
<COMMENT_STATE>.
<COMMENT_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<COMMENT_STATE>"*/" { BEGIN(INITIAL); }
<COMMENT_STATE><<EOF>> { throw s4::parser::syntax_error(ctx->loc, "unmatched multiline comment start ('/*')"); }
<INITIAL>"*/" { throw s4::parser::syntax_error(ctx->loc, "unmatched multiline comment end ('*/')"); }
<DEV_ON_STATE>"/#" { throw s4::parser::syntax_error(ctx->loc, "cannot recurse devblock ('/#')"); }
<DEV_ON_STATE>"#/" { BEGIN(INITIAL); return s4::parser::make_DEVEND(ctx->loc); }
<DEV_ON_STATE><<EOF>> { throw s4::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
"/#" { BEGIN(ctx->mode == xsk::gsc::build::dev ? DEV_ON_STATE : DEV_OFF_STATE); if(ctx->mode == xsk::gsc::build::dev) return s4::parser::make_DEVBEGIN(ctx->loc); }
<DEV_OFF_STATE>.
<DEV_OFF_STATE>\n { ctx->loc.lines(yyleng); ctx->loc.step(); }
<DEV_OFF_STATE>"#/" { BEGIN(INITIAL); }
<DEV_OFF_STATE><<EOF>> { throw s4::parser::syntax_error(ctx->loc, "unmatched devblock start ('/#')"); }
<INITIAL>"#/" { throw s4::parser::syntax_error(ctx->loc, "unmatched devblock end ('#/')"); }
"#inline" { return s4::parser::make_INLINE(ctx->loc); }
"#include" { return s4::parser::make_INCLUDE(ctx->loc); }
"#using_animtree" { return s4::parser::make_USINGTREE(ctx->loc); }
"#animtree" { return s4::parser::make_ANIMTREE(ctx->loc); }
"endon" { return s4::parser::make_ENDON(ctx->loc); }
"notify" { return s4::parser::make_NOTIFY(ctx->loc); }
"wait" { return s4::parser::make_WAIT(ctx->loc); }
"waittill" { return s4::parser::make_WAITTILL(ctx->loc); }
"waittillmatch" { return s4::parser::make_WAITTILLMATCH(ctx->loc); }
"waittillframeend" { return s4::parser::make_WAITTILLFRAMEEND(ctx->loc); }
"waitframe" { return s4::parser::make_WAITFRAME(ctx->loc); }
"if" { return s4::parser::make_IF(ctx->loc); }
"else" { return s4::parser::make_ELSE(ctx->loc); }
"do" { return s4::parser::make_DO(ctx->loc); }
"while" { return s4::parser::make_WHILE(ctx->loc); }
"for" { return s4::parser::make_FOR(ctx->loc); }
"foreach" { return s4::parser::make_FOREACH(ctx->loc); }
"in" { return s4::parser::make_IN(ctx->loc); }
"switch" { return s4::parser::make_SWITCH(ctx->loc); }
"case" { return s4::parser::make_CASE(ctx->loc); }
"default" { return s4::parser::make_DEFAULT(ctx->loc); }
"break" { return s4::parser::make_BREAK(ctx->loc); }
"continue" { return s4::parser::make_CONTINUE(ctx->loc); }
"return" { return s4::parser::make_RETURN(ctx->loc); }
"breakpoint" { return s4::parser::make_BREAKPOINT(ctx->loc); }
"prof_begin" { return s4::parser::make_PROFBEGIN(ctx->loc); }
"prof_end" { return s4::parser::make_PROFEND(ctx->loc); }
"thread" { return s4::parser::make_THREAD(ctx->loc); }
"childthread" { return s4::parser::make_CHILDTHREAD(ctx->loc); }
"thisthread" { return s4::parser::make_THISTHREAD(ctx->loc); }
"call" { return s4::parser::make_CALL(ctx->loc); }
"true" { return s4::parser::make_TRUE(ctx->loc); }
"false" { return s4::parser::make_FALSE(ctx->loc); }
"undefined" { return s4::parser::make_UNDEFINED(ctx->loc); }
".size" { return s4::parser::make_SIZE(ctx->loc); }
"game" { return s4::parser::make_GAME(ctx->loc); }
"self" { return s4::parser::make_SELF(ctx->loc); }
"anim" { return s4::parser::make_ANIM(ctx->loc); }
"level" { return s4::parser::make_LEVEL(ctx->loc); }
(?i:isdefined) { return s4::parser::make_ISDEFINED(ctx->loc); }
(?i:istrue) { return s4::parser::make_ISTRUE(ctx->loc); }
\( { return s4::parser::make_LPAREN(ctx->loc); }
\) { return s4::parser::make_RPAREN(ctx->loc); }
\{ { return s4::parser::make_LBRACE(ctx->loc); }
\} { return s4::parser::make_RBRACE(ctx->loc); }
\[ { return s4::parser::make_LBRACKET(ctx->loc); }
\] { return s4::parser::make_RBRACKET(ctx->loc); }
\, { return s4::parser::make_COMMA(ctx->loc); }
\. { return s4::parser::make_DOT(ctx->loc); }
\:\: { return s4::parser::make_DOUBLECOLON(ctx->loc); }
\: { return s4::parser::make_COLON(ctx->loc); }
\; { return s4::parser::make_SEMICOLON(ctx->loc); }
\? { return s4::parser::make_QMARK(ctx->loc); }
\+\+ { return s4::parser::make_INCREMENT(ctx->loc); }
\-\- { return s4::parser::make_DECREMENT(ctx->loc); }
\<\<\= { return s4::parser::make_ASSIGN_LSHIFT(ctx->loc); }
\>\>\= { return s4::parser::make_ASSIGN_RSHIFT(ctx->loc); }
\<\< { return s4::parser::make_LSHIFT(ctx->loc); }
\>\> { return s4::parser::make_RSHIFT(ctx->loc); }
\|\| { return s4::parser::make_OR(ctx->loc); }
\&\& { return s4::parser::make_AND(ctx->loc); }
\=\= { return s4::parser::make_EQUALITY(ctx->loc); }
\!\= { return s4::parser::make_INEQUALITY(ctx->loc); }
\<\= { return s4::parser::make_LESS_EQUAL(ctx->loc); }
\>\= { return s4::parser::make_GREATER_EQUAL(ctx->loc); }
\< { return s4::parser::make_LESS(ctx->loc); }
\> { return s4::parser::make_GREATER(ctx->loc); }
\+\= { return s4::parser::make_ASSIGN_ADD(ctx->loc); }
\-\= { return s4::parser::make_ASSIGN_SUB(ctx->loc); }
\*\= { return s4::parser::make_ASSIGN_MUL(ctx->loc); }
\/\= { return s4::parser::make_ASSIGN_DIV(ctx->loc); }
\%\= { return s4::parser::make_ASSIGN_MOD(ctx->loc); }
\|\= { return s4::parser::make_ASSIGN_BW_OR(ctx->loc); }
\&\= { return s4::parser::make_ASSIGN_BW_AND(ctx->loc); }
\^\= { return s4::parser::make_ASSIGN_BW_EXOR(ctx->loc); }
\= { return s4::parser::make_ASSIGN(ctx->loc); }
\+ { return s4::parser::make_ADD(ctx->loc); }
\- { return s4::parser::make_SUB(ctx->loc); }
\* { return s4::parser::make_MUL(ctx->loc); }
\/ { return s4::parser::make_DIV(ctx->loc); }
\% { return s4::parser::make_MOD(ctx->loc); }
\! { return s4::parser::make_NOT(ctx->loc); }
\~ { return s4::parser::make_COMPLEMENT(ctx->loc); }
\| { return s4::parser::make_BITWISE_OR(ctx->loc); }
\& { return s4::parser::make_BITWISE_AND(ctx->loc); }
\^ { return s4::parser::make_BITWISE_EXOR(ctx->loc); }
{RGX_PATH} { return s4::parser::make_PATH(xsk::gsc::s4::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
{RGX_IDENTIFIER} { return s4::parser::make_IDENTIFIER(xsk::gsc::s4::resolver::make_token(std::string_view(yytext, yyleng)), ctx->loc); }
\&{RGX_STRING} { return s4::parser::make_ISTRING(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_STRING} { return s4::parser::make_STRING(std::string(yytext), ctx->loc); }
{RGX_COLOR_S} { return s4::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_COLOR_L} { return s4::parser::make_COLOR(std::string(++yytext, --yyleng), ctx->loc); }
{RGX_FLT_DEC} { return s4::parser::make_FLOAT(std::string(yytext), ctx->loc); }
{RGX_INT_OCT} { return s4::parser::make_INTEGER(xsk::utils::string::oct_to_dec(yytext), ctx->loc); }
{RGX_INT_BIN} { return s4::parser::make_INTEGER(xsk::utils::string::bin_to_dec(yytext), ctx->loc); }
{RGX_INT_HEX} { return s4::parser::make_INTEGER(xsk::utils::string::hex_to_dec(yytext), ctx->loc); }
{RGX_INT_DEC} { return s4::parser::make_INTEGER(std::string(yytext), ctx->loc); }
<<EOF>> { if(ctx->header_top > 0) s4_pop_header(ctx); else return s4::parser::make_S4EOF(ctx->loc); }
<*>{RGX_DEFAULT} { throw s4::parser::syntax_error(ctx->loc, "bad token: \'" + std::string(yytext) + "\'"); }
%%
void s4_push_header(xsk::gsc::context* ctx, const std::string& file)
{
try
{
if (ctx->header_top >= 4)
{
throw xsk::gsc::error("maximum gsh depth exceeded '4'");
}
ctx->header_top++;
char* buf_data = 0;
size_t buf_size = 0;
for (auto& src : *ctx->sources)
{
if (src.name == file)
{
buf_data = reinterpret_cast<char*>(src.buf.data());
buf_size = src.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&src.name);
}
}
if (buf_data == 0)
{
ctx->sources->push_back(xsk::gsc::source());
auto& source = ctx->sources->back();
source.name = file;
source.buf = ctx->read_callback(file + ".gsh");
source.buf.push_back(0);
source.buf.push_back(0);
buf_data = reinterpret_cast<char*>(source.buf.data());
buf_size = source.buf.size();
ctx->locs.push(ctx->loc);
ctx->loc.initialize(&source.name);
}
auto state = new yy_buffer_state();
state->yy_buf_size = buf_size - 2;
state->yy_buf_pos = state->yy_ch_buf = buf_data;
state->yy_is_our_buffer = 0;
state->yy_input_file = NULL;
state->yy_n_chars = state->yy_buf_size;
state->yy_is_interactive = 0;
state->yy_at_bol = 1;
state->yy_fill_buffer = 0;
state->yy_buffer_status = 0;
yypush_buffer_state(state, ctx->scanner);
}
catch (const std::exception& e)
{
throw xsk::gsc::error("parsing header file '" + file + "': " + e.what());
}
}
void s4_pop_header(xsk::gsc::context* ctx)
{
ctx->header_top--;
ctx->loc = ctx->locs.top();
ctx->locs.pop();
yypop_buffer_state(ctx->scanner);
}

22
gen/s4/parser.ypp
View File

@ -1,4 +1,4 @@
/* Copyright 2021 xensik. All rights reserved.
/* Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,21 +19,15 @@
%define parse.trace
%define parse.error detailed
%define parse.lac full
%locations
%lex-param { yyscan_t yyscanner }
%lex-param { xsk::gsc::context* ctx }
%parse-param { yyscan_t yyscanner }
%parse-param { xsk::gsc::context* ctx }
%lex-param { xsk::gsc::s4::lexer& lexer }
%parse-param { xsk::gsc::s4::lexer& lexer }
%parse-param { xsk::gsc::ast::program::ptr& ast }
%code requires
{
#include "s4.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::s4::parser::symbol_type S4lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::s4 { class lexer; }
}
%code top
@ -42,7 +36,7 @@ typedef void *yyscan_t;
#include "parser.hpp"
#include "lexer.hpp"
using namespace xsk::gsc;
xsk::gsc::s4::parser::symbol_type S4lex(yyscan_t yyscanner, xsk::gsc::context* ctx);
xsk::gsc::s4::parser::symbol_type S4lex(xsk::gsc::s4::lexer& lexer);
}
%token DEVBEGIN "/#"
@ -272,7 +266,7 @@ program
;
inline
: INLINE expr_path SEMICOLON { s4_push_header(ctx, $2->value); }
: INLINE expr_path SEMICOLON { lexer.push_header($2->value); }
;
include
@ -290,7 +284,7 @@ declaration
decl_usingtree
: USINGTREE LPAREN expr_string RPAREN SEMICOLON
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_usingtree>(@$, std::move($3)); }
;
decl_constant
@ -300,7 +294,7 @@ decl_constant
decl_thread
: expr_identifier LPAREN expr_parameters RPAREN stmt_block
{ ctx->restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
{ lexer.restrict_header(@$); $$ = std::make_unique<ast::decl_thread>(@$, std::move($1), std::move($3), std::move($5)); }
;
stmt

2
src/experimental/iw5_console/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw5_console/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw5_console/xsk/iw5_console.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw5_console/xsk/iw5_console.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw6_console/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw6_console/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw6_console/xsk/iw6_console.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/iw6_console/xsk/iw6_console.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/s1_console/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/s1_console/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/s1_console/xsk/s1_console.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/s1_console/xsk/s1_console.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t4/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t4/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t4/xsk/t4.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t4/xsk/t4.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t5/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t5/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t5/xsk/t5.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/experimental/t5/xsk/t5.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/assembler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/assembler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

31
src/h1/xsk/compiler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,7 +19,6 @@ auto compiler::output() -> std::vector<function::ptr>
void compiler::compile(const std::string& file, std::vector<std::uint8_t>& data)
{
filename_ = file;
sources_.clear();
auto prog = parse_buffer(filename_, data);
@ -33,39 +32,19 @@ void compiler::read_callback(std::function<std::vector<std::uint8_t>(const std::
auto compiler::parse_buffer(const std::string& file, std::vector<std::uint8_t>& data) -> ast::program::ptr
{
yyscan_t scanner;
context ctx;
ast::program::ptr result(nullptr);
ctx.header_top = 0;
ctx.mode = mode_;
ctx.read_callback = read_callback_;
ctx.sources = &sources_;
ctx.loc.initialize(&file);
resolver::set_reader(read_callback_);
// Add the two NULL terminators, required by flex.
data.push_back(0);
data.push_back(0);
lexer lexer(file, reinterpret_cast<char*>(data.data()), data.size());
if (h1_lex_init(&scanner))
{
throw comp_error(ctx.loc, "An unknown error ocurred while starting lexer context.");
}
ctx.scanner = scanner;
YY_BUFFER_STATE yybuffer = h1__scan_buffer(reinterpret_cast<char*>(data.data()), data.size(), scanner);
parser parser(scanner, &ctx, result);
parser parser(lexer, result);
if (parser.parse() || result == nullptr)
{
throw comp_error(ctx.loc, "An unknown error ocurred while parsing gsc file.");
throw comp_error(xsk::gsc::location(&file), "An unknown error ocurred while parsing gsc file.");
}
h1__delete_buffer(yybuffer, scanner);
h1_lex_destroy(scanner);
return result;
}

3
src/h1/xsk/compiler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -25,7 +25,6 @@ class compiler : public gsc::compiler
std::vector<animtree_t> animtrees_;
std::unordered_map<std::string, ast::expr> constants_;
std::function<std::vector<std::uint8_t>(const std::string&)> read_callback_;
std::vector<gsc::source> sources_;
std::vector<block*> break_blks_;
std::vector<block*> continue_blks_;
bool can_break_;

2
src/h1/xsk/decompiler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/decompiler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/disassembler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/disassembler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/h1.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h1/xsk/h1.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

3934
src/h1/xsk/lexer.cpp
View File

File diff suppressed because it is too large Load Diff

754
src/h1/xsk/lexer.hpp
View File

@ -1,711 +1,79 @@
#ifndef h1_HEADER_H
#define h1_HEADER_H 1
#define h1_IN_HEADER 1
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
#pragma once
#line 5 "lexer.hpp"
#include "stdafx.hpp"
#include "h1.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void h1_push_header(xsk::gsc::context* ctx, const std::string& file);
void h1_pop_header(xsk::gsc::context* ctx);
#line 13 "lexer.hpp"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
#ifdef yy_create_buffer
#define h1__create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer h1__create_buffer
#endif
#ifdef yy_delete_buffer
#define h1__delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer h1__delete_buffer
#endif
#ifdef yy_scan_buffer
#define h1__scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer h1__scan_buffer
#endif
#ifdef yy_scan_string
#define h1__scan_string_ALREADY_DEFINED
#else
#define yy_scan_string h1__scan_string
#endif
#ifdef yy_scan_bytes
#define h1__scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes h1__scan_bytes
#endif
#ifdef yy_init_buffer
#define h1__init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer h1__init_buffer
#endif
#ifdef yy_flush_buffer
#define h1__flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer h1__flush_buffer
#endif
#ifdef yy_load_buffer_state
#define h1__load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state h1__load_buffer_state
#endif
#ifdef yy_switch_to_buffer
#define h1__switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer h1__switch_to_buffer
#endif
#ifdef yypush_buffer_state
#define h1_push_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state h1_push_buffer_state
#endif
#ifdef yypop_buffer_state
#define h1_pop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state h1_pop_buffer_state
#endif
#ifdef yyensure_buffer_stack
#define h1_ensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack h1_ensure_buffer_stack
#endif
#ifdef yylex
#define h1_lex_ALREADY_DEFINED
#else
#define yylex h1_lex
#endif
#ifdef yyrestart
#define h1_restart_ALREADY_DEFINED
#else
#define yyrestart h1_restart
#endif
#ifdef yylex_init
#define h1_lex_init_ALREADY_DEFINED
#else
#define yylex_init h1_lex_init
#endif
#ifdef yylex_init_extra
#define h1_lex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra h1_lex_init_extra
#endif
#ifdef yylex_destroy
#define h1_lex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy h1_lex_destroy
#endif
#ifdef yyget_debug
#define h1_get_debug_ALREADY_DEFINED
#else
#define yyget_debug h1_get_debug
#endif
#ifdef yyset_debug
#define h1_set_debug_ALREADY_DEFINED
#else
#define yyset_debug h1_set_debug
#endif
#ifdef yyget_extra
#define h1_get_extra_ALREADY_DEFINED
#else
#define yyget_extra h1_get_extra
#endif
#ifdef yyset_extra
#define h1_set_extra_ALREADY_DEFINED
#else
#define yyset_extra h1_set_extra
#endif
#ifdef yyget_in
#define h1_get_in_ALREADY_DEFINED
#else
#define yyget_in h1_get_in
#endif
#ifdef yyset_in
#define h1_set_in_ALREADY_DEFINED
#else
#define yyset_in h1_set_in
#endif
#ifdef yyget_out
#define h1_get_out_ALREADY_DEFINED
#else
#define yyget_out h1_get_out
#endif
#ifdef yyset_out
#define h1_set_out_ALREADY_DEFINED
#else
#define yyset_out h1_set_out
#endif
#ifdef yyget_leng
#define h1_get_leng_ALREADY_DEFINED
#else
#define yyget_leng h1_get_leng
#endif
#ifdef yyget_text
#define h1_get_text_ALREADY_DEFINED
#else
#define yyget_text h1_get_text
#endif
#ifdef yyget_lineno
#define h1_get_lineno_ALREADY_DEFINED
#else
#define yyget_lineno h1_get_lineno
#endif
#ifdef yyset_lineno
#define h1_set_lineno_ALREADY_DEFINED
#else
#define yyset_lineno h1_set_lineno
#endif
#ifdef yyget_column
#define h1_get_column_ALREADY_DEFINED
#else
#define yyget_column h1_get_column
#endif
#ifdef yyset_column
#define h1_set_column_ALREADY_DEFINED
#else
#define yyset_column h1_set_column
#endif
#ifdef yywrap
#define h1_wrap_ALREADY_DEFINED
#else
#define yywrap h1_wrap
#endif
#ifdef yyalloc
#define h1_alloc_ALREADY_DEFINED
#else
#define yyalloc h1_alloc
#endif
#ifdef yyrealloc
#define h1_realloc_ALREADY_DEFINED
#else
#define yyrealloc h1_realloc
#endif
#ifdef yyfree
#define h1_free_ALREADY_DEFINED
#else
#define yyfree h1_free
#endif
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#ifndef SIZE_MAX
#define SIZE_MAX (~(size_t)0)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
/* begin standard C++ headers. */
/* TODO: this is always defined, so inline it */
#define yyconst const
#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif
/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif
/* For convenience, these vars (plus the bison vars far below)
are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r
/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
* Ditto for the __ia64__ case accordingly.
*/
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
namespace xsk::gsc::h1
{
FILE *yy_input_file;
char *yy_ch_buf; /* input buffer */
char *yy_buf_pos; /* current position in input buffer */
enum class keyword;
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
* delete it.
*/
int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and
* if we're using stdio for input, then we want to use getc()
* instead of fread(), to make sure we stop fetching input after
* each newline.
*/
int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line.
* If so, '^' rules will be active on the next match, otherwise
* not.
*/
int yy_at_bol;
int yy_bs_lineno; /**< The line count. */
int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
int yy_fill_buffer;
int yy_buffer_status;
struct buffer
{
int size;
int length;
char* data;
buffer();
~buffer();
bool push(char c);
};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );
struct reader
{
enum states { end, ok };
YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
states state;
int bytes_remaining;
const char* buffer_pos;
char last_byte;
char current_byte;
void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );
reader();
/* Begin user sect3 */
reader& operator=(const reader& r)
{
std::memcpy(this, &r, sizeof(reader));
return *this;
}
#define h1_wrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
void init(const char* data, size_t size);
void advance();
};
#define yytext_ptr yytext_r
class lexer
{
private:
reader reader_;
buffer buffer_;
location loc_;
build mode_;
bool in_dev_state_;
std::stack<location> locs_;
std::stack<reader> readers_;
std::uint32_t header_top_;
#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0
#define COMMENT_STATE 1
#define DEV_OFF_STATE 2
#define DEV_ON_STATE 3
public:
lexer(const std::string& name, const char* data, size_t size);
auto lex() -> xsk::gsc::h1::parser::symbol_type;
void push_header(const std::string& file);
void pop_header();
void restrict_header(const xsk::gsc::location& loc);
#endif
private:
auto read_string(char quote, bool localize) -> xsk::gsc::h1::parser::symbol_type;
auto read_number(char first) -> xsk::gsc::h1::parser::symbol_type;
auto read_word(char first) -> xsk::gsc::h1::parser::symbol_type;
auto read_dotsize() -> xsk::gsc::h1::parser::symbol_type;
auto keyword_token(keyword k) -> xsk::gsc::h1::parser::symbol_type;
static auto keyword_is_token(keyword k) -> bool;
static auto get_keyword(std::string_view str) -> keyword;
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include <unistd.h>
#endif
static std::unordered_map<std::string_view, keyword> keywords;
};
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
int yylex_init (yyscan_t* scanner);
int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */
int yylex_destroy ( yyscan_t yyscanner );
int yyget_debug ( yyscan_t yyscanner );
void yyset_debug ( int debug_flag , yyscan_t yyscanner );
YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
FILE *yyget_in ( yyscan_t yyscanner );
void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
FILE *yyget_out ( yyscan_t yyscanner );
void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
int yyget_leng ( yyscan_t yyscanner );
char *yyget_text ( yyscan_t yyscanner );
int yyget_lineno ( yyscan_t yyscanner );
void yyset_lineno ( int _line_number , yyscan_t yyscanner );
int yyget_column ( yyscan_t yyscanner );
void yyset_column ( int _column_no , yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in
* section 1.
*/
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif
#ifndef YY_NO_INPUT
#endif
/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif
/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
/* Default declaration of generated scanner - a define so the user can
* easily add parameters.
*/
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
extern int yylex (yyscan_t yyscanner);
#define YY_DECL int yylex (yyscan_t yyscanner)
#endif /* !YY_DECL */
/* yy_get_previous_state - get the state just before the EOB char was reached */
#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION
#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif
#ifndef h1__create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef h1__delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef h1__scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef h1__scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef h1__scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef h1__init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef h1__flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef h1__load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef h1__switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef h1_push_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef h1_pop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef h1_ensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef h1_lex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef h1_restart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef h1_lex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef h1_lex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef h1_lex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef h1_get_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef h1_set_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef h1_get_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef h1_set_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef h1_get_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef h1_set_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef h1_get_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef h1_set_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef h1_get_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef h1_get_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef h1_get_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef h1_set_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef h1_get_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef h1_set_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef h1_wrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef h1_get_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef h1_set_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef h1_get_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef h1_set_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef h1_alloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef h1_realloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef h1_free_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef h1_text_ALREADY_DEFINED
#undef yytext
#endif
#ifndef h1_leng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef h1_in_ALREADY_DEFINED
#undef yyin
#endif
#ifndef h1_out_ALREADY_DEFINED
#undef yyout
#endif
#ifndef h1__flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef h1_lineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef h1_tables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef h1_tables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef h1_TABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif
#line 172 "lexer.lpp"
#line 709 "lexer.hpp"
#undef h1_IN_HEADER
#endif /* h1_HEADER_H */
} // namespace xsk::gsc::h1

931
src/h1/xsk/parser.cpp
View File

File diff suppressed because it is too large Load Diff

16
src/h1/xsk/parser.hpp
View File

@ -45,13 +45,12 @@
#ifndef YY_H1_PARSER_HPP_INCLUDED
# define YY_H1_PARSER_HPP_INCLUDED
// "%code requires" blocks.
#line 33 "parser.ypp"
#line 28 "parser.ypp"
#include "h1.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::h1::parser::symbol_type H1lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::h1 { class lexer; }
#line 55 "parser.hpp"
#line 54 "parser.hpp"
# include <cassert>
# include <cstdlib> // std::abort
@ -194,7 +193,7 @@ typedef void *yyscan_t;
#line 13 "parser.ypp"
namespace xsk { namespace gsc { namespace h1 {
#line 198 "parser.hpp"
#line 197 "parser.hpp"
@ -2685,7 +2684,7 @@ switch (yykind)
};
/// Build a parser object.
parser (yyscan_t yyscanner_yyarg, xsk::gsc::context* ctx_yyarg, xsk::gsc::ast::program::ptr& ast_yyarg);
parser (xsk::gsc::h1::lexer& lexer_yyarg, xsk::gsc::ast::program::ptr& ast_yyarg);
virtual ~parser ();
#if 201103L <= YY_CPLUSPLUS
@ -4656,8 +4655,7 @@ switch (yykind)
// User arguments.
yyscan_t yyscanner;
xsk::gsc::context* ctx;
xsk::gsc::h1::lexer& lexer;
xsk::gsc::ast::program::ptr& ast;
};
@ -5342,7 +5340,7 @@ switch (yykind)
#line 13 "parser.ypp"
} } } // xsk::gsc::h1
#line 5346 "parser.hpp"
#line 5344 "parser.hpp"

31
src/h1/xsk/resolver.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -206,6 +206,35 @@ auto resolver::make_token(std::string_view str) -> std::string
return data;
}
std::function<std::vector<std::uint8_t>(const std::string&)> read_callback = nullptr;
std::unordered_map<std::string, std::vector<std::uint8_t>> files;
auto resolver::file_data(const std::string& name) -> std::tuple<const std::string*, char*, size_t>
{
const auto& itr = files.find(name);
if(itr != files.end())
{
return { &itr->first ,reinterpret_cast<char*>(itr->second.data()), itr->second.size() };
}
auto data = read_callback(name);
const auto& res = files.insert({ name, std::move(data)});
if(res.second)
{
return { &res.first->first, reinterpret_cast<char*>(res.first->second.data()), res.first->second.size() };
}
throw error("couldn't open gsc file '" + name + "'");
}
void resolver::set_reader(std::function<std::vector<std::uint8_t>(const std::string&)> callback)
{
read_callback = callback;
}
const std::array<std::pair<std::uint8_t, const char*>, 154> opcode_list
{{
{ 0x17, "SET_NEW_LOCAL_VARIABLE_FIELD_CACHED0" },

4
src/h1/xsk/resolver.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -30,6 +30,8 @@ public:
static auto find_method(const std::string& name) -> bool;
static auto make_token(std::string_view str) -> std::string;
static auto file_data(const std::string& name) -> std::tuple<const std::string*, char*, size_t>;
static void set_reader(std::function<std::vector<std::uint8_t>(const std::string&)> callback);
};
} // namespace xsk::gsc::h1

2
src/h2/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/assembler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/assembler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

31
src/h2/xsk/compiler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,7 +19,6 @@ auto compiler::output() -> std::vector<function::ptr>
void compiler::compile(const std::string& file, std::vector<std::uint8_t>& data)
{
filename_ = file;
sources_.clear();
auto prog = parse_buffer(filename_, data);
@ -33,39 +32,19 @@ void compiler::read_callback(std::function<std::vector<std::uint8_t>(const std::
auto compiler::parse_buffer(const std::string& file, std::vector<std::uint8_t>& data) -> ast::program::ptr
{
yyscan_t scanner;
context ctx;
ast::program::ptr result(nullptr);
ctx.header_top = 0;
ctx.mode = mode_;
ctx.read_callback = read_callback_;
ctx.sources = &sources_;
ctx.loc.initialize(&file);
resolver::set_reader(read_callback_);
// Add the two NULL terminators, required by flex.
data.push_back(0);
data.push_back(0);
lexer lexer(file, reinterpret_cast<char*>(data.data()), data.size());
if (h2_lex_init(&scanner))
{
throw comp_error(ctx.loc, "An unknown error ocurred while starting lexer context.");
}
ctx.scanner = scanner;
YY_BUFFER_STATE yybuffer = h2__scan_buffer(reinterpret_cast<char*>(data.data()), data.size(), scanner);
parser parser(scanner, &ctx, result);
parser parser(lexer, result);
if (parser.parse() || result == nullptr)
{
throw comp_error(ctx.loc, "An unknown error ocurred while parsing gsc file.");
throw comp_error(xsk::gsc::location(&file), "An unknown error ocurred while parsing gsc file.");
}
h2__delete_buffer(yybuffer, scanner);
h2_lex_destroy(scanner);
return result;
}

3
src/h2/xsk/compiler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -25,7 +25,6 @@ class compiler : public gsc::compiler
std::vector<animtree_t> animtrees_;
std::unordered_map<std::string, ast::expr> constants_;
std::function<std::vector<std::uint8_t>(const std::string&)> read_callback_;
std::vector<gsc::source> sources_;
std::vector<block*> break_blks_;
std::vector<block*> continue_blks_;
bool can_break_;

2
src/h2/xsk/decompiler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/decompiler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/disassembler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/disassembler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/h2.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/h2/xsk/h2.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

3934
src/h2/xsk/lexer.cpp
View File

File diff suppressed because it is too large Load Diff

754
src/h2/xsk/lexer.hpp
View File

@ -1,711 +1,77 @@
#ifndef h2_HEADER_H
#define h2_HEADER_H 1
#define h2_IN_HEADER 1
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
#line 5 "lexer.hpp"
#include "stdafx.hpp"
#include "h2.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void h2_push_header(xsk::gsc::context* ctx, const std::string& file);
void h2_pop_header(xsk::gsc::context* ctx);
#pragma once
#line 13 "lexer.hpp"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
#ifdef yy_create_buffer
#define h2__create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer h2__create_buffer
#endif
#ifdef yy_delete_buffer
#define h2__delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer h2__delete_buffer
#endif
#ifdef yy_scan_buffer
#define h2__scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer h2__scan_buffer
#endif
#ifdef yy_scan_string
#define h2__scan_string_ALREADY_DEFINED
#else
#define yy_scan_string h2__scan_string
#endif
#ifdef yy_scan_bytes
#define h2__scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes h2__scan_bytes
#endif
#ifdef yy_init_buffer
#define h2__init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer h2__init_buffer
#endif
#ifdef yy_flush_buffer
#define h2__flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer h2__flush_buffer
#endif
#ifdef yy_load_buffer_state
#define h2__load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state h2__load_buffer_state
#endif
#ifdef yy_switch_to_buffer
#define h2__switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer h2__switch_to_buffer
#endif
#ifdef yypush_buffer_state
#define h2_push_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state h2_push_buffer_state
#endif
#ifdef yypop_buffer_state
#define h2_pop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state h2_pop_buffer_state
#endif
#ifdef yyensure_buffer_stack
#define h2_ensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack h2_ensure_buffer_stack
#endif
#ifdef yylex
#define h2_lex_ALREADY_DEFINED
#else
#define yylex h2_lex
#endif
#ifdef yyrestart
#define h2_restart_ALREADY_DEFINED
#else
#define yyrestart h2_restart
#endif
#ifdef yylex_init
#define h2_lex_init_ALREADY_DEFINED
#else
#define yylex_init h2_lex_init
#endif
#ifdef yylex_init_extra
#define h2_lex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra h2_lex_init_extra
#endif
#ifdef yylex_destroy
#define h2_lex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy h2_lex_destroy
#endif
#ifdef yyget_debug
#define h2_get_debug_ALREADY_DEFINED
#else
#define yyget_debug h2_get_debug
#endif
#ifdef yyset_debug
#define h2_set_debug_ALREADY_DEFINED
#else
#define yyset_debug h2_set_debug
#endif
#ifdef yyget_extra
#define h2_get_extra_ALREADY_DEFINED
#else
#define yyget_extra h2_get_extra
#endif
#ifdef yyset_extra
#define h2_set_extra_ALREADY_DEFINED
#else
#define yyset_extra h2_set_extra
#endif
#ifdef yyget_in
#define h2_get_in_ALREADY_DEFINED
#else
#define yyget_in h2_get_in
#endif
#ifdef yyset_in
#define h2_set_in_ALREADY_DEFINED
#else
#define yyset_in h2_set_in
#endif
#ifdef yyget_out
#define h2_get_out_ALREADY_DEFINED
#else
#define yyget_out h2_get_out
#endif
#ifdef yyset_out
#define h2_set_out_ALREADY_DEFINED
#else
#define yyset_out h2_set_out
#endif
#ifdef yyget_leng
#define h2_get_leng_ALREADY_DEFINED
#else
#define yyget_leng h2_get_leng
#endif
#ifdef yyget_text
#define h2_get_text_ALREADY_DEFINED
#else
#define yyget_text h2_get_text
#endif
#ifdef yyget_lineno
#define h2_get_lineno_ALREADY_DEFINED
#else
#define yyget_lineno h2_get_lineno
#endif
#ifdef yyset_lineno
#define h2_set_lineno_ALREADY_DEFINED
#else
#define yyset_lineno h2_set_lineno
#endif
#ifdef yyget_column
#define h2_get_column_ALREADY_DEFINED
#else
#define yyget_column h2_get_column
#endif
#ifdef yyset_column
#define h2_set_column_ALREADY_DEFINED
#else
#define yyset_column h2_set_column
#endif
#ifdef yywrap
#define h2_wrap_ALREADY_DEFINED
#else
#define yywrap h2_wrap
#endif
#ifdef yyalloc
#define h2_alloc_ALREADY_DEFINED
#else
#define yyalloc h2_alloc
#endif
#ifdef yyrealloc
#define h2_realloc_ALREADY_DEFINED
#else
#define yyrealloc h2_realloc
#endif
#ifdef yyfree
#define h2_free_ALREADY_DEFINED
#else
#define yyfree h2_free
#endif
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#ifndef SIZE_MAX
#define SIZE_MAX (~(size_t)0)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
/* begin standard C++ headers. */
/* TODO: this is always defined, so inline it */
#define yyconst const
#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif
/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif
/* For convenience, these vars (plus the bison vars far below)
are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r
/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
* Ditto for the __ia64__ case accordingly.
*/
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
namespace xsk::gsc::h2
{
FILE *yy_input_file;
char *yy_ch_buf; /* input buffer */
char *yy_buf_pos; /* current position in input buffer */
enum class keyword;
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
* delete it.
*/
int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and
* if we're using stdio for input, then we want to use getc()
* instead of fread(), to make sure we stop fetching input after
* each newline.
*/
int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line.
* If so, '^' rules will be active on the next match, otherwise
* not.
*/
int yy_at_bol;
int yy_bs_lineno; /**< The line count. */
int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
int yy_fill_buffer;
int yy_buffer_status;
struct buffer
{
int size;
int length;
char* data;
buffer();
~buffer();
bool push(char c);
};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );
struct reader
{
enum states { end, ok };
YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
states state;
int bytes_remaining;
const char* buffer_pos;
char last_byte;
char current_byte;
void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );
reader();
/* Begin user sect3 */
reader& operator=(const reader& r)
{
std::memcpy(this, &r, sizeof(reader));
return *this;
}
#define h2_wrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
void init(const char* data, size_t size);
void advance();
};
#define yytext_ptr yytext_r
class lexer
{
private:
reader reader_;
buffer buffer_;
location loc_;
build mode_;
bool in_dev_state_;
std::stack<location> locs_;
std::stack<reader> readers_;
std::uint32_t header_top_;
#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0
#define COMMENT_STATE 1
#define DEV_OFF_STATE 2
#define DEV_ON_STATE 3
public:
lexer(const std::string& name, const char* data, size_t size);
auto lex() -> xsk::gsc::h2::parser::symbol_type;
void push_header(const std::string& file);
void pop_header();
void restrict_header(const xsk::gsc::location& loc);
#endif
private:
auto read_string(char quote, bool localize) -> xsk::gsc::h2::parser::symbol_type;
auto read_number(char first) -> xsk::gsc::h2::parser::symbol_type;
auto read_word(char first) -> xsk::gsc::h2::parser::symbol_type;
auto read_dotsize() -> xsk::gsc::h2::parser::symbol_type;
auto keyword_token(keyword k) -> xsk::gsc::h2::parser::symbol_type;
static auto keyword_is_token(keyword k) -> bool;
static auto get_keyword(std::string_view str) -> keyword;
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include <unistd.h>
#endif
static std::unordered_map<std::string_view, keyword> keywords;
};
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
int yylex_init (yyscan_t* scanner);
int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */
int yylex_destroy ( yyscan_t yyscanner );
int yyget_debug ( yyscan_t yyscanner );
void yyset_debug ( int debug_flag , yyscan_t yyscanner );
YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
FILE *yyget_in ( yyscan_t yyscanner );
void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
FILE *yyget_out ( yyscan_t yyscanner );
void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
int yyget_leng ( yyscan_t yyscanner );
char *yyget_text ( yyscan_t yyscanner );
int yyget_lineno ( yyscan_t yyscanner );
void yyset_lineno ( int _line_number , yyscan_t yyscanner );
int yyget_column ( yyscan_t yyscanner );
void yyset_column ( int _column_no , yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in
* section 1.
*/
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif
#ifndef YY_NO_INPUT
#endif
/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif
/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
/* Default declaration of generated scanner - a define so the user can
* easily add parameters.
*/
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
extern int yylex (yyscan_t yyscanner);
#define YY_DECL int yylex (yyscan_t yyscanner)
#endif /* !YY_DECL */
/* yy_get_previous_state - get the state just before the EOB char was reached */
#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION
#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif
#ifndef h2__create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef h2__delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef h2__scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef h2__scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef h2__scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef h2__init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef h2__flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef h2__load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef h2__switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef h2_push_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef h2_pop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef h2_ensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef h2_lex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef h2_restart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef h2_lex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef h2_lex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef h2_lex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef h2_get_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef h2_set_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef h2_get_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef h2_set_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef h2_get_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef h2_set_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef h2_get_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef h2_set_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef h2_get_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef h2_get_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef h2_get_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef h2_set_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef h2_get_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef h2_set_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef h2_wrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef h2_get_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef h2_set_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef h2_get_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef h2_set_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef h2_alloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef h2_realloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef h2_free_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef h2_text_ALREADY_DEFINED
#undef yytext
#endif
#ifndef h2_leng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef h2_in_ALREADY_DEFINED
#undef yyin
#endif
#ifndef h2_out_ALREADY_DEFINED
#undef yyout
#endif
#ifndef h2__flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef h2_lineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef h2_tables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef h2_tables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef h2_TABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif
#line 172 "lexer.lpp"
#line 709 "lexer.hpp"
#undef h2_IN_HEADER
#endif /* h2_HEADER_H */
} // namespace xsk::gsc::h2

931
src/h2/xsk/parser.cpp
View File

File diff suppressed because it is too large Load Diff

16
src/h2/xsk/parser.hpp
View File

@ -45,13 +45,12 @@
#ifndef YY_H2_PARSER_HPP_INCLUDED
# define YY_H2_PARSER_HPP_INCLUDED
// "%code requires" blocks.
#line 33 "parser.ypp"
#line 28 "parser.ypp"
#include "h2.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::h2::parser::symbol_type H2lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::h2 { class lexer; }
#line 55 "parser.hpp"
#line 54 "parser.hpp"
# include <cassert>
# include <cstdlib> // std::abort
@ -194,7 +193,7 @@ typedef void *yyscan_t;
#line 13 "parser.ypp"
namespace xsk { namespace gsc { namespace h2 {
#line 198 "parser.hpp"
#line 197 "parser.hpp"
@ -2685,7 +2684,7 @@ switch (yykind)
};
/// Build a parser object.
parser (yyscan_t yyscanner_yyarg, xsk::gsc::context* ctx_yyarg, xsk::gsc::ast::program::ptr& ast_yyarg);
parser (xsk::gsc::h2::lexer& lexer_yyarg, xsk::gsc::ast::program::ptr& ast_yyarg);
virtual ~parser ();
#if 201103L <= YY_CPLUSPLUS
@ -4656,8 +4655,7 @@ switch (yykind)
// User arguments.
yyscan_t yyscanner;
xsk::gsc::context* ctx;
xsk::gsc::h2::lexer& lexer;
xsk::gsc::ast::program::ptr& ast;
};
@ -5342,7 +5340,7 @@ switch (yykind)
#line 13 "parser.ypp"
} } } // xsk::gsc::h2
#line 5346 "parser.hpp"
#line 5344 "parser.hpp"

31
src/h2/xsk/resolver.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -206,6 +206,35 @@ auto resolver::make_token(std::string_view str) -> std::string
return data;
}
std::function<std::vector<std::uint8_t>(const std::string&)> read_callback = nullptr;
std::unordered_map<std::string, std::vector<std::uint8_t>> files;
auto resolver::file_data(const std::string& name) -> std::tuple<const std::string*, char*, size_t>
{
const auto& itr = files.find(name);
if(itr != files.end())
{
return { &itr->first ,reinterpret_cast<char*>(itr->second.data()), itr->second.size() };
}
auto data = read_callback(name);
const auto& res = files.insert({ name, std::move(data)});
if(res.second)
{
return { &res.first->first, reinterpret_cast<char*>(res.first->second.data()), res.first->second.size() };
}
throw error("couldn't open gsc file '" + name + "'");
}
void resolver::set_reader(std::function<std::vector<std::uint8_t>(const std::string&)> callback)
{
read_callback = callback;
}
const std::array<std::pair<std::uint8_t, const char*>, 154> opcode_list
{{
{ 0x17, "SET_NEW_LOCAL_VARIABLE_FIELD_CACHED0" },

4
src/h2/xsk/resolver.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -30,6 +30,8 @@ public:
static auto find_method(const std::string& name) -> bool;
static auto make_token(std::string_view str) -> std::string;
static auto file_data(const std::string& name) -> std::tuple<const std::string*, char*, size_t>;
static void set_reader(std::function<std::vector<std::uint8_t>(const std::string&)> callback);
};
} // namespace xsk::gsc::h2

2
src/iw5/stdafx.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/stdafx.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/assembler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/assembler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

31
src/iw5/xsk/compiler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -19,7 +19,6 @@ auto compiler::output() -> std::vector<function::ptr>
void compiler::compile(const std::string& file, std::vector<std::uint8_t>& data)
{
filename_ = file;
sources_.clear();
auto prog = parse_buffer(filename_, data);
@ -33,39 +32,19 @@ void compiler::read_callback(std::function<std::vector<std::uint8_t>(const std::
auto compiler::parse_buffer(const std::string& file, std::vector<std::uint8_t>& data) -> ast::program::ptr
{
yyscan_t scanner;
context ctx;
ast::program::ptr result(nullptr);
ctx.header_top = 0;
ctx.mode = mode_;
ctx.read_callback = read_callback_;
ctx.sources = &sources_;
ctx.loc.initialize(&file);
resolver::set_reader(read_callback_);
// Add the two NULL terminators, required by flex.
data.push_back(0);
data.push_back(0);
lexer lexer(file, reinterpret_cast<char*>(data.data()), data.size());
if (iw5_lex_init(&scanner))
{
throw comp_error(ctx.loc, "An unknown error ocurred while starting lexer context.");
}
ctx.scanner = scanner;
YY_BUFFER_STATE yybuffer = iw5__scan_buffer(reinterpret_cast<char*>(data.data()), data.size(), scanner);
parser parser(scanner, &ctx, result);
parser parser(lexer, result);
if (parser.parse() || result == nullptr)
{
throw comp_error(ctx.loc, "An unknown error ocurred while parsing gsc file.");
throw comp_error(xsk::gsc::location(&file), "An unknown error ocurred while parsing gsc file.");
}
iw5__delete_buffer(yybuffer, scanner);
iw5_lex_destroy(scanner);
return result;
}

3
src/iw5/xsk/compiler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -25,7 +25,6 @@ class compiler : public gsc::compiler
std::vector<animtree_t> animtrees_;
std::unordered_map<std::string, ast::expr> constants_;
std::function<std::vector<std::uint8_t>(const std::string&)> read_callback_;
std::vector<gsc::source> sources_;
std::vector<block*> break_blks_;
std::vector<block*> continue_blks_;
bool can_break_;

2
src/iw5/xsk/decompiler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/decompiler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/disassembler.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/disassembler.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/iw5.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

2
src/iw5/xsk/iw5.hpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

3920
src/iw5/xsk/lexer.cpp
View File

File diff suppressed because it is too large Load Diff

754
src/iw5/xsk/lexer.hpp
View File

@ -1,711 +1,79 @@
#ifndef iw5_HEADER_H
#define iw5_HEADER_H 1
#define iw5_IN_HEADER 1
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
#pragma once
#line 5 "lexer.hpp"
#include "stdafx.hpp"
#include "iw5.hpp"
#include "parser.hpp"
using namespace xsk::gsc;
void iw5_push_header(xsk::gsc::context* ctx, const std::string& file);
void iw5_pop_header(xsk::gsc::context* ctx);
#line 13 "lexer.hpp"
#define YY_INT_ALIGNED short int
/* A lexical scanner generated by flex */
#define FLEX_SCANNER
#define YY_FLEX_MAJOR_VERSION 2
#define YY_FLEX_MINOR_VERSION 6
#define YY_FLEX_SUBMINOR_VERSION 4
#if YY_FLEX_SUBMINOR_VERSION > 0
#define FLEX_BETA
#endif
#ifdef yy_create_buffer
#define iw5__create_buffer_ALREADY_DEFINED
#else
#define yy_create_buffer iw5__create_buffer
#endif
#ifdef yy_delete_buffer
#define iw5__delete_buffer_ALREADY_DEFINED
#else
#define yy_delete_buffer iw5__delete_buffer
#endif
#ifdef yy_scan_buffer
#define iw5__scan_buffer_ALREADY_DEFINED
#else
#define yy_scan_buffer iw5__scan_buffer
#endif
#ifdef yy_scan_string
#define iw5__scan_string_ALREADY_DEFINED
#else
#define yy_scan_string iw5__scan_string
#endif
#ifdef yy_scan_bytes
#define iw5__scan_bytes_ALREADY_DEFINED
#else
#define yy_scan_bytes iw5__scan_bytes
#endif
#ifdef yy_init_buffer
#define iw5__init_buffer_ALREADY_DEFINED
#else
#define yy_init_buffer iw5__init_buffer
#endif
#ifdef yy_flush_buffer
#define iw5__flush_buffer_ALREADY_DEFINED
#else
#define yy_flush_buffer iw5__flush_buffer
#endif
#ifdef yy_load_buffer_state
#define iw5__load_buffer_state_ALREADY_DEFINED
#else
#define yy_load_buffer_state iw5__load_buffer_state
#endif
#ifdef yy_switch_to_buffer
#define iw5__switch_to_buffer_ALREADY_DEFINED
#else
#define yy_switch_to_buffer iw5__switch_to_buffer
#endif
#ifdef yypush_buffer_state
#define iw5_push_buffer_state_ALREADY_DEFINED
#else
#define yypush_buffer_state iw5_push_buffer_state
#endif
#ifdef yypop_buffer_state
#define iw5_pop_buffer_state_ALREADY_DEFINED
#else
#define yypop_buffer_state iw5_pop_buffer_state
#endif
#ifdef yyensure_buffer_stack
#define iw5_ensure_buffer_stack_ALREADY_DEFINED
#else
#define yyensure_buffer_stack iw5_ensure_buffer_stack
#endif
#ifdef yylex
#define iw5_lex_ALREADY_DEFINED
#else
#define yylex iw5_lex
#endif
#ifdef yyrestart
#define iw5_restart_ALREADY_DEFINED
#else
#define yyrestart iw5_restart
#endif
#ifdef yylex_init
#define iw5_lex_init_ALREADY_DEFINED
#else
#define yylex_init iw5_lex_init
#endif
#ifdef yylex_init_extra
#define iw5_lex_init_extra_ALREADY_DEFINED
#else
#define yylex_init_extra iw5_lex_init_extra
#endif
#ifdef yylex_destroy
#define iw5_lex_destroy_ALREADY_DEFINED
#else
#define yylex_destroy iw5_lex_destroy
#endif
#ifdef yyget_debug
#define iw5_get_debug_ALREADY_DEFINED
#else
#define yyget_debug iw5_get_debug
#endif
#ifdef yyset_debug
#define iw5_set_debug_ALREADY_DEFINED
#else
#define yyset_debug iw5_set_debug
#endif
#ifdef yyget_extra
#define iw5_get_extra_ALREADY_DEFINED
#else
#define yyget_extra iw5_get_extra
#endif
#ifdef yyset_extra
#define iw5_set_extra_ALREADY_DEFINED
#else
#define yyset_extra iw5_set_extra
#endif
#ifdef yyget_in
#define iw5_get_in_ALREADY_DEFINED
#else
#define yyget_in iw5_get_in
#endif
#ifdef yyset_in
#define iw5_set_in_ALREADY_DEFINED
#else
#define yyset_in iw5_set_in
#endif
#ifdef yyget_out
#define iw5_get_out_ALREADY_DEFINED
#else
#define yyget_out iw5_get_out
#endif
#ifdef yyset_out
#define iw5_set_out_ALREADY_DEFINED
#else
#define yyset_out iw5_set_out
#endif
#ifdef yyget_leng
#define iw5_get_leng_ALREADY_DEFINED
#else
#define yyget_leng iw5_get_leng
#endif
#ifdef yyget_text
#define iw5_get_text_ALREADY_DEFINED
#else
#define yyget_text iw5_get_text
#endif
#ifdef yyget_lineno
#define iw5_get_lineno_ALREADY_DEFINED
#else
#define yyget_lineno iw5_get_lineno
#endif
#ifdef yyset_lineno
#define iw5_set_lineno_ALREADY_DEFINED
#else
#define yyset_lineno iw5_set_lineno
#endif
#ifdef yyget_column
#define iw5_get_column_ALREADY_DEFINED
#else
#define yyget_column iw5_get_column
#endif
#ifdef yyset_column
#define iw5_set_column_ALREADY_DEFINED
#else
#define yyset_column iw5_set_column
#endif
#ifdef yywrap
#define iw5_wrap_ALREADY_DEFINED
#else
#define yywrap iw5_wrap
#endif
#ifdef yyalloc
#define iw5_alloc_ALREADY_DEFINED
#else
#define yyalloc iw5_alloc
#endif
#ifdef yyrealloc
#define iw5_realloc_ALREADY_DEFINED
#else
#define yyrealloc iw5_realloc
#endif
#ifdef yyfree
#define iw5_free_ALREADY_DEFINED
#else
#define yyfree iw5_free
#endif
/* First, we deal with platform-specific or compiler-specific issues. */
/* begin standard C headers. */
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <stdlib.h>
/* end standard C headers. */
/* flex integer type definitions */
#ifndef FLEXINT_H
#define FLEXINT_H
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
* if you want the limit (max/min) macros for int types.
*/
#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS 1
#endif
#include <inttypes.h>
typedef int8_t flex_int8_t;
typedef uint8_t flex_uint8_t;
typedef int16_t flex_int16_t;
typedef uint16_t flex_uint16_t;
typedef int32_t flex_int32_t;
typedef uint32_t flex_uint32_t;
#else
typedef signed char flex_int8_t;
typedef short int flex_int16_t;
typedef int flex_int32_t;
typedef unsigned char flex_uint8_t;
typedef unsigned short int flex_uint16_t;
typedef unsigned int flex_uint32_t;
/* Limits of integral types. */
#ifndef INT8_MIN
#define INT8_MIN (-128)
#endif
#ifndef INT16_MIN
#define INT16_MIN (-32767-1)
#endif
#ifndef INT32_MIN
#define INT32_MIN (-2147483647-1)
#endif
#ifndef INT8_MAX
#define INT8_MAX (127)
#endif
#ifndef INT16_MAX
#define INT16_MAX (32767)
#endif
#ifndef INT32_MAX
#define INT32_MAX (2147483647)
#endif
#ifndef UINT8_MAX
#define UINT8_MAX (255U)
#endif
#ifndef UINT16_MAX
#define UINT16_MAX (65535U)
#endif
#ifndef UINT32_MAX
#define UINT32_MAX (4294967295U)
#endif
#ifndef SIZE_MAX
#define SIZE_MAX (~(size_t)0)
#endif
#endif /* ! C99 */
#endif /* ! FLEXINT_H */
/* begin standard C++ headers. */
/* TODO: this is always defined, so inline it */
#define yyconst const
#if defined(__GNUC__) && __GNUC__ >= 3
#define yynoreturn __attribute__((__noreturn__))
#else
#define yynoreturn
#endif
/* An opaque pointer. */
#ifndef YY_TYPEDEF_YY_SCANNER_T
#define YY_TYPEDEF_YY_SCANNER_T
typedef void* yyscan_t;
#endif
/* For convenience, these vars (plus the bison vars far below)
are macros in the reentrant scanner. */
#define yyin yyg->yyin_r
#define yyout yyg->yyout_r
#define yyextra yyg->yyextra_r
#define yyleng yyg->yyleng_r
#define yytext yyg->yytext_r
#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
#define yy_flex_debug yyg->yy_flex_debug_r
/* Size of default input buffer. */
#ifndef YY_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k.
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
* Ditto for the __ia64__ case accordingly.
*/
#define YY_BUF_SIZE 32768
#else
#define YY_BUF_SIZE 16384
#endif /* __ia64__ */
#endif
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
#define YY_TYPEDEF_YY_BUFFER_STATE
typedef struct yy_buffer_state *YY_BUFFER_STATE;
#endif
#ifndef YY_TYPEDEF_YY_SIZE_T
#define YY_TYPEDEF_YY_SIZE_T
typedef size_t yy_size_t;
#endif
#ifndef YY_STRUCT_YY_BUFFER_STATE
#define YY_STRUCT_YY_BUFFER_STATE
struct yy_buffer_state
namespace xsk::gsc::iw5
{
FILE *yy_input_file;
char *yy_ch_buf; /* input buffer */
char *yy_buf_pos; /* current position in input buffer */
enum class keyword;
/* Size of input buffer in bytes, not including room for EOB
* characters.
*/
int yy_buf_size;
/* Number of characters read into yy_ch_buf, not including EOB
* characters.
*/
int yy_n_chars;
/* Whether we "own" the buffer - i.e., we know we created it,
* and can realloc() it to grow it, and should free() it to
* delete it.
*/
int yy_is_our_buffer;
/* Whether this is an "interactive" input source; if so, and
* if we're using stdio for input, then we want to use getc()
* instead of fread(), to make sure we stop fetching input after
* each newline.
*/
int yy_is_interactive;
/* Whether we're considered to be at the beginning of a line.
* If so, '^' rules will be active on the next match, otherwise
* not.
*/
int yy_at_bol;
int yy_bs_lineno; /**< The line count. */
int yy_bs_column; /**< The column count. */
/* Whether to try to fill the input buffer when we reach the
* end of it.
*/
int yy_fill_buffer;
int yy_buffer_status;
struct buffer
{
int size;
int length;
char* data;
buffer();
~buffer();
bool push(char c);
};
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
void yyrestart ( FILE *input_file , yyscan_t yyscanner );
void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size , yyscan_t yyscanner );
void yy_delete_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yy_flush_buffer ( YY_BUFFER_STATE b , yyscan_t yyscanner );
void yypush_buffer_state ( YY_BUFFER_STATE new_buffer , yyscan_t yyscanner );
void yypop_buffer_state ( yyscan_t yyscanner );
struct reader
{
enum states { end, ok };
YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_string ( const char *yy_str , yyscan_t yyscanner );
YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len , yyscan_t yyscanner );
states state;
int bytes_remaining;
const char* buffer_pos;
char last_byte;
char current_byte;
void *yyalloc ( yy_size_t , yyscan_t yyscanner );
void *yyrealloc ( void *, yy_size_t , yyscan_t yyscanner );
void yyfree ( void * , yyscan_t yyscanner );
reader();
/* Begin user sect3 */
reader& operator=(const reader& r)
{
std::memcpy(this, &r, sizeof(reader));
return *this;
}
#define iw5_wrap(yyscanner) (/*CONSTCOND*/1)
#define YY_SKIP_YYWRAP
void init(const char* data, size_t size);
void advance();
};
#define yytext_ptr yytext_r
class lexer
{
private:
reader reader_;
buffer buffer_;
location loc_;
build mode_;
bool in_dev_state_;
std::stack<location> locs_;
std::stack<reader> readers_;
std::uint32_t header_top_;
#ifdef YY_HEADER_EXPORT_START_CONDITIONS
#define INITIAL 0
#define COMMENT_STATE 1
#define DEV_OFF_STATE 2
#define DEV_ON_STATE 3
public:
lexer(const std::string& name, const char* data, size_t size);
auto lex() -> xsk::gsc::iw5::parser::symbol_type;
void push_header(const std::string& file);
void pop_header();
void restrict_header(const xsk::gsc::location& loc);
#endif
private:
auto read_string(char quote, bool localize) -> xsk::gsc::iw5::parser::symbol_type;
auto read_number(char first) -> xsk::gsc::iw5::parser::symbol_type;
auto read_word(char first) -> xsk::gsc::iw5::parser::symbol_type;
auto read_dotsize() -> xsk::gsc::iw5::parser::symbol_type;
auto keyword_token(keyword k) -> xsk::gsc::iw5::parser::symbol_type;
static auto keyword_is_token(keyword k) -> bool;
static auto get_keyword(std::string_view str) -> keyword;
#ifndef YY_NO_UNISTD_H
/* Special case for "unistd.h", since it is non-ANSI. We include it way
* down here because we want the user's section 1 to have been scanned first.
* The user has a chance to override it with an option.
*/
#include <unistd.h>
#endif
static std::unordered_map<std::string_view, keyword> keywords;
};
#ifndef YY_EXTRA_TYPE
#define YY_EXTRA_TYPE void *
#endif
int yylex_init (yyscan_t* scanner);
int yylex_init_extra ( YY_EXTRA_TYPE user_defined, yyscan_t* scanner);
/* Accessor methods to globals.
These are made visible to non-reentrant scanners for convenience. */
int yylex_destroy ( yyscan_t yyscanner );
int yyget_debug ( yyscan_t yyscanner );
void yyset_debug ( int debug_flag , yyscan_t yyscanner );
YY_EXTRA_TYPE yyget_extra ( yyscan_t yyscanner );
void yyset_extra ( YY_EXTRA_TYPE user_defined , yyscan_t yyscanner );
FILE *yyget_in ( yyscan_t yyscanner );
void yyset_in ( FILE * _in_str , yyscan_t yyscanner );
FILE *yyget_out ( yyscan_t yyscanner );
void yyset_out ( FILE * _out_str , yyscan_t yyscanner );
int yyget_leng ( yyscan_t yyscanner );
char *yyget_text ( yyscan_t yyscanner );
int yyget_lineno ( yyscan_t yyscanner );
void yyset_lineno ( int _line_number , yyscan_t yyscanner );
int yyget_column ( yyscan_t yyscanner );
void yyset_column ( int _column_no , yyscan_t yyscanner );
/* Macros after this point can all be overridden by user definitions in
* section 1.
*/
#ifndef YY_SKIP_YYWRAP
#ifdef __cplusplus
extern "C" int yywrap ( yyscan_t yyscanner );
#else
extern int yywrap ( yyscan_t yyscanner );
#endif
#endif
#ifndef yytext_ptr
static void yy_flex_strncpy ( char *, const char *, int , yyscan_t yyscanner);
#endif
#ifdef YY_NEED_STRLEN
static int yy_flex_strlen ( const char * , yyscan_t yyscanner);
#endif
#ifndef YY_NO_INPUT
#endif
/* Amount of stuff to slurp up with each read. */
#ifndef YY_READ_BUF_SIZE
#ifdef __ia64__
/* On IA-64, the buffer size is 16k, not 8k */
#define YY_READ_BUF_SIZE 16384
#else
#define YY_READ_BUF_SIZE 8192
#endif /* __ia64__ */
#endif
/* Number of entries by which start-condition stack grows. */
#ifndef YY_START_STACK_INCR
#define YY_START_STACK_INCR 25
#endif
/* Default declaration of generated scanner - a define so the user can
* easily add parameters.
*/
#ifndef YY_DECL
#define YY_DECL_IS_OURS 1
extern int yylex (yyscan_t yyscanner);
#define YY_DECL int yylex (yyscan_t yyscanner)
#endif /* !YY_DECL */
/* yy_get_previous_state - get the state just before the EOB char was reached */
#undef YY_NEW_FILE
#undef YY_FLUSH_BUFFER
#undef yy_set_bol
#undef yy_new_buffer
#undef yy_set_interactive
#undef YY_DO_BEFORE_ACTION
#ifdef YY_DECL_IS_OURS
#undef YY_DECL_IS_OURS
#undef YY_DECL
#endif
#ifndef iw5__create_buffer_ALREADY_DEFINED
#undef yy_create_buffer
#endif
#ifndef iw5__delete_buffer_ALREADY_DEFINED
#undef yy_delete_buffer
#endif
#ifndef iw5__scan_buffer_ALREADY_DEFINED
#undef yy_scan_buffer
#endif
#ifndef iw5__scan_string_ALREADY_DEFINED
#undef yy_scan_string
#endif
#ifndef iw5__scan_bytes_ALREADY_DEFINED
#undef yy_scan_bytes
#endif
#ifndef iw5__init_buffer_ALREADY_DEFINED
#undef yy_init_buffer
#endif
#ifndef iw5__flush_buffer_ALREADY_DEFINED
#undef yy_flush_buffer
#endif
#ifndef iw5__load_buffer_state_ALREADY_DEFINED
#undef yy_load_buffer_state
#endif
#ifndef iw5__switch_to_buffer_ALREADY_DEFINED
#undef yy_switch_to_buffer
#endif
#ifndef iw5_push_buffer_state_ALREADY_DEFINED
#undef yypush_buffer_state
#endif
#ifndef iw5_pop_buffer_state_ALREADY_DEFINED
#undef yypop_buffer_state
#endif
#ifndef iw5_ensure_buffer_stack_ALREADY_DEFINED
#undef yyensure_buffer_stack
#endif
#ifndef iw5_lex_ALREADY_DEFINED
#undef yylex
#endif
#ifndef iw5_restart_ALREADY_DEFINED
#undef yyrestart
#endif
#ifndef iw5_lex_init_ALREADY_DEFINED
#undef yylex_init
#endif
#ifndef iw5_lex_init_extra_ALREADY_DEFINED
#undef yylex_init_extra
#endif
#ifndef iw5_lex_destroy_ALREADY_DEFINED
#undef yylex_destroy
#endif
#ifndef iw5_get_debug_ALREADY_DEFINED
#undef yyget_debug
#endif
#ifndef iw5_set_debug_ALREADY_DEFINED
#undef yyset_debug
#endif
#ifndef iw5_get_extra_ALREADY_DEFINED
#undef yyget_extra
#endif
#ifndef iw5_set_extra_ALREADY_DEFINED
#undef yyset_extra
#endif
#ifndef iw5_get_in_ALREADY_DEFINED
#undef yyget_in
#endif
#ifndef iw5_set_in_ALREADY_DEFINED
#undef yyset_in
#endif
#ifndef iw5_get_out_ALREADY_DEFINED
#undef yyget_out
#endif
#ifndef iw5_set_out_ALREADY_DEFINED
#undef yyset_out
#endif
#ifndef iw5_get_leng_ALREADY_DEFINED
#undef yyget_leng
#endif
#ifndef iw5_get_text_ALREADY_DEFINED
#undef yyget_text
#endif
#ifndef iw5_get_lineno_ALREADY_DEFINED
#undef yyget_lineno
#endif
#ifndef iw5_set_lineno_ALREADY_DEFINED
#undef yyset_lineno
#endif
#ifndef iw5_get_column_ALREADY_DEFINED
#undef yyget_column
#endif
#ifndef iw5_set_column_ALREADY_DEFINED
#undef yyset_column
#endif
#ifndef iw5_wrap_ALREADY_DEFINED
#undef yywrap
#endif
#ifndef iw5_get_lval_ALREADY_DEFINED
#undef yyget_lval
#endif
#ifndef iw5_set_lval_ALREADY_DEFINED
#undef yyset_lval
#endif
#ifndef iw5_get_lloc_ALREADY_DEFINED
#undef yyget_lloc
#endif
#ifndef iw5_set_lloc_ALREADY_DEFINED
#undef yyset_lloc
#endif
#ifndef iw5_alloc_ALREADY_DEFINED
#undef yyalloc
#endif
#ifndef iw5_realloc_ALREADY_DEFINED
#undef yyrealloc
#endif
#ifndef iw5_free_ALREADY_DEFINED
#undef yyfree
#endif
#ifndef iw5_text_ALREADY_DEFINED
#undef yytext
#endif
#ifndef iw5_leng_ALREADY_DEFINED
#undef yyleng
#endif
#ifndef iw5_in_ALREADY_DEFINED
#undef yyin
#endif
#ifndef iw5_out_ALREADY_DEFINED
#undef yyout
#endif
#ifndef iw5__flex_debug_ALREADY_DEFINED
#undef yy_flex_debug
#endif
#ifndef iw5_lineno_ALREADY_DEFINED
#undef yylineno
#endif
#ifndef iw5_tables_fload_ALREADY_DEFINED
#undef yytables_fload
#endif
#ifndef iw5_tables_destroy_ALREADY_DEFINED
#undef yytables_destroy
#endif
#ifndef iw5_TABLES_NAME_ALREADY_DEFINED
#undef yyTABLES_NAME
#endif
#line 171 "lexer.lpp"
#line 709 "lexer.hpp"
#undef iw5_IN_HEADER
#endif /* iw5_HEADER_H */
} // namespace xsk::gsc::iw5

919
src/iw5/xsk/parser.cpp
View File

File diff suppressed because it is too large Load Diff

16
src/iw5/xsk/parser.hpp
View File

@ -45,13 +45,12 @@
#ifndef YY_IW5_PARSER_HPP_INCLUDED
# define YY_IW5_PARSER_HPP_INCLUDED
// "%code requires" blocks.
#line 33 "parser.ypp"
#line 28 "parser.ypp"
#include "iw5.hpp"
typedef void *yyscan_t;
#define YY_DECL xsk::gsc::iw5::parser::symbol_type IW5lex(yyscan_t yyscanner, xsk::gsc::context* ctx)
namespace xsk::gsc::iw5 { class lexer; }
#line 55 "parser.hpp"
#line 54 "parser.hpp"
# include <cassert>
# include <cstdlib> // std::abort
@ -194,7 +193,7 @@ typedef void *yyscan_t;
#line 13 "parser.ypp"
namespace xsk { namespace gsc { namespace iw5 {
#line 198 "parser.hpp"
#line 197 "parser.hpp"
@ -2657,7 +2656,7 @@ switch (yykind)
};
/// Build a parser object.
parser (yyscan_t yyscanner_yyarg, xsk::gsc::context* ctx_yyarg, xsk::gsc::ast::program::ptr& ast_yyarg);
parser (xsk::gsc::iw5::lexer& lexer_yyarg, xsk::gsc::ast::program::ptr& ast_yyarg);
virtual ~parser ();
#if 201103L <= YY_CPLUSPLUS
@ -4613,8 +4612,7 @@ switch (yykind)
// User arguments.
yyscan_t yyscanner;
xsk::gsc::context* ctx;
xsk::gsc::iw5::lexer& lexer;
xsk::gsc::ast::program::ptr& ast;
};
@ -5291,7 +5289,7 @@ switch (yykind)
#line 13 "parser.ypp"
} } } // xsk::gsc::iw5
#line 5295 "parser.hpp"
#line 5293 "parser.hpp"

31
src/iw5/xsk/resolver.cpp
View File

@ -1,4 +1,4 @@
// Copyright 2021 xensik. All rights reserved.
// Copyright 2022 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.
@ -264,6 +264,35 @@ auto resolver::make_token(std::string_view str) -> std::string
return data;
}
std::function<std::vector<std::uint8_t>(const std::string&)> read_callback = nullptr;
std::unordered_map<std::string, std::vector<std::uint8_t>> files;
auto resolver::file_data(const std::string& name) -> std::tuple<const std::string*, char*, size_t>
{
const auto& itr = files.find(name);
if(itr != files.end())
{
return { &itr->first ,reinterpret_cast<char*>(itr->second.data()), itr->second.size() };
}
auto data = read_callback(name);
const auto& res = files.insert({ name, std::move(data)});
if(res.second)
{
return { &res.first->first, reinterpret_cast<char*>(res.first->second.data()), res.first->second.size() };
}
throw error("couldn't open gsc file '" + name + "'");
}
void resolver::set_reader(std::function<std::vector<std::uint8_t>(const std::string&)> callback)
{
read_callback = callback;
}
const std::array<std::pair<std::uint8_t, const char*>, 153> opcode_list
{{
{ 0x00, "END" },

Some files were not shown because too many files have changed in this diff Show More