## core functions
#include <getopt.h>
- static char Usage[] = "Usage: oceani --trace --print --noexec --brackets"
- "--section=SectionName prog.ocn\n";
+ static char Usage[] =
+ "Usage: oceani --trace --print --noexec --brackets --section=SectionName prog.ocn\n";
static const struct option long_options[] = {
{"trace", 0, NULL, 't'},
{"print", 0, NULL, 'p'},
char *section = NULL;
struct parse_context context = {
.config = {
- .ignored = (1 << TK_line_comment)
- | (1 << TK_block_comment)
- | (1 << TK_mark),
+ .ignored = (1 << TK_mark),
.number_chars = ".,_+- ",
.word_start = "_",
.word_cont = "_",
###### includes
#include <gmp.h>
- #include "string.h"
- #include "number.h"
+ #include "parse_string.h"
+ #include "parse_number.h"
###### libs
myLDLIBS := libnumber.o libstring.o -lgmp
$void
OpenScope -> ${ scope_push(c); }$
+ ClosePara -> ${ var_block_close(c, CloseParallel); }$
Each variable records a scope depth and is in one of four states:
}
###### 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;
- }
- } }$
+ DeclareStruct -> struct IDENTIFIER FieldBlock Newlines ${ {
+ 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;
+ }
+ } }$
- $void
- Open -> {
- | NEWLINE Open
- Close -> }
- | NEWLINE Close
$*fieldlist
- FieldBlock -> Open FieldList Close ${ $0 = $<2; }$
- | Open SimpleFieldList } ${ $0 = $<2; }$
- | : FieldList ${ $0 = $<2; }$
-
- FieldList -> SimpleFieldList NEWLINE ${ $0 = $<1; }$
- | FieldList SimpleFieldList NEWLINE ${
- $2->prev = $<1;
- $0 = $<2;
+ FieldBlock -> { IN OptNL FieldLines OUT OptNL } ${ $0 = $<FL; }$
+ | { SimpleFieldList } ${ $0 = $<SFL; }$
+ | IN OptNL FieldLines OUT ${ $0 = $<FL; }$
+ | SimpleFieldList EOL ${ $0 = $<SFL; }$
+
+ FieldLines -> SimpleFieldList Newlines ${ $0 = $<SFL; }$
+ | FieldLines SimpleFieldList Newlines ${
+ $SFL->prev = $<FL;
+ $0 = $<SFL;
}$
- SimpleFieldList -> Field ${ $0 = $<1; }$
+ SimpleFieldList -> Field ${ $0 = $<F; }$
| SimpleFieldList ; Field ${
- $3->prev = $<1;
- $0 = $<3;
+ $F->prev = $<SFL;
+ $0 = $<F;
}$
| SimpleFieldList ; ${
- $0 = $<1;
+ $0 = $<SFL;
}$
+ | ERROR ${ tok_err(c, "Syntax error in struct field", &$1); }$
Field -> IDENTIFIER : Type = Expression ${ {
int ok;
$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);
{
int i;
- fprintf(f, "struct %.*s:\n", t->name.len, t->name.txt);
+ fprintf(f, "struct %.*s\n", t->name.len, t->name.txt);
for (i = 0; i < t->structure.nfields; i++) {
struct field *fl = t->structure.fields + i;
###### 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
+ $TERM ( )
###### expression grammar
| Expression Eop Expression ${ {
###### Binode types
Block,
-###### Grammar
+###### expr precedence
+ $TERM pass
- $void
- Newlines -> NEWLINE
- | Newlines NEWLINE
+###### Grammar
$*binode
- Block -> Open Statementlist Close ${ $0 = $<2; }$
- | Open SimpleStatements } ${ $0 = reorder_bilist($<2); }$
- | : SimpleStatements ${ $0 = reorder_bilist($<2); }$
- | : Statementlist ${ $0 = $<2; }$
-
- Statementlist -> ComplexStatements ${ $0 = reorder_bilist($<1); }$
+ Block -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+ | { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
+ | SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
+ | SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
+ | IN OptNL Statementlist OUT ${ $0 = $<Sl; }$
+
+ OpenBlock -> OpenScope { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+ | OpenScope { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
+ | OpenScope SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
+ | OpenScope SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
+ | IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
+
+ UseBlock -> { OpenScope IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+ | { OpenScope SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
+ | IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
+
+ ColonBlock -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+ | { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
+ | : SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
+ | : SimpleStatements EOL ${ $0 = reorder_bilist($<SS); }$
+ | : IN OptNL Statementlist OUT ${ $0 = $<Sl; }$
+
+ Statementlist -> ComplexStatements ${ $0 = reorder_bilist($<CS); }$
ComplexStatements -> ComplexStatements ComplexStatement ${
if ($2 == NULL) {
}$
$*exec
- ComplexStatement -> SimpleStatements NEWLINE ${
- $0 = reorder_bilist($<1);
+ ComplexStatement -> SimpleStatements Newlines ${
+ $0 = reorder_bilist($<SS);
+ }$
+ | SimpleStatements ; Newlines ${
+ $0 = reorder_bilist($<SS);
}$
- | Newlines ${ $0 = NULL; }$
## ComplexStatement Grammar
$*binode
$0->left = NULL;
$0->right = $<1;
}$
- | SimpleStatements ; ${ $0 = $<1; }$
SimpleStatement -> pass ${ $0 = NULL; }$
| ERROR ${ tok_err(c, "Syntax error in statement", &$1); }$
###### Binode types
Print,
+##### expr precedence
+ $TERM print ,
+
###### SimpleStatement Grammar
| print ExpressionList ${
###### Binode types
Use,
+###### expr precedence
+ $TERM use
+
###### SimpleStatement Grammar
| use Expression ${
$0 = new_pos(binode, $1);
###### ComplexStatement Grammar
| CondStatement ${ $0 = $<1; }$
+###### expr precedence
+ $TERM for then while do
+ $TERM else
+ $TERM switch case
+
###### Grammar
$*cond_statement
- // both ForThen and Whilepart open scopes, and CondSuffix only
+ // A CondStatement must end with EOL, as does CondSuffix and
+ // IfSuffix.
+ // ForPart, ThenPart, SwitchPart, CasePart are non-empty and
+ // may or may not end with EOL
+ // WhilePart and IfPart include an appropriate Suffix
+
+
+ // Both ForPart 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 ${
- $0 = $<4;
- $0->forpart = $<1;
- $0->thenpart = $<2;
- $0->condpart = $3.condpart; $3.condpart = NULL;
- $0->dopart = $3.dopart; $3.dopart = NULL;
+ CondStatement -> ForPart OptNL ThenPart OptNL WhilePart CondSuffix ${
+ $0 = $<CS;
+ $0->forpart = $<FP;
+ $0->thenpart = $<TP;
+ $0->condpart = $WP.condpart; $WP.condpart = NULL;
+ $0->dopart = $WP.dopart; $WP.dopart = NULL;
var_block_close(c, CloseSequential);
}$
- | forPart WhilePart CondSuffix ${
- $0 = $<3;
- $0->forpart = $<1;
- $0->thenpart = NULL;
- $0->condpart = $2.condpart; $2.condpart = NULL;
- $0->dopart = $2.dopart; $2.dopart = NULL;
+ | ForPart OptNL WhilePart CondSuffix ${
+ $0 = $<CS;
+ $0->forpart = $<FP;
+ $0->condpart = $WP.condpart; $WP.condpart = NULL;
+ $0->dopart = $WP.dopart; $WP.dopart = NULL;
var_block_close(c, CloseSequential);
}$
- | whilePart CondSuffix ${
- $0 = $<2;
- $0->condpart = $1.condpart; $1.condpart = NULL;
- $0->dopart = $1.dopart; $1.dopart = NULL;
+ | WhilePart CondSuffix ${
+ $0 = $<CS;
+ $0->condpart = $WP.condpart; $WP.condpart = NULL;
+ $0->dopart = $WP.dopart; $WP.dopart = NULL;
+ }$
+ | SwitchPart OptNL CasePart CondSuffix ${
+ $0 = $<CS;
+ $0->condpart = $<SP;
+ $CP->next = $0->casepart;
+ $0->casepart = $<CP;
}$
- | switchPart CondSuffix ${
- $0 = $<2;
- $0->condpart = $<1;
+ | SwitchPart : IN OptNL CasePart CondSuffix OUT Newlines ${
+ $0 = $<CS;
+ $0->condpart = $<SP;
+ $CP->next = $0->casepart;
+ $0->casepart = $<CP;
}$
- | ifPart IfSuffix ${
- $0 = $<2;
- $0->condpart = $1.condpart; $1.condpart = NULL;
- $0->thenpart = $1.thenpart; $1.thenpart = NULL;
+ | IfPart IfSuffix ${
+ $0 = $<IS;
+ $0->condpart = $IP.condpart; $IP.condpart = NULL;
+ $0->thenpart = $IP.thenpart; $IP.thenpart = NULL;
// This is where we close an "if" statement
var_block_close(c, CloseSequential);
}$
// "for" or "while" statement
var_block_close(c, CloseSequential);
}$
+ | Newlines CasePart CondSuffix ${
+ $0 = $<CS;
+ $CP->next = $0->casepart;
+ $0->casepart = $<CP;
+ }$
| CasePart CondSuffix ${
- $0 = $<2;
- $1->next = $0->casepart;
- $0->casepart = $<1;
+ $0 = $<CS;
+ $CP->next = $0->casepart;
+ $0->casepart = $<CP;
}$
- $void
- Case -> case
- | NEWLINE Case
- $*casepart
- CasePart -> Case Expression OpenScope Block ${
- $0 = calloc(1,sizeof(struct casepart));
- $0->value = $<2;
- $0->action = $<4;
- var_block_close(c, CloseParallel);
- }$
+ IfSuffix -> Newlines ${ $0 = new(cond_statement); }$
+ | Newlines ElsePart ${ $0 = $<EP; }$
+ | ElsePart ${$0 = $<EP; }$
- $*cond_statement
- IfSuffix -> ${ $0 = new(cond_statement); }$
- | NEWLINE IfSuffix ${ $0 = $<2; }$
- | else OpenScope Block ${
+ ElsePart -> else OpenBlock Newlines ${
$0 = new(cond_statement);
- $0->elsepart = $<3;
+ $0->elsepart = $<OB;
var_block_close(c, CloseElse);
}$
| else OpenScope CondStatement ${
$0 = new(cond_statement);
- $0->elsepart = $<3;
+ $0->elsepart = $<CS;
var_block_close(c, CloseElse);
}$
- $void
- Then -> then
- | NEWLINE Then
- While -> while
- | NEWLINE While
- Do -> do
- | NEWLINE Do
+ $*casepart
+ CasePart -> case Expression OpenScope ColonBlock ${
+ $0 = calloc(1,sizeof(struct casepart));
+ $0->value = $<Ex;
+ $0->action = $<Bl;
+ var_block_close(c, CloseParallel);
+ }$
+
$*exec
// These scopes are closed in CondSuffix
- forPart -> for OpenScope SimpleStatements ${
- $0 = reorder_bilist($<3);
- }$
- | for OpenScope Block ${
- $0 = $<3;
+ ForPart -> for OpenBlock ${
+ $0 = $<Bl;
}$
- ThenPart -> Then OpenScope SimpleStatements ${
- $0 = reorder_bilist($<3);
- var_block_close(c, CloseSequential);
- }$
- | Then OpenScope Block ${
- $0 = $<3;
+ ThenPart -> then OpenBlock ${
+ $0 = $<OB;
var_block_close(c, CloseSequential);
}$
- // This scope is closed in CondSuffix
- WhileHead -> While OpenScope Block ${
- $0 = $<3;
- }$
- whileHead -> while OpenScope Block ${
- $0 = $<3;
- }$
-
$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 UseBlock OptNL do Block ${
+ $0.condpart = $<UB;
+ $0.dopart = $<Bl;
}$
- 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;
+ | while OpenScope Expression ColonBlock ${
+ $0.condpart = $<Exp;
+ $0.dopart = $<Bl;
}$
- ifPart -> if OpenScope Expression OpenScope Block ${
- $0.type = Xcond_statement;
- $0.condpart = $<3;
- $0.thenpart = $<5;
- var_block_close(c, CloseParallel);
+ IfPart -> if UseBlock OptNL then OpenBlock ClosePara ${
+ $0.condpart = $<UB;
+ $0.thenpart = $<Bl;
}$
- | if OpenScope Block Then OpenScope Block ${
- $0.type = Xcond_statement;
- $0.condpart = $<3;
- $0.thenpart = $<6;
- var_block_close(c, CloseParallel);
+ | if OpenScope Expression OpenScope ColonBlock ClosePara ${
+ $0.condpart = $<Ex;
+ $0.thenpart = $<Bl;
+ }$
+ | if OpenScope Expression OpenScope OptNL then Block ClosePara ${
+ $0.condpart = $<Ex;
+ $0.thenpart = $<Bl;
}$
$*exec
// This scope is closed in CondSuffix
- switchPart -> switch OpenScope Expression ${
- $0 = $<3;
+ SwitchPart -> switch OpenScope Expression ${
+ $0 = $<Ex;
}$
- | switch OpenScope Block ${
- $0 = $<3;
+ | switch UseBlock ${
+ $0 = $<Bl;
}$
###### print exec cases
struct casepart *cp;
if (cs->forpart) {
do_indent(indent, "for");
- if (bracket) printf(" {\n"); else printf(":\n");
+ if (bracket) printf(" {\n"); else printf("\n");
print_exec(cs->forpart, indent+1, bracket);
if (cs->thenpart) {
if (bracket)
do_indent(indent, "} then {\n");
else
- do_indent(indent, "then:\n");
+ do_indent(indent, "then\n");
print_exec(cs->thenpart, indent+1, bracket);
}
if (bracket) do_indent(indent, "}\n");
if (bracket)
do_indent(indent, "while {\n");
else
- do_indent(indent, "while:\n");
+ do_indent(indent, "while\n");
print_exec(cs->condpart, indent+1, bracket);
if (bracket)
do_indent(indent, "} do {\n");
else
- do_indent(indent, "do:\n");
+ do_indent(indent, "do\n");
print_exec(cs->dopart, indent+1, bracket);
if (bracket)
do_indent(indent, "}\n");
if (bracket)
printf(" {\n");
else
- printf(":\n");
+ printf("\n");
print_exec(cs->elsepart, indent+1, bracket);
if (bracket)
do_indent(indent, "}\n");
###### Parser: grammar
$void
- Ocean -> DeclarationList
+ Ocean -> OptNL DeclarationList
+
+ OptNL ->
+ | OptNL NEWLINE
+ Newlines -> NEWLINE
+ | Newlines NEWLINE
DeclarationList -> Declaration
| DeclarationList Declaration
- Declaration -> DeclareConstant
- | DeclareProgram
- | DeclareStruct
- | NEWLINE
- | ERROR NEWLINE ${
+ Declaration -> ERROR Newlines ${
tok_err(c,
"error: unhandled parse error", &$1);
}$
+ | DeclareConstant
+ | DeclareProgram
+ | DeclareStruct
## top level grammar
###### top level grammar
- DeclareConstant -> const Open ConstList Close
- | const Open SimpleConstList }
- | const : ConstList
- | const SimpleConstList NEWLINE
+ DeclareConstant -> const { IN OptNL ConstList OUT OptNL } Newlines
+ | const { SimpleConstList } Newlines
+ | const IN OptNL ConstList OUT Newlines
+ | const SimpleConstList Newlines
- ConstList -> ComplexConsts
- | NEWLINE ConstList
- ComplexConsts -> ComplexConst ComplexConsts
- | ComplexConst
- ComplexConst -> SimpleConstList NEWLINE
+ ConstList -> ConstList SimpleConstLine
+ | SimpleConstLine
SimpleConstList -> SimpleConstList ; Const
| Const
| SimpleConstList ;
+ SimpleConstLine -> SimpleConstList Newlines
+ | ERROR Newlines ${ 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
{
if (target == -1) {
if (i)
- printf("const:\n");
+ printf("const\n");
target = i;
} else {
printf(" %.*s :: ", v->name->name.len, v->name->name.txt);
} }$
$*binode
- Program -> program OpenScope Varlist Block ${
+ Program -> program OpenScope Varlist ColonBlock Newlines ${
$0 = new(binode);
$0->op = Program;
- $0->left = reorder_bilist($<3);
- $0->right = $<4;
+ $0->left = reorder_bilist($<Vl);
+ $0->right = $<Bl;
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);
###### demo: hello
- const:
+ const
pi ::= 3.141_592_6
four ::= 2 + 2 ; five ::= 10/2
const pie ::= "I like Pie";
cake ::= "The cake is"
++ " a lie"
- struct fred:
+ struct fred
size:[four]number
name:string
alive:Boolean
*/
if A > B:
bigger := "yes"
- else:
+ else
bigger := "no"
print "Is", A, "bigger than", B,"? ", bigger
/* If a variable is not used after the 'if', no
if A > B * 2:
double:string = "yes"
print A, "is more than twice", B, "?", double
- else:
+ else
double := B*2
print "double", B, "is", double
while a != b:
if a < b:
b = b - a
- else:
+ else
a = a - b
print "GCD of", A, "and", B,"is", a
else if a <= 0:
print a, "is not positive, cannot calculate GCD"
- else:
+ else
print b, "is not positive, cannot calculate GCD"
- for:
+ for
togo := 10
f1 := 1; f2 := 1
print "Fibonacci:", f1,f2,
print ""
/* Binary search... */
- for:
+ for
lo:= 0; hi := 100
target := 77
- while:
+ while
mid := (lo + hi) / 2
if mid == target:
use Found
if mid < target:
lo = mid
- else:
+ else
hi = mid
if hi - lo < 1:
use GiveUp
use True
- do: pass
+ do pass
case Found:
print "Yay, I found", target
case GiveUp:
print "", list[i],
print
+ if 1 == 2 then print "yes"; else print "no"
+
bob:fred
bob.name = "Hello"
bob.alive = (bob.name == "Hello")