###### top level grammar
DeclareStruct -> struct IDENTIFIER FieldBlock ${ {
- struct type *t =
- add_type(c, $2.txt, &structure_prototype);
- int cnt = 0;
- struct fieldlist *f;
-
- for (f = $3; f; f=f->prev)
- cnt += 1;
-
- t->structure.nfields = cnt;
- t->structure.fields = calloc(cnt, sizeof(struct field));
- f = $3;
- while (cnt > 0) {
- cnt -= 1;
- t->structure.fields[cnt] = f->f;
- f->f.init = val_prepare(Tnone);
- f = f->prev;
- }
- } }$
+ struct type *t =
+ add_type(c, $2.txt, &structure_prototype);
+ int cnt = 0;
+ struct fieldlist *f;
+
+ for (f = $3; f; f=f->prev)
+ cnt += 1;
+
+ t->structure.nfields = cnt;
+ t->structure.fields = calloc(cnt, sizeof(struct field));
+ f = $3;
+ while (cnt > 0) {
+ cnt -= 1;
+ t->structure.fields[cnt] = f->f;
+ f->f.init = val_prepare(Tnone);
+ f = f->prev;
+ }
+ } }$
+ | DeclareStruct NEWLINE
$void
Open -> {
Close -> }
| NEWLINE Close
$*fieldlist
- FieldBlock -> Open FieldList Close ${ $0 = $<2; }$
+ FieldBlock -> Open FieldList } ${ $0 = $<2; }$
| Open SimpleFieldList } ${ $0 = $<2; }$
- | : FieldList ${ $0 = $<2; }$
+ | : FieldList $$NEWLINE ${ $0 = $<2; }$
- FieldList -> SimpleFieldList NEWLINE ${ $0 = $<1; }$
- | FieldList SimpleFieldList NEWLINE ${
+ FieldList -> FieldLines ${ $0 = $<1; }$
+ | NEWLINE FieldLines ${ $0 = $<2; }$
+ FieldLines -> SimpleFieldListLine ${ $0 = $<1; }$
+ | FieldLines SimpleFieldListLine ${
$2->prev = $<1;
$0 = $<2;
}$
+ SimpleFieldListLine -> SimpleFieldList NEWLINE ${ $0 = $<1; }$
+ | SimpleFieldListLine NEWLINE ${ $0 = $<1; }$
+ | ERROR NEWLINE ${ tok_err(c, "Syntax error in struct field", &$1); }$
+
SimpleFieldList -> Field ${ $0 = $<1; }$
| SimpleFieldList ; Field ${
$3->prev = $<1;
$0->f.type = $<3;
$0->f.init = val_init($3);
}$
- | ERROR ${ tok_err(c, "Syntax error in struct field", &$1); }$
###### forward decls
static void structure_print_type(struct type *t, FILE *f);
###### Grammar
- $LEFT $$ifelse
+ $LEFT if $$ifelse
## expr precedence
$*exec
NEql,
###### expr precedence
- $LEFT CMPop
+ $LEFT < > <= >= == != CMPop
###### expression grammar
| Expression CMPop Expression ${ {
Bracket,
###### expr precedence
- $LEFT Eop
- $LEFT Top
+ $LEFT + - Eop
+ $LEFT * / % ++ Top
$LEFT Uop
###### expression grammar
###### Grammar
- $void
- Newlines -> NEWLINE
- | Newlines NEWLINE
-
$*binode
Block -> Open Statementlist Close ${ $0 = $<2; }$
| Open SimpleStatements } ${ $0 = reorder_bilist($<2); }$
- | : SimpleStatements ${ $0 = reorder_bilist($<2); }$
- | : Statementlist ${ $0 = $<2; }$
+ | : SimpleStatements $$NEWLINE ${ $0 = reorder_bilist($<2); }$
+ | : Statementlist $$NEWLINE ${ $0 = $<2; }$
Statementlist -> ComplexStatements ${ $0 = reorder_bilist($<1); }$
+ | NEWLINE Statementlist ${ $0 = $<2; }$
ComplexStatements -> ComplexStatements ComplexStatement ${
if ($2 == NULL) {
}$
$*exec
- ComplexStatement -> SimpleStatements NEWLINE ${
+ ComplexStatement -> SimpleStatementLine ${
$0 = reorder_bilist($<1);
}$
- | Newlines ${ $0 = NULL; }$
+ | ComplexStatement NEWLINE ${ $0 = $<1; }$
## ComplexStatement Grammar
$*binode
}$
| SimpleStatements ; ${ $0 = $<1; }$
+ SimpleStatementLine -> SimpleStatements NEWLINE ${ $0 = $<1; }$
+ | SimpleStatementLine NEWLINE ${ $0 = $<1; }$
+
SimpleStatement -> pass ${ $0 = NULL; }$
| ERROR ${ tok_err(c, "Syntax error in statement", &$1); }$
## SimpleStatement Grammar
$*cond_statement
// both ForThen and Whilepart open scopes, and CondSuffix only
// closes one - so in the first branch here we have another to close.
- CondStatement -> forPart ThenPart WhilePart CondSuffix ${
+ CondStatement -> ForPart ThenPart WhilePart CondSuffix ${
$0 = $<4;
$0->forpart = $<1;
$0->thenpart = $<2;
$0->dopart = $3.dopart; $3.dopart = NULL;
var_block_close(c, CloseSequential);
}$
- | forPart WhilePart CondSuffix ${
+ | ForPart WhilePart CondSuffix ${
$0 = $<3;
$0->forpart = $<1;
$0->thenpart = NULL;
$0->dopart = $2.dopart; $2.dopart = NULL;
var_block_close(c, CloseSequential);
}$
- | whilePart CondSuffix ${
+ | WhilePart CondSuffix ${
$0 = $<2;
$0->condpart = $1.condpart; $1.condpart = NULL;
$0->dopart = $1.dopart; $1.dopart = NULL;
}$
- | switchPart CondSuffix ${
- $0 = $<2;
+ | SwitchPart CasePart CondSuffix ${
+ $0 = $<3;
$0->condpart = $<1;
+ $2->next = $0->casepart;
+ $0->casepart = $<2;
}$
- | ifPart IfSuffix ${
+ | IfPart IfSuffix ${
$0 = $<2;
$0->condpart = $1.condpart; $1.condpart = NULL;
$0->thenpart = $1.thenpart; $1.thenpart = NULL;
$0->casepart = $<1;
}$
- $void
- Case -> case
- | NEWLINE Case
$*casepart
- CasePart -> Case Expression OpenScope Block ${
+ CasePart -> case Expression OpenScope Block ${
$0 = calloc(1,sizeof(struct casepart));
$0->value = $<2;
$0->action = $<4;
var_block_close(c, CloseParallel);
}$
+ | CasePart NEWLINE ${ $0 = $<1; }$
$*cond_statement
IfSuffix -> ${ $0 = new(cond_statement); }$
- | NEWLINE IfSuffix ${ $0 = $<2; }$
+ | IfSuffix NEWLINE ${ $0 = $<1; }$
| else OpenScope Block ${
$0 = new(cond_statement);
$0->elsepart = $<3;
var_block_close(c, CloseElse);
}$
- $void
- Then -> then
- | NEWLINE Then
- While -> while
- | NEWLINE While
- Do -> do
- | NEWLINE Do
$*exec
// These scopes are closed in CondSuffix
- forPart -> for OpenScope SimpleStatements ${
+ ForPart -> for OpenScope SimpleStatements ${
$0 = reorder_bilist($<3);
}$
| for OpenScope Block ${
$0 = $<3;
}$
+ | ForPart NEWLINE ${ $0 = $<1; }$
- ThenPart -> Then OpenScope SimpleStatements ${
+ ThenPart -> then OpenScope SimpleStatements ${
$0 = reorder_bilist($<3);
var_block_close(c, CloseSequential);
}$
- | Then OpenScope Block ${
+ | then OpenScope Block ${
$0 = $<3;
var_block_close(c, CloseSequential);
}$
+ | ThenPart NEWLINE ${ $0 = $<1; }$
// This scope is closed in CondSuffix
- WhileHead -> While OpenScope Block ${
- $0 = $<3;
- }$
- whileHead -> while OpenScope Block ${
- $0 = $<3;
- }$
+ WhileHead -> while OpenScope Block ${ $0 = $<3; }$
+ | WhileHead NEWLINE ${ $0 = $<1; }$
$cond_statement
// This scope is closed in CondSuffix
- whilePart -> while OpenScope Expression Block ${
- $0.type = Xcond_statement;
- $0.condpart = $<3;
- $0.dopart = $<4;
- }$
- | whileHead Do Block ${
- $0.type = Xcond_statement;
- $0.condpart = $<1;
- $0.dopart = $<3;
- }$
- WhilePart -> While OpenScope Expression Block ${
+ WhilePart -> while OpenScope Expression Block ${
$0.type = Xcond_statement;
$0.condpart = $<3;
$0.dopart = $<4;
}$
- | WhileHead Do Block ${
+ | WhileHead do Block ${
$0.type = Xcond_statement;
$0.condpart = $<1;
$0.dopart = $<3;
}$
+ | WhilePart NEWLINE ${ $0 = $<1; }$
- ifPart -> if OpenScope Expression OpenScope Block ${
+ IfPart -> if OpenScope Expression OpenScope Block ${
$0.type = Xcond_statement;
$0.condpart = $<3;
$0.thenpart = $<5;
var_block_close(c, CloseParallel);
}$
- | if OpenScope Block Then OpenScope Block ${
+ | if OpenScope Block then OpenScope Block ${
$0.type = Xcond_statement;
$0.condpart = $<3;
$0.thenpart = $<6;
var_block_close(c, CloseParallel);
}$
+ | IfPart NEWLINE ${ $0 = $<1; }$
$*exec
// This scope is closed in CondSuffix
- switchPart -> switch OpenScope Expression ${
+ SwitchPart -> switch OpenScope Expression ${
$0 = $<3;
}$
| switch OpenScope Block ${
$0 = $<3;
}$
+ | SwitchPart NEWLINE ${ $0 = $<1; }$
###### print exec cases
$void
Ocean -> DeclarationList
+ | NEWLINE Ocean
DeclarationList -> Declaration
| DeclarationList Declaration
- Declaration -> DeclareConstant
+ Declaration -> Declaration NEWLINE
+ | DeclareConstant
| DeclareProgram
| DeclareStruct
- | NEWLINE
| ERROR NEWLINE ${
tok_err(c,
"error: unhandled parse error", &$1);
DeclareConstant -> const Open ConstList Close
| const Open SimpleConstList }
- | const : ConstList
+ | const : ConstList $$NEWLINE
| const SimpleConstList NEWLINE
- ConstList -> ComplexConsts
+ ConstList -> ConstLines
| NEWLINE ConstList
- ComplexConsts -> ComplexConst ComplexConsts
- | ComplexConst
- ComplexConst -> SimpleConstList NEWLINE
+ ConstLines -> ConstLines SimpleConstLine
+ | SimpleConstLine
SimpleConstList -> SimpleConstList ; Const
| Const
| SimpleConstList ;
+ SimpleConstLine -> SimpleConstList NEWLINE
+ | SimpleConstLine NEWLINE
+ | ERROR NEWLINE ${ tok_err(c, "Syntax error in constant", &$1); }$
$*type
CType -> Type ${ $0 = $<1; }$
v->val = interp_exec($5);
}
} }$
- | ERROR NEWLINE ${ tok_err(c, "Syntax error in constant", &$1); }$
###### print const decls
{
var_block_close(c, CloseSequential);
if (c->scope_stack && !c->parse_error) abort();
}$
- | ERROR ${
- tok_err(c,
- "error: unhandled parse error", &$1);
- }$
Varlist -> Varlist ArgDecl ${
$0 = new(binode);