diff --git a/.editorconfig b/.editorconfig
index 82159d830579e0d0e73920bcbc72f85178739e17..b522a5e5819c22255630455c4621716f93a2ab85 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -6,6 +6,6 @@ indent_size = 2
charset = utf-8
insert_final_newline = true
-[*.txt]
+[*.{sablecc3,txt}]
indent_size = 4
trim_trailing_whitespace = true
diff --git a/src/main/sablecc/sablecc-3x.sablecc3 b/src/main/sablecc/sablecc-3x.sablecc3
index 878eb49c231fc74fbdd0119de463b3095ff5286e..5a2cbbea2802150df356575313a65046a5c85246 100644
--- a/src/main/sablecc/sablecc-3x.sablecc3
+++ b/src/main/sablecc/sablecc-3x.sablecc3
@@ -131,104 +131,104 @@ Productions
grammar =
P.package? P.helpers? P.states? P.tokens? ign_tokens? P.productions? P.ast?
- {-> New grammar([P.package.list_pkg_id], P.helpers, P.states,
- P.tokens, P.ign_tokens, P.productions, P.ast)
- };
+ {-> New grammar([P.package.list_pkg_id], P.helpers, P.states,
+ P.tokens, P.ign_tokens, P.productions, P.ast)
+ };
package
- {-> [list_pkg_id]:pkg_id*} =
+ {-> [list_pkg_id]:pkg_id*} =
T.package pkg_name
- {-> [pkg_name.pkg_id] };
+ {-> [pkg_name.pkg_id] };
- pkg_name
- {-> pkg_id*} =
+ pkg_name
+ {-> pkg_id*} =
pkg_id [pkg_ids]:pkg_name_tail* semicolon
- {-> [pkg_id, pkg_ids.pkg_id] };
+ {-> [pkg_id, pkg_ids.pkg_id] };
- pkg_name_tail
- {-> pkg_id } =
+ pkg_name_tail
+ {-> pkg_id } =
dot pkg_id
- {-> pkg_id };
+ {-> pkg_id };
helpers =
T.helpers [helper_defs]:helper_def+
- {-> New helpers([helper_defs]) };
+ {-> New helpers([helper_defs]) };
helper_def =
id equal reg_exp semicolon
- {-> New helper_def(id, reg_exp) };
+ {-> New helper_def(id, reg_exp) };
states =
T.states id_list semicolon
- {-> New states([id_list.id]) };
+ {-> New states([id_list.id]) };
- id_list
- {-> id*} =
+ id_list
+ {-> id*} =
id [ids]:id_list_tail*
- {-> [id, ids.id]};
+ {-> [id, ids.id]};
- id_list_tail
- {-> id } =
+ id_list_tail
+ {-> id } =
comma id
- {-> id};
+ {-> id};
tokens =
T.tokens [token_defs]:token_def+
- {-> New tokens([token_defs]) };
+ {-> New tokens([token_defs]) };
token_def =
state_list? id equal reg_exp look_ahead? semicolon
- {-> New token_def(state_list, id, reg_exp, look_ahead.slash, look_ahead.reg_exp) };
+ {-> New token_def(state_list, id, reg_exp, look_ahead.slash, look_ahead.reg_exp) };
state_list =
l_brace id transition? [state_lists]:state_list_tail* r_brace
- {-> New state_list(id, transition, [state_lists])};
+ {-> New state_list(id, transition, [state_lists])};
state_list_tail =
comma id transition?
- {-> New state_list_tail(id, transition) };
+ {-> New state_list_tail(id, transition) };
transition =
arrow id
- {-> New transition(id)};
+ {-> New transition(id)};
ign_tokens =
ignored T.tokens id_list? semicolon
- {-> New ign_tokens([id_list.id]) };
+ {-> New ign_tokens([id_list.id]) };
- look_ahead
- {-> slash reg_exp} =
+ look_ahead
+ {-> slash reg_exp} =
slash reg_exp
- {-> slash reg_exp};
+ {-> slash reg_exp};
reg_exp =
concat [concats]:reg_exp_tail*
- {-> New reg_exp([concat, concats.concat])};
+ {-> New reg_exp([concat, concats.concat])};
- reg_exp_tail
- {-> concat } =
+ reg_exp_tail
+ {-> concat } =
bar concat
- {-> concat};
+ {-> concat};
concat =
[un_exps]:un_exp*
- {-> New concat([un_exps])};
+ {-> New concat([un_exps])};
un_exp =
basic un_op?;
basic =
- {char} P.char
- {-> New basic.char(P.char)} |
- {set} set
- {-> New basic.set(set)} |
- {string} string
- {-> New basic.string(string)} |
- {id} id
- {-> New basic.id(id)} |
+ {char} P.char
+ {-> New basic.char(P.char)} |
+ {set} set
+ {-> New basic.set(set)} |
+ {string} string
+ {-> New basic.string(string)} |
+ {id} id
+ {-> New basic.id(id)} |
{reg_exp} l_par reg_exp r_par
- {-> New basic.reg_exp(reg_exp)} ;
+ {-> New basic.reg_exp(reg_exp)};
char =
{char} T.char |
@@ -236,158 +236,158 @@ Productions
{hex} hex_char;
set =
- {operation} l_bkt [left]:basic bin_op [right]:basic r_bkt
- {-> New set.operation(left, bin_op, right) } |
+ {operation} l_bkt [left]:basic bin_op [right]:basic r_bkt
+ {-> New set.operation(left, bin_op, right) } |
{interval} l_bkt [left]:P.char d_dot [right]:P.char r_bkt
- {-> New set.interval(left, right) };
+ {-> New set.interval(left, right) };
un_op =
- {star} star
- {-> New un_op.star(star)} |
+ {star} star
+ {-> New un_op.star(star)} |
{q_mark} q_mark
- {-> New un_op.q_mark(q_mark)} |
+ {-> New un_op.q_mark(q_mark)} |
{plus} plus
- {-> New un_op.plus(plus)} ;
+ {-> New un_op.plus(plus)};
bin_op =
- {plus} plus
- {-> New bin_op.plus()} |
+ {plus} plus
+ {-> New bin_op.plus()}|
{minus} minus
- {-> New bin_op.minus()} ;
+ {-> New bin_op.minus()};
productions =
T.productions [prods]:prod+
- {-> New productions([prods]) };
+ {-> New productions([prods]) };
prod =
id prod_transform? equal alts semicolon
- {-> New prod(id, prod_transform.arrow, [prod_transform.elem], [alts.list_alt])};
+ {-> New prod(id, prod_transform.arrow, [prod_transform.elem], [alts.list_alt])};
- prod_transform
- {-> arrow elem*} =
+ prod_transform
+ {-> arrow elem*} =
l_brace arrow [elems]:elem* r_brace
- {-> arrow [elems]};
+ {-> arrow [elems]};
- alts
- {-> [list_alt]:alt*} =
+ alts
+ {-> [list_alt]:alt*} =
alt [alts]:alts_tail*
- {-> [alt, alts.alt]};
+ {-> [alt, alts.alt]};
- alts_tail
- {-> alt} =
+ alts_tail
+ {-> alt} =
bar alt
- {-> alt};
+ {-> alt};
alt =
- alt_name? [elems]:elem* alt_transform?
- {-> New alt(alt_name.id, [elems], alt_transform)};
+ alt_name? [elems]:elem* alt_transform?
+ {-> New alt(alt_name.id, [elems], alt_transform)};
alt_transform =
l_brace arrow [terms]: term* r_brace
- {-> New alt_transform(l_brace, [terms], r_brace)};
+ {-> New alt_transform(l_brace, [terms], r_brace)};
term =
{new} new prod_name l_par params? r_par
- {-> New term.new(prod_name, l_par, [params.list_term]) } |
+ {-> New term.new(prod_name, l_par, [params.list_term]) } |
{list} l_bkt list_of_list_term? r_bkt
- {-> New term.list(l_bkt, [list_of_list_term.list_terms])} |
+ {-> New term.list(l_bkt, [list_of_list_term.list_terms])} |
{simple} specifier? id simple_term_tail?
- {-> New term.simple(specifier, id, simple_term_tail.id)} |
+ {-> New term.simple(specifier, id, simple_term_tail.id)} |
{null} null
- {-> New term.null()} ;
+ {-> New term.null()};
- list_of_list_term
- {-> [list_terms]:list_term* } =
- list_term [list_terms]:list_term_tail*
- {-> [list_term, list_terms.list_term] } ;
+ list_of_list_term
+ {-> [list_terms]:list_term* } =
+ list_term [list_terms]:list_term_tail*
+ {-> [list_term, list_terms.list_term] };
list_term =
{new} new prod_name l_par params? r_par
- {-> New list_term.new(prod_name, l_par, [params.list_term])} |
- {simple} specifier? id simple_term_tail?
- {-> New list_term.simple(specifier, id, simple_term_tail.id)};
+ {-> New list_term.new(prod_name, l_par, [params.list_term])} |
+ {simple} specifier? id simple_term_tail?
+ {-> New list_term.simple(specifier, id, simple_term_tail.id)};
- list_term_tail
- {-> list_term} =
- comma list_term
- {-> list_term} ;
+ list_term_tail
+ {-> list_term} =
+ comma list_term
+ {-> list_term};
- simple_term_tail
- {-> id} =
+ simple_term_tail
+ {-> id} =
dot id
- {-> id};
+ {-> id};
prod_name =
id prod_name_tail?
- {-> New prod_name(id, prod_name_tail.id)};
+ {-> New prod_name(id, prod_name_tail.id)};
- prod_name_tail
- {-> id} =
+ prod_name_tail
+ {-> id} =
dot id
- {-> id};
+ {-> id};
- params
- {-> [list_term]:term*} =
+ params
+ {-> [list_term]:term*} =
term [params]:params_tail*
- {-> [term, params.term]};
+ {-> [term, params.term]};
- params_tail
- {-> term} =
+ params_tail
+ {-> term} =
comma term
- {-> term};
+ {-> term};
- alt_name
- {-> id} =
+ alt_name
+ {-> id} =
l_brace id r_brace
- {-> id};
+ {-> id};
elem =
elem_name? specifier? id un_op?
- {-> New elem(elem_name.id, specifier, id, un_op) };
+ {-> New elem(elem_name.id, specifier, id, un_op) };
- elem_name
- {-> id} =
+ elem_name
+ {-> id} =
l_bkt id r_bkt colon
- {-> id};
+ {-> id};
specifier =
- {token} token_specifier dot
- {-> New specifier.token()} |
+ {token} token_specifier dot
+ {-> New specifier.token()} |
{production} production_specifier dot
- {-> New specifier.production()} ;
+ {-> New specifier.production()};
ast =
abstract syntax tree [prods]:ast_prod+
- {-> New ast([prods]) };
+ {-> New ast([prods]) };
ast_prod =
id equal [alts]:ast_alts semicolon
- {-> New ast_prod(id, [alts.list_ast_alt])};
+ {-> New ast_prod(id, [alts.list_ast_alt])};
- ast_alts
- {-> [list_ast_alt]:ast_alt*} =
+ ast_alts
+ {-> [list_ast_alt]:ast_alt*} =
ast_alt [ast_alts]:ast_alts_tail*
- {-> [ast_alt, ast_alts.ast_alt]};
+ {-> [ast_alt, ast_alts.ast_alt]};
- ast_alts_tail
- {-> ast_alt} =
+ ast_alts_tail
+ {-> ast_alt} =
bar ast_alt
- {-> ast_alt};
+ {-> ast_alt};
ast_alt =
alt_name? [elems]:elem*
- {-> New ast_alt(alt_name.id, [elems])};
+ {-> New ast_alt(alt_name.id, [elems])};
/*****************************************************************************************/
-/* */
-/* */
-/* */
-/* */
-/* */
+/* */
+/* */
+/* */
+/* */
+/* */
/*****************************************************************************************/
Abstract Syntax Tree
@@ -401,7 +401,7 @@ Abstract Syntax Tree
id reg_exp;
states =
- [list_id]:id*;
+ [list_id]:id*;
tokens =
[token_defs]:token_def*;
@@ -424,8 +424,8 @@ Abstract Syntax Tree
reg_exp =
[concats]:concat*;
- concat =
- [un_exps]: un_exp*;
+ concat =
+ [un_exps]: un_exp*;
un_exp =
basic un_op?;
@@ -447,9 +447,9 @@ Abstract Syntax Tree
{interval} [left]:P.char [right]:P.char ;
un_op =
- {star} star |
+ {star} star |
{q_mark} q_mark |
- {plus} plus ;
+ {plus} plus;
bin_op =
{plus} |
@@ -465,27 +465,27 @@ Abstract Syntax Tree
[alt_name]:id? [elems]:elem* alt_transform?;
alt_transform =
- l_brace [terms]:term* r_brace;
+ l_brace [terms]:term* r_brace;
term =
{new} prod_name l_par [params]:term* |
{list} l_bkt [list_terms]:list_term* |
{simple} specifier? id [simple_term_tail]:id? |
- {null} ;
+ {null};
list_term =
{new} prod_name l_par [params]:term* |
- {simple} specifier? id [simple_term_tail]:id? ;
+ {simple} specifier? id [simple_term_tail]:id?;
prod_name =
- id [prod_name_tail]:id? ;
+ id [prod_name_tail]:id?;
elem =
[elem_name]:id? specifier? id un_op?;
specifier =
- {token} |
- {production} ;
+ {token} |
+ {production};
ast =
[prods]:ast_prod*;