Some operators that have only recently been added, and so have not
generated all that much experience yet are "and then" and "or else" as
-short-circuit Boolean operators, and the "if ... else" trinary
-operator which can select between two expressions based on a third
-(which appears syntactically in the middle).
+short-circuit Boolean operators (which have since been remove), and the
+"if ... else" trinary operator which can select between two expressions
+based on a third (which appears syntactically in the middle).
The "func" clause currently only allows a "main" function to be
declared. That will be extended when proper function support is added.
{
int cmp;
if (tl != tr)
- return tl - tr; // NOTEST
+ return tl - tr;
switch (tl->vtype) {
case Vlabel: cmp = left->label == right->label ? 0 : 1; break;
case Vnum: cmp = mpq_cmp(left->num, right->num); break;
if (v->merged != v)
continue;
if (!t)
- continue;
+ continue; // NOTEST
if (v->frame_pos >= 0)
continue;
while (done && done->scope_end < v->scope_start)
struct value *vsize;
mpz_t q;
if (type->array.static_size)
- return 1; // UNTESTED
+ return 1; // NOTEST - guard against reentry
if (type->array.unspec && parse_time)
- return 1; // UNTESTED
+ return 1; // NOTEST - unspec is still incomplete
if (parse_time && type->array.vsize && !type->array.vsize->global)
- return 1; // UNTESTED
+ return 1; // NOTEST - should be impossible
if (type->array.vsize) {
vsize = var_value(c, type->array.vsize);
if (!vsize)
- return 1; // UNTESTED
+ return 1; // NOTEST - should be impossible
mpz_init(q);
mpz_tdiv_q(q, mpq_numref(vsize->num), mpq_denref(vsize->num));
type->array.size = mpz_get_si(q);
if (!parse_time)
return 1;
if (type->array.member->size <= 0)
- return 0; // UNTESTED
+ return 0; // NOTEST - error caught before here
type->array.static_size = 1;
type->size = type->array.size * type->array.member->size;
| SimpleFieldList EOL ${ $0 = $<SFL; }$
FieldLines -> SimpleFieldList Newlines ${ $0 = $<SFL; }$
- | FieldLines SimpleFieldList Newlines ${
- $SFL->prev = $<FL;
- $0 = $<SFL;
- }$
+ | FieldLines SimpleFieldList Newlines ${ {
+ struct fieldlist *f = $<SFL;
+
+ if (f) {
+ $0 = f;
+ while (f->prev)
+ f = f->prev;
+ f->prev = $<FL;
+ } else
+ $0 = $<FL;
+ } }$
SimpleFieldList -> Field ${ $0 = $<F; }$
| SimpleFieldList ; Field ${
case AddressOf:
/* left must be lval, we create reference to it */
if (!type || type->free != reference_free)
- t = propagate_types(b->left, c, perr, type, 0); // UNTESTED
+ t = propagate_types(b->left, c, perr, type, 0); // NOTEST impossible
else
t = propagate_types(b->left, c, perr,
type->reference.referent, 0);
static void function_print(struct type *type, struct value *val, FILE *f)
{
+ fprintf(f, "\n");
print_exec(val->function, 1, 0);
}
} else
type_print(type->function.return_type, f);
}
- fprintf(f, "\n");
}
static void function_free_type(struct type *t)
### Expressions: Boolean
The next class of expressions to use the `binode` will be Boolean
-expressions. "`and then`" and "`or else`" are similar to `and` and `or`
-have same corresponding precendence. The difference is that they don't
+expressions. `and` and `or` are short-circuit operators that don't
evaluate the second expression if not necessary.
###### Binode types
And,
- AndThen,
Or,
- OrElse,
Not,
###### declare terminals
b->right = $<3;
$0 = b;
} }$
- | Expression or else Expression ${ {
- struct binode *b = new(binode);
- b->op = OrElse;
- b->left = $<1;
- b->right = $<4;
- $0 = b;
- } }$
-
| Expression and Expression ${ {
struct binode *b = new(binode);
b->op = And;
b->right = $<3;
$0 = b;
} }$
- | Expression and then Expression ${ {
- struct binode *b = new(binode);
- b->op = AndThen;
- b->left = $<1;
- b->right = $<4;
- $0 = b;
- } }$
-
| not Expression ${ {
struct binode *b = new(binode);
b->op = Not;
print_exec(b->right, -1, bracket);
if (bracket) printf(")");
break;
- case AndThen:
- if (bracket) printf("(");
- print_exec(b->left, -1, bracket);
- printf(" and then ");
- print_exec(b->right, -1, bracket);
- if (bracket) printf(")");
- break;
case Or:
if (bracket) printf("(");
print_exec(b->left, -1, bracket);
print_exec(b->right, -1, bracket);
if (bracket) printf(")");
break;
- case OrElse:
- if (bracket) printf("(");
- print_exec(b->left, -1, bracket);
- printf(" or else ");
- print_exec(b->right, -1, bracket);
- if (bracket) printf(")");
- break;
case Not:
if (bracket) printf("(");
printf("not ");
###### propagate binode cases
case And:
- case AndThen:
case Or:
- case OrElse:
case Not:
/* both must be Tbool, result is Tbool */
propagate_types(b->left, c, perr, Tbool, 0);
###### interp binode cases
case And:
- rv = interp_exec(c, b->left, &rvtype);
- right = interp_exec(c, b->right, &rtype);
- rv.bool = rv.bool && right.bool;
- break;
- case AndThen:
rv = interp_exec(c, b->left, &rvtype);
if (rv.bool)
rv = interp_exec(c, b->right, NULL);
break;
case Or:
- rv = interp_exec(c, b->left, &rvtype);
- right = interp_exec(c, b->right, &rtype);
- rv.bool = rv.bool || right.bool;
- break;
- case OrElse:
rv = interp_exec(c, b->left, &rvtype);
if (!rv.bool)
rv = interp_exec(c, b->right, NULL);
if (bracket) printf(")");
break;
case Bracket:
- printf("(");
+ /* Avoid double brackets... */
+ if (!bracket) printf("(");
print_exec(b->right, indent, bracket);
- printf(")");
+ if (!bracket) printf(")");
break;
###### propagate binode cases
Block -> { IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
| { SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
| SimpleStatements ; ${ $0 = reorder_bilist($<SS); }$
- | SimpleStatements EOL ${ $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 EOL ${ $0 = reorder_bilist($<SS); }$
| IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
- UseBlock -> { OpenScope IN OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
+ UseBlock -> { IN OpenScope OptNL Statementlist OUT OptNL } ${ $0 = $<Sl; }$
| { OpenScope SimpleStatements } ${ $0 = reorder_bilist($<SS); }$
| IN OpenScope OptNL Statementlist OUT ${ $0 = $<Sl; }$
ComplexStatements -> ComplexStatements ComplexStatement ${
if ($2 == NULL) {
- $0 = $<1;
+ $0 = $<1; // NOTEST - impossible
} else {
$0 = new(binode);
$0->op = Block;
}$
| ComplexStatement ${
if ($1 == NULL) {
- $0 = NULL;
+ $0 = NULL; // NOTEST - impossible
} else {
$0 = new(binode);
$0->op = Block;
struct binode *e;
for (e = b; e; e = cast(binode, e->right)) {
- t = propagate_types(e->left, c, perr, NULL, rules);
+ *perr |= *perr_local;
+ *perr_local = 0;
+ t = propagate_types(e->left, c, perr_local, NULL, rules);
if ((rules & Rboolok) && (t == Tbool || t == Tnone))
t = NULL;
if (t == Tnone && e->right)
be declared at any time.
###### Binode types
- Assign, AssignRef,
- Declare, DeclareRef,
+ Assign,
+ Declare,
###### declare terminals
$TERM =
###### print binode cases
case Assign:
- case AssignRef:
do_indent(indent, "");
print_exec(b->left, -1, bracket);
printf(" = ");
break;
case Declare:
- case DeclareRef:
{
struct variable *v = cast(var, b->left)->var;
do_indent(indent, "");
###### propagate binode cases
case Assign:
- case AssignRef:
case Declare:
- case DeclareRef:
/* Both must match, or left may be ref and right an lval
* Type must support 'dup',
* For Assign, left must not be constant.
; // No more effort needed
else if (t->free == reference_free &&
t->reference.referent == t2 &&
- !(*perr_local & Erval)) {
- if (b->op == Assign)
- b->op = AssignRef;
- if (b->op == Declare)
- b->op = DeclareRef;
- }
+ !(*perr_local & Erval))
+ b->right = take_addr(b->right);
else if (t->free == reference_free &&
t->reference.referent == t2 &&
(*perr_local & Erval))
if (*perr & Erval)
type_err(c, "error: cannot assign to an rval", b,
NULL, 0, NULL);
- else if ((b->op == Assign || b->op == AssignRef) && (*perr & Econst)) {
+ else if (b->op == Assign && (*perr & Econst)) {
type_err(c, "error: Cannot assign to a constant: %v",
b->left, NULL, 0, NULL);
if (b->left->type == Xvar) {
###### interp binode cases
case Assign:
- case AssignRef:
lleft = linterp_exec(c, b->left, <ype);
- if (!lleft)
- // FIXME lleft==NULL probably means illegal array ref
- // should that cause a runtime error
- ;
- else if (b->op == AssignRef)
- lleft->ref = linterp_exec(c, b->right, &rtype);
- else
+ if (lleft)
dinterp_exec(c, b->right, lleft, ltype, 1);
ltype = Tnone;
break;
case Declare:
- case DeclareRef:
{
struct variable *v = cast(var, b->left)->var;
struct value *val;
v->type->prepare_type(c, v->type, 0);
if (!b->right)
val_init(v->type, val);
- else if (b->op == DeclareRef)
- val->ref = linterp_exec(c, b->right, &rtype);
else
dinterp_exec(c, b->right, val, v->type, 0);
break;
struct value *val = var_value(&context, v);
printf("func %.*s", v->name->name.len, v->name->name.txt);
v->type->print_type_decl(v->type, stdout);
- if (brackets)
- print_exec(val->function, 0, brackets);
- else
+ if (brackets) {
+ printf(" {\n");
+ print_exec(val->function, 1, brackets);
+ printf("}\n");
+ } else {
print_value(v->type, val, stdout);
+ }
printf("/* frame size %d */\n", v->type->function.local_size);
target -= 1;
}
a : number
a = A;
b:number = B
- if a > 0 and then b > 0:
+ if a > 0 and b > 0:
while a != b:
if a < b:
b = b - a