CoreDump: The LL(1) LPSe Language.
Welcome to CoreDump, the one-stop for techies….
Dump 04.07.2022.21.11
Gecko: Remember the COOL Language from Stanford.
The Trio, the Gecko, and the Team have teamed up with Dr. Bheemaiah to consult on Free Willy BC, the new AWS IQ, and SaaS Consultancy. We are helping students drowning in homework, I just met a kid, who needed oxygen, not so much due to covid but HW!, he had to handcraft a compiler in Java, for the LPSe language, be a Gandhian, with the chakra, spinning threads of code, with no fabric woven, just plain pacifism, “we are against lethal AI, we are for peace”, we sit handcrafting code, to end the colonial!
Trio: The HW is not so bad, create a LL(1) parser, a grammar for LPSe, and handcraft a parser, backend, and optimizer, without any compiler-compiler or scaffolding engineering?
We are helping him with it….., one thread at a time…, in Java….
Lisa: I don’t get the deal, Earthers are just shit! and what real difference does concurrent machine-generated threads, woven into a fabric, of concurrency? in scaffolding engineering? Don’t you think Earthers are a mere scaffolding to the Belters, Martians, and Jovians?
Calvin: I hope the shit falls to place and all objects, code and all, fall to place, return to the elements….., The Samadhi, of Peace and the self-extinction of the Earthers to the indigenous?
Hobbes: I could reflect that in the code, generated or handcrafted…..
Gecko: The COOL Language has the following grammar, I just modify it, a subset to the LPSe language.
program ::= [[class; ]]+
class ::= class TYPE [inherits TYPE] { [[feature; ]]∗ }
feature ::= ID( [ formal [[, formal]]∗ ] ) : TYPE { expr }
ID : TYPE [ <- expr ]
formal ::= ID : TYPE
expr ::= ID <- expr
| expr[@TYPE].ID( [ expr [[, expr]]∗ ] )
| ID( [ expr [[, expr]]∗ ] )
| if expr then expr else expr f
| while expr loop expr pool | { [[expr; ]]+}
| let ID : TYPE [ <- expr ] [[,ID : TYPE [ <- expr ]]]∗ in expr
| case expr of [[ID : TYPE => expr; ]]+esac
| new TYPE
| isvoid expr
| expr + expr
| expr − expr
| expr ∗ expr
| expr / expr
|˜expr
| expr
| ID
| integer
| string
| true
| false
LPSe Grammar.
program : Begin [feature]* [expr]* End;
feature : ID( [ formal [[, formal]]∗ ] ) : TYPE { expr };
ID : TYPE [ <- expr ];
formal : ID : TYPE;
expr : expr[@TYPE].ID( [ expr [[, expr]]∗ ] )
| ID( [ expr [[, expr]]∗ ] )
| if expr then expr else expr f
| while expr loop expr pool | { [[expr; ]]+}
| let ID : TYPE [ <- expr ] [[,ID : TYPE [ <- expr ]]]∗ in expr
| case expr of [[ID : TYPE => expr; ]]+esac
| printint expr
| printchar expr
| isvoid expr
| expr + expr
| expr − expr
| expr ∗ expr
| expr / expr
| expr == expr
| expr < expr
| expr > expr
| expr ≥ expr
| expr ≤ expr
|˜expr
| expr
| ID
| integer
| string
| true
| false
;
Trio: Great is this LL(1)? , can we just add it to JISON, spew out a JS parser and compare it to one painfully hand-crafted, by say, Gandhi, over a decade?
Here is JISON:: zoom, zoom, zoom …
For the C-like language LPse(C), written in Lex syntax….
%token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
%token BEGIN END
%token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
%token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
%token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
%token XOR_ASSIGN OR_ASSIGN TYPE_NAME
%token TYPEDEF EXTERN STATIC AUTO REGISTER
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
%token STRUCT UNION ENUM ELLIPSIS
%token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
%nonassoc IF_WITHOUT_ELSE
%nonassoc ELSE
%start translation_unit
%%
primary_expression
: IDENTIFIER
| CONSTANT
| STRING_LITERAL
| ‘(‘ expression ‘)’
;
postfix_expression
: primary_expression
| postfix_expression ‘[‘ expression ‘]’
| postfix_expression ‘(‘ ‘)’
| postfix_expression ‘(‘ argument_expression_list ‘)’
| postfix_expression ‘.’ IDENTIFIER
| postfix_expression PTR_OP IDENTIFIER
| postfix_expression INC_OP
| postfix_expression DEC_OP
;
argument_expression_list
: assignment_expression
| argument_expression_list ‘,’ assignment_expression
;
unary_expression
: postfix_expression
| INC_OP unary_expression
| DEC_OP unary_expression
| unary_operator cast_expression
| SIZEOF unary_expression
| SIZEOF ‘(‘ type_name ‘)’
;
unary_operator
: ‘&’
| ‘*’
| ‘+’
| ‘-’
| ‘~’
| ‘!’
;
cast_expression
: unary_expression
| ‘(‘ type_name ‘)’ cast_expression
;
multiplicative_expression
: cast_expression
| multiplicative_expression ‘*’ cast_expression
| multiplicative_expression ‘/’ cast_expression
| multiplicative_expression ‘%’ cast_expression
;
additive_expression
: multiplicative_expression
| additive_expression ‘+’ multiplicative_expression
| additive_expression ‘-’ multiplicative_expression
;
shift_expression
: additive_expression
| shift_expression LEFT_OP additive_expression
| shift_expression RIGHT_OP additive_expression
;
relational_expression
: shift_expression
| relational_expression ‘<’ shift_expression
| relational_expression ‘>’ shift_expression
| relational_expression LE_OP shift_expression
| relational_expression GE_OP shift_expression
;
equality_expression
: relational_expression
| equality_expression EQ_OP relational_expression
| equality_expression NE_OP relational_expression
;
and_expression
: equality_expression
| and_expression ‘&’ equality_expression
;
exclusive_or_expression
: and_expression
| exclusive_or_expression ‘^’ and_expression
;
inclusive_or_expression
: exclusive_or_expression
| inclusive_or_expression ‘|’ exclusive_or_expression
;
logical_and_expression
: inclusive_or_expression
| logical_and_expression AND_OP inclusive_or_expression
;
logical_or_expression
: logical_and_expression
| logical_or_expression OR_OP logical_and_expression
;
conditional_expression
: logical_or_expression
| logical_or_expression ‘?’ expression ‘:’ conditional_expression
;
assignment_expression
: conditional_expression
| unary_expression assignment_operator assignment_expression
;
assignment_operator
: ‘=’
| MUL_ASSIGN
| DIV_ASSIGN
| MOD_ASSIGN
| ADD_ASSIGN
| SUB_ASSIGN
| LEFT_ASSIGN
| RIGHT_ASSIGN
| AND_ASSIGN
| XOR_ASSIGN
| OR_ASSIGN
;
expression
: assignment_expression
| expression ‘,’ assignment_expression
;
constant_expression
: conditional_expression
;
declaration
: declaration_specifiers ‘;’
| declaration_specifiers init_declarator_list ‘;’
;
declaration_specifiers
: storage_class_specifier
| storage_class_specifier declaration_specifiers
| type_specifier
| type_specifier declaration_specifiers
| type_qualifier
| type_qualifier declaration_specifiers
;
init_declarator_list
: init_declarator
| init_declarator_list ‘,’ init_declarator
;
init_declarator
: declarator
| declarator ‘=’ initializer
;
storage_class_specifier
: TYPEDEF
| EXTERN
| STATIC
| AUTO
| REGISTER
;
type_specifier
: VOID
| CHAR
| SHORT
| INT
| LONG
| FLOAT
| DOUBLE
| SIGNED
| UNSIGNED
| enum_specifier
| TYPE_NAME
;
enum_specifier
: ENUM ‘{‘ enumerator_list ‘}’
| ENUM IDENTIFIER ‘{‘ enumerator_list ‘}’
| ENUM IDENTIFIER
;
enumerator_list
: enumerator
| enumerator_list ‘,’ enumerator
;
enumerator
: IDENTIFIER
| IDENTIFIER ‘=’ constant_expression
;
type_qualifier
: CONST
| VOLATILE
;
declarator
: pointer direct_declarator
| direct_declarator
;
direct_declarator
: IDENTIFIER
| ‘(‘ declarator ‘)’
| direct_declarator ‘[‘ constant_expression ‘]’
| direct_declarator ‘[‘ ‘]’
| direct_declarator ‘(‘ parameter_type_list ‘)’
| direct_declarator ‘(‘ identifier_list ‘)’
| direct_declarator ‘(‘ ‘)’
;
pointer
: ‘*’
| ‘*’ type_qualifier_list
| ‘*’ pointer
| ‘*’ type_qualifier_list pointer
;
type_qualifier_list
: type_qualifier
| type_qualifier_list type_qualifier
;
parameter_type_list
: parameter_list
| parameter_list ‘,’ ELLIPSIS
;
parameter_list
: parameter_declaration
| parameter_list ‘,’ parameter_declaration
;
parameter_declaration
: declaration_specifiers declarator
| declaration_specifiers abstract_declarator
| declaration_specifiers
;
identifier_list
: IDENTIFIER
| identifier_list ‘,’ IDENTIFIER
;
type_name
: specifier_qualifier_list
| specifier_qualifier_list abstract_declarator
;
abstract_declarator
: pointer
| direct_abstract_declarator
| pointer direct_abstract_declarator
;
direct_abstract_declarator
: ‘(‘ abstract_declarator ‘)’
| ‘[‘ ‘]’
| ‘[‘ constant_expression ‘]’
| direct_abstract_declarator ‘[‘ ‘]’
| direct_abstract_declarator ‘[‘ constant_expression ‘]’
| ‘(‘ ‘)’
| ‘(‘ parameter_type_list ‘)’
| direct_abstract_declarator ‘(‘ ‘)’
| direct_abstract_declarator ‘(‘ parameter_type_list ‘)’
;
initializer
: assignment_expression
| ‘{‘ initializer_list ‘}’
| ‘{‘ initializer_list ‘,’ ‘}’
;
initializer_list
: initializer
| initializer_list ‘,’ initializer
;
statement
: labeled_statement
| compound_statement
| expression_statement
| selection_statement
| iteration_statement
| jump_statement
;
labeled_statement
: IDENTIFIER ‘:’ statement
| DEFAULT ‘:’ statement
;
compound_statement
: ‘{‘ ‘}’
| ‘{‘ statement_list ‘}’
| ‘{‘ declaration_list ‘}’
| ‘{‘ declaration_list statement_list ‘}’
;
declaration_list
: declaration
| declaration_list declaration
;
statement_list
: BEGIN |statement
| statement_list statement | END
;
expression_statement
: ‘;’
| expression ‘;’
;
selection_statement
: IF ‘(‘ expression ‘)’ statement %prec IF_WITHOUT_ELSE
| IF ‘(‘ expression ‘)’ statement ELSE statement
;
iteration_statement
: WHILE ‘(‘ expression ‘)’ statement
| DO statement WHILE ‘(‘ expression ‘)’ ‘;’
;
jump_statement
: GOTO IDENTIFIER ‘;’
| CONTINUE ‘;’
| BREAK ‘;’
| RETURN ‘;’
| RETURN expression ‘;’
;
translation_unit
: external_declaration
| translation_unit external_declaration
;
external_declaration
: function_definition
| declaration
;
function_definition
: declaration_specifiers declarator declaration_list compound_statement
| declaration_specifiers declarator compound_statement
| declarator declaration_list compound_statement
| declarator compound_statement
;
Using JISON Online. One can generate a parser, and then use RxJS …..
Or use Antlr, for scaffolding engineering, a state-of-the-art code generator, compiler-compiler, without the chicken-egg problem, I just thought it exists! and it bootstrapped, much like the first synthetic cell, it boots!
