Rather than embed the type in ever value, keep it separate.
This allows arrays without duplicating the member-type information.
Also review and clean up the commentary.
Signed-off-by: NeilBrown <neil@brown.name>
that uses bracketing. So a `--bracket` command line option is needed
for that. Normally the first code section found is used, however an
alternate section can be requested so that a file (such as this one)
that uses bracketing. So a `--bracket` command line option is needed
for that. Normally the first code section found is used, however an
alternate section can be requested so that a file (such as this one)
-can contain multiple programs This is effected with the `--section`
+can contain multiple programs. This is effected with the `--section`
option.
This code must be compiled with `-fplan9-extensions` so that anonymous
option.
This code must be compiled with `-fplan9-extensions` so that anonymous
If the same variable is declared in both branchs of an 'if/else', or
in all cases of a 'switch' then the multiple instances may be merged
If the same variable is declared in both branchs of an 'if/else', or
in all cases of a 'switch' then the multiple instances may be merged
-into just one variable if the variable is references after the
+into just one variable if the variable is referenced after the
conditional statement. When this happens, the types must naturally be
consistent across all the branches. When the variable is not used
outside the if, the variables in the different branches are distinct
conditional statement. When this happens, the types must naturally be
consistent across all the branches. When the variable is not used
outside the if, the variables in the different branches are distinct
element where its type was set. For now we will assume that each line
of an error message indicates one location in the file, and up to 2
types. So we provide a `printf`-like function which takes a format, a
element where its type was set. For now we will assume that each line
of an error message indicates one location in the file, and up to 2
types. So we provide a `printf`-like function which takes a format, a
-language (a `struct exec` which has not yet been introduced), and 2
+location (a `struct exec` which has not yet been introduced), and 2
types. "`%1`" reports the first type, "`%2`" reports the second. We
will need a function to print the location, once we know how that is
types. "`%1`" reports the first type, "`%2`" reports the second. We
will need a function to print the location, once we know how that is
-stored. As will be explained later, there are sometimes extra rules for
+stored. e As will be explained later, there are sometimes extra rules for
type matching and they might affect error messages, we need to pass those
in too.
type matching and they might affect error messages, we need to pass those
in too.
needs to know about to parse and execute a program. These include
types, variables, values, and executable code. These are all lumped
together under the term "entities" (calling them "objects" would be
needs to know about to parse and execute a program. These include
types, variables, values, and executable code. These are all lumped
together under the term "entities" (calling them "objects" would be
-confusing) and introduced here. These will introduced and described
-here. The following section will present the different specific code
-elements which comprise or manipulate these various entities.
+confusing) and introduced here. The following section will present the
+different specific code elements which comprise or manipulate these
+various entities.
Rather than requiring every numeric type to support all numeric
operations (add, multiple, etc), we allow types to be able to present
as one of a few standard types: integer, float, and fraction. The
Rather than requiring every numeric type to support all numeric
operations (add, multiple, etc), we allow types to be able to present
as one of a few standard types: integer, float, and fraction. The
-existence of these conversion functions eventaully enable types to
+existence of these conversion functions eventually enable types to
determine if they are compatible with other types, though such types
have not yet been implemented.
determine if they are compatible with other types, though such types
have not yet been implemented.
-Named type are stored in a simple linked list. Objects of each type are "values"
-which are often passed around by value.
+Named type are stored in a simple linked list. Objects of each type are
+"values" which are often passed around by value.
###### ast
struct value {
###### ast
struct value {
## value union fields
};
};
## value union fields
};
};
struct type {
struct text name;
struct type *next;
struct type {
struct text name;
struct type *next;
- struct value (*init)(struct type *type);
- struct value (*prepare)(struct type *type);
- struct value (*parse)(struct type *type, char *str);
- void (*print)(struct value val);
+ int size, align;
+ void (*init)(struct type *type, struct value *val);
+ int (*parse)(struct type *type, char *str, struct value *val);
+ void (*print)(struct type *type, struct value *val);
void (*print_type)(struct type *type, FILE *f);
void (*print_type)(struct type *type, FILE *f);
- int (*cmp_order)(struct value v1, struct value v2);
- int (*cmp_eq)(struct value v1, struct value v2);
- struct value (*dup)(struct value val);
- void (*free)(struct value val);
+ int (*cmp_order)(struct type *t1, struct type *t2,
+ struct value *v1, struct value *v2);
+ int (*cmp_eq)(struct type *t1, struct type *t2,
+ struct value *v1, struct value *v2);
+ void (*dup)(struct type *type, struct value *vold, struct value *vnew);
+ void (*free)(struct type *type, struct value *val);
void (*free_type)(struct type *t);
void (*free_type)(struct type *t);
- int (*compat)(struct type *this, struct type *other);
long long (*to_int)(struct value *v);
double (*to_float)(struct value *v);
int (*to_mpq)(mpq_t *q, struct value *v);
long long (*to_int)(struct value *v);
double (*to_float)(struct value *v);
int (*to_mpq)(mpq_t *q, struct value *v);
- static void free_value(struct value v)
- {
- if (v.type)
- v.type->free(v);
- }
-
- static int type_compat(struct type *require, struct type *have, int rules)
+ static void free_value(struct type *type, struct value *v)
- if ((rules & Rboolok) && have == Tbool)
- return 1;
- if ((rules & Rnolabel) && have == Tlabel)
- return 0;
- if (!require || !have)
- return 1;
-
- if (require->compat)
- return require->compat(require, have);
-
- return require == have;
+ if (type && v)
+ type->free(type, v);
}
static void type_print(struct type *type, FILE *f)
}
static void type_print(struct type *type, FILE *f)
fputs("*invalid*type*", f); // NOTEST
}
fputs("*invalid*type*", f); // NOTEST
}
- static struct value val_prepare(struct type *type)
+ static void val_init(struct type *type, struct value *val)
- struct value rv;
-
- if (type)
- return type->prepare(type);
- rv.type = type;
- return rv;
- }
-
- static struct value val_init(struct type *type)
- {
- struct value rv;
-
- if (type)
- return type->init(type);
- rv.type = type;
- return rv;
+ if (type && type->init)
+ type->init(type, val);
- static struct value dup_value(struct value v)
+ static void dup_value(struct type *type,
+ struct value *vold, struct value *vnew)
- if (v.type)
- return v.type->dup(v);
- return v;
+ if (type && type->dup)
+ type->dup(type, vold, vnew);
- static int value_cmp(struct value left, struct value right)
+ static int value_cmp(struct type *tl, struct type *tr,
+ struct value *left, struct value *right)
- if (left.type && left.type->cmp_order)
- return left.type->cmp_order(left, right);
- if (left.type && left.type->cmp_eq)
- return left.type->cmp_eq(left, right);
+ if (tl && tl->cmp_order)
+ return tl->cmp_order(tl, tr, left, right);
+ if (tl && tl->cmp_eq)
+ return tl->cmp_eq(tl, tr, left, right);
- static void print_value(struct value v)
+ static void print_value(struct type *type, struct value *v)
- if (v.type && v.type->print)
- v.type->print(v);
+ if (type && type->print)
+ type->print(type, v);
else
printf("*Unknown*"); // NOTEST
}
else
printf("*Unknown*"); // NOTEST
}
- static struct value parse_value(struct type *type, char *arg)
+ static int parse_value(struct type *type, char *arg,
+ struct value *val)
- return type->parse(type, arg);
- rv.type = NULL; // NOTEST
- return rv; // NOTEST
+ return type->parse(type, arg, val);
+ return 0; // NOTEST
+ }
+
+ static struct value *val_alloc(struct type *t, struct value *init)
+ {
+ struct value *ret;
+
+ if (!t->size)
+ val_init(t, NULL);
+ ret = calloc(1, t->size);
+ if (init)
+ memcpy(ret, init, t->size);
+ else
+ val_init(t, ret);
+ return ret;
- static void free_value(struct value v);
+ static void free_value(struct type *type, struct value *v);
static int type_compat(struct type *require, struct type *have, int rules);
static void type_print(struct type *type, FILE *f);
static int type_compat(struct type *require, struct type *have, int rules);
static void type_print(struct type *type, FILE *f);
- static struct value val_init(struct type *type);
- static struct value dup_value(struct value v);
- static int value_cmp(struct value left, struct value right);
- static void print_value(struct value v);
- static struct value parse_value(struct type *type, char *arg);
+ static void val_init(struct type *type, struct value *v);
+ static void dup_value(struct type *type,
+ struct value *vold, struct value *vnew);
+ static int value_cmp(struct type *tl, struct type *tr,
+ struct value *left, struct value *right);
+ static void print_value(struct type *type, struct value *v);
+ static int parse_value(struct type *type, char *arg, struct value *val);
###### free context types
###### free context types
primary type, and in others any type is acceptable except a label (`Vlabel`).
A separate function encoding these cases will simplify some code later.
primary type, and in others any type is acceptable except a label (`Vlabel`).
A separate function encoding these cases will simplify some code later.
+## type functions
+
+ int (*compat)(struct type *this, struct type *other);
+
+## ast functions
+
+ static int type_compat(struct type *require, struct type *have, int rules)
+ {
+ if ((rules & Rboolok) && have == Tbool)
+ return 1;
+ if ((rules & Rnolabel) && have == Tlabel)
+ return 0;
+ if (!require || !have)
+ return 1;
+
+ if (require->compat)
+ return require->compat(require, have);
+
+ return require == have;
+ }
+
When assigning command line arguments to variables, we need to be able
to parse each type from a string.
When assigning command line arguments to variables, we need to be able
to parse each type from a string.
-The distinction beteen "prepare" and "init" needs to be explained.
-"init" sets up an initial value, such as "zero" or the empty string.
-"prepare" simply prepares the data structure so that if "free" gets
-called on it, it won't do something silly. Normally a value will be
-stored after "prepare" but before "free", but this might not happen if
-there are errors.
-
###### includes
#include <gmp.h>
#include "parse_string.h"
###### includes
#include <gmp.h>
#include "parse_string.h"
###### value union fields
struct text str;
mpq_t num;
###### value union fields
struct text str;
mpq_t num;
void *label;
###### ast functions
void *label;
###### ast functions
- static void _free_value(struct value v)
+ static void _free_value(struct type *type, struct value *v)
- switch (v.type->vtype) {
+ if (!v)
+ return;
+ switch (type->vtype) {
- case Vstr: free(v.str.txt); break;
- case Vnum: mpq_clear(v.num); break;
+ case Vstr: free(v->str.txt); break;
+ case Vnum: mpq_clear(v->num); break;
case Vlabel:
case Vbool: break;
}
case Vlabel:
case Vbool: break;
}
- static struct value _val_prepare(struct type *type)
+ static void _val_init(struct type *type, struct value *val)
- struct value rv;
-
- rv.type = type;
- switch(type->vtype) {
- case Vnone:
- break;
- case Vnum:
- memset(&rv.num, 0, sizeof(rv.num));
- break;
- case Vstr:
- rv.str.txt = NULL;
- rv.str.len = 0;
- break;
- case Vbool:
- rv.bool = 0;
- break;
- case Vlabel:
- rv.label = NULL;
- break;
- }
- return rv;
- }
-
- static struct value _val_init(struct type *type)
- {
- struct value rv;
-
- rv.type = type;
switch(type->vtype) {
case Vnone: // NOTEST
break; // NOTEST
case Vnum:
switch(type->vtype) {
case Vnone: // NOTEST
break; // NOTEST
case Vnum:
- mpq_init(rv.num); break;
+ mpq_init(val->num); break;
- rv.str.txt = malloc(1);
- rv.str.len = 0;
+ val->str.txt = malloc(1);
+ val->str.len = 0;
break;
case Vlabel: // NOTEST
break;
case Vlabel: // NOTEST
- rv.label = NULL; // NOTEST
+ val->label = NULL; // NOTEST
- static struct value _dup_value(struct value v)
+ static void _dup_value(struct type *type,
+ struct value *vold, struct value *vnew)
- struct value rv;
- rv.type = v.type;
- switch (rv.type->vtype) {
case Vnone: // NOTEST
break; // NOTEST
case Vlabel:
case Vnone: // NOTEST
break; // NOTEST
case Vlabel:
+ vnew->label = vold->label;
+ vnew->bool = vold->bool;
- mpq_init(rv.num);
- mpq_set(rv.num, v.num);
+ mpq_init(vnew->num);
+ mpq_set(vnew->num, vold->num);
- rv.str.len = v.str.len;
- rv.str.txt = malloc(rv.str.len);
- memcpy(rv.str.txt, v.str.txt, v.str.len);
+ vnew->str.len = vold->str.len;
+ vnew->str.txt = malloc(vnew->str.len);
+ memcpy(vnew->str.txt, vold->str.txt, vnew->str.len);
- static int _value_cmp(struct value left, struct value right)
+ static int _value_cmp(struct type *tl, struct type *tr,
+ struct value *left, struct value *right)
- if (left.type != right.type)
- return left.type - right.type; // NOTEST
- switch (left.type->vtype) {
- case Vlabel: cmp = left.label == right.label ? 0 : 1; break;
- case Vnum: cmp = mpq_cmp(left.num, right.num); break;
- case Vstr: cmp = text_cmp(left.str, right.str); break;
- case Vbool: cmp = left.bool - right.bool; break;
+ if (tl != tr)
+ return tl - tr; // NOTEST
+ switch (tl->vtype) {
+ case Vlabel: cmp = left->label == right->label ? 0 : 1; break;
+ case Vnum: cmp = mpq_cmp(left->num, right->num); break;
+ case Vstr: cmp = text_cmp(left->str, right->str); break;
+ case Vbool: cmp = left->bool - right->bool; break;
case Vnone: cmp = 0; // NOTEST
}
return cmp;
}
case Vnone: cmp = 0; // NOTEST
}
return cmp;
}
- static void _print_value(struct value v)
+ static void _print_value(struct type *type, struct value *v)
- switch (v.type->vtype) {
case Vnone: // NOTEST
printf("*no-value*"); break; // NOTEST
case Vlabel: // NOTEST
case Vnone: // NOTEST
printf("*no-value*"); break; // NOTEST
case Vlabel: // NOTEST
- printf("*label-%p*", v.label); break; // NOTEST
+ printf("*label-%p*", v->label); break; // NOTEST
- printf("%.*s", v.str.len, v.str.txt); break;
+ printf("%.*s", v->str.len, v->str.txt); break;
- printf("%s", v.bool ? "True":"False"); break;
+ printf("%s", v->bool ? "True":"False"); break;
case Vnum:
{
mpf_t fl;
mpf_init2(fl, 20);
case Vnum:
{
mpf_t fl;
mpf_init2(fl, 20);
gmp_printf("%Fg", fl);
mpf_clear(fl);
break;
gmp_printf("%Fg", fl);
mpf_clear(fl);
break;
- static struct value _parse_value(struct type *type, char *arg)
+ static int _parse_value(struct type *type, char *arg, struct value *val)
struct text tx;
int neg = 0;
char tail[3] = "";
struct text tx;
int neg = 0;
char tail[3] = "";
switch(type->vtype) {
case Vlabel: // NOTEST
case Vnone: // NOTEST
switch(type->vtype) {
case Vlabel: // NOTEST
case Vnone: // NOTEST
- val.type = NULL; // NOTEST
- break; // NOTEST
- val.str.len = strlen(arg);
- val.str.txt = malloc(val.str.len);
- memcpy(val.str.txt, arg, val.str.len);
+ val->str.len = strlen(arg);
+ val->str.txt = malloc(val->str.len);
+ memcpy(val->str.txt, arg, val->str.len);
break;
case Vnum:
if (*arg == '-') {
break;
case Vnum:
if (*arg == '-') {
arg++;
}
tx.txt = arg; tx.len = strlen(tx.txt);
arg++;
}
tx.txt = arg; tx.len = strlen(tx.txt);
- if (number_parse(val.num, tail, tx) == 0)
- mpq_init(val.num);
+ if (number_parse(val->num, tail, tx) == 0)
+ mpq_init(val->num);
- mpq_neg(val.num, val.num);
+ mpq_neg(val->num, val->num);
if (tail[0]) {
printf("Unsupported suffix: %s\n", arg);
if (tail[0]) {
printf("Unsupported suffix: %s\n", arg);
}
break;
case Vbool:
if (strcasecmp(arg, "true") == 0 ||
strcmp(arg, "1") == 0)
}
break;
case Vbool:
if (strcasecmp(arg, "true") == 0 ||
strcmp(arg, "1") == 0)
else if (strcasecmp(arg, "false") == 0 ||
strcmp(arg, "0") == 0)
else if (strcasecmp(arg, "false") == 0 ||
strcmp(arg, "0") == 0)
else {
printf("Bad bool: %s\n", arg);
else {
printf("Bad bool: %s\n", arg);
- static void _free_value(struct value v);
+ static void _free_value(struct type *type, struct value *v);
static struct type base_prototype = {
.init = _val_init,
static struct type base_prototype = {
.init = _val_init,
- .prepare = _val_prepare,
.parse = _parse_value,
.print = _print_value,
.cmp_order = _value_cmp,
.parse = _parse_value,
.print = _print_value,
.cmp_order = _value_cmp,
static struct type *Tbool, *Tstr, *Tnum, *Tnone, *Tlabel;
###### ast functions
static struct type *Tbool, *Tstr, *Tnum, *Tnone, *Tlabel;
###### ast functions
- static struct type *add_base_type(struct parse_context *c, char *n, enum vtype vt)
+ static struct type *add_base_type(struct parse_context *c, char *n,
+ enum vtype vt, int size)
{
struct text txt = { n, strlen(n) };
struct type *t;
t = add_type(c, txt, &base_prototype);
t->vtype = vt;
{
struct text txt = { n, strlen(n) };
struct type *t;
t = add_type(c, txt, &base_prototype);
t->vtype = vt;
+ t->size = size;
+ t->align = size > sizeof(void*) ? sizeof(void*) : size;
+ if (t->size & (t->align - 1))
+ t->size = (t->size | (t->align - 1)) + 1;
return t;
}
###### context initialization
return t;
}
###### context initialization
- Tbool = add_base_type(&context, "Boolean", Vbool);
- Tstr = add_base_type(&context, "string", Vstr);
- Tnum = add_base_type(&context, "number", Vnum);
- Tnone = add_base_type(&context, "none", Vnone);
- Tlabel = add_base_type(&context, "label", Vlabel);
+ Tbool = add_base_type(&context, "Boolean", Vbool, sizeof(char));
+ Tstr = add_base_type(&context, "string", Vstr, sizeof(struct text));
+ Tnum = add_base_type(&context, "number", Vnum, sizeof(mpq_t));
+ Tnone = add_base_type(&context, "none", Vnone, 0);
+ Tlabel = add_base_type(&context, "label", Vlabel, sizeof(void*));
-Variables are scoped named values. We store the names in a linked
-list of "bindings" sorted lexically, and use sequential search and
+Variables are scoped named values. We store the names in a linked list
+of "bindings" sorted in lexical order, and use sequential search and
insertion sort.
###### ast
insertion sort.
###### ast
###### ast
struct variable {
struct variable *previous;
###### ast
struct variable {
struct variable *previous;
+ struct type *type;
+ struct value *val;
struct binding *name;
struct exec *where_decl;// where name was declared
struct exec *where_set; // where type was set
struct binding *name;
struct exec *where_decl;// where name was declared
struct exec *where_set; // where type was set
the child-count of the parent frame is incremented. This child-count
is used to distinguish between the first of a set of parallel scopes,
in which declared variables must not be in scope, and subsequent
the child-count of the parent frame is incremented. This child-count
is used to distinguish between the first of a set of parallel scopes,
in which declared variables must not be in scope, and subsequent
-branches, whether they must already be conditionally scoped.
+branches, whether they may already be conditionally scoped.
To push a new frame *before* any code in the frame is parsed, we need a
grammar reduction. This is most easily achieved with a grammar
element which derives the empty string, and creates the new scope when
To push a new frame *before* any code in the frame is parsed, we need a
grammar reduction. This is most easily achieved with a grammar
element which derives the empty string, and creates the new scope when
-it is recognized. This can be placed, for example, between a keyword
+it is recognised. This can be placed, for example, between a keyword
like "if" and the code following it.
###### ast
like "if" and the code following it.
###### ast
struct variable *in_scope;
All variables with the same name are linked together using the
struct variable *in_scope;
All variables with the same name are linked together using the
-'previous' link. Those variable that have
-been affirmatively merged all have a 'merged' pointer that points to
-one primary variable - the most recently declared instance. When
-merging variables, we need to also adjust the 'merged' pointer on any
-other variables that had previously been merged with the one that will
-no longer be primary.
+'previous' link. Those variable that have been affirmatively merged all
+have a 'merged' pointer that points to one primary variable - the most
+recently declared instance. When merging variables, we need to also
+adjust the 'merged' pointer on any other variables that had previously
+been merged with the one that will no longer be primary.
A variable that is no longer the most recent instance of a name may
still have "pending" scope, if it might still be merged with most
A variable that is no longer the most recent instance of a name may
still have "pending" scope, if it might still be merged with most
struct variable *t = v;
v = t->previous;
struct variable *t = v;
v = t->previous;
+ free_value(t->type, t->val);
+ free(t->val);
if (t->depth == 0)
// This is a global constant
free_exec(t->where_decl);
if (t->depth == 0)
// This is a global constant
free_exec(t->where_decl);
pending-scope variable. If the previous variable was conditionally
scoped, it and its homonyms becomes out-of-scope.
pending-scope variable. If the previous variable was conditionally
scoped, it and its homonyms becomes out-of-scope.
-When we parse a variable reference (including non-declarative
-assignment) we report an error if the name is not bound or is bound to
+When we parse a variable reference (including non-declarative assignment
+"foo = bar") we report an error if the name is not bound or is bound to
a pending-scope variable; update the scope if the name is bound to a
conditionally scoped variable; or just proceed normally if the named
variable is in scope.
a pending-scope variable; update the scope if the name is bound to a
conditionally scoped variable; or just proceed normally if the named
variable is in scope.
v->scope = InScope;
v->in_scope = c->in_scope;
c->in_scope = v;
v->scope = InScope;
v->in_scope = c->in_scope;
c->in_scope = v;
- v->val = val_prepare(NULL);
else if (v->previous &&
v->previous->scope == PendingScope)
v->scope = PendingScope;
else if (v->previous &&
v->previous->scope == PendingScope)
v->scope = PendingScope;
- else if (v->val.type == Tlabel)
+ else if (v->type == Tlabel)
v->scope = PendingScope;
else if (v->name->var == v)
v->scope = OutScope;
v->scope = PendingScope;
else if (v->name->var == v)
v->scope = OutScope;
for (v2 = v;
v2 && v2->scope == PendingScope;
v2 = v2->previous)
for (v2 = v;
v2 && v2->scope == PendingScope;
v2 = v2->previous)
- if (v2->val.type != Tlabel)
+ if (v2->type != Tlabel)
v2->scope = OutScope;
break;
case OutScope: break;
}
break;
case CloseSequential:
v2->scope = OutScope;
break;
case OutScope: break;
}
break;
case CloseSequential:
- if (v->val.type == Tlabel)
v->scope = PendingScope;
switch (v->scope) {
case InScope:
v->scope = PendingScope;
switch (v->scope) {
case InScope:
for (v2 = v;
v2 && v2->scope == PendingScope;
v2 = v2->previous)
for (v2 = v;
v2 && v2->scope == PendingScope;
v2 = v2->previous)
- if (v2->val.type == Tlabel) {
+ if (v2->type == Tlabel) {
v2->scope = CondScope;
v2->min_depth = c->scope_depth;
} else
v2->scope = CondScope;
v2->min_depth = c->scope_depth;
} else
Executables can be lots of different things. In many cases an
executable is just an operation combined with one or two other
Executables can be lots of different things. In many cases an
executable is just an operation combined with one or two other
-executables. This allows for expressions and lists etc. Other times
-an executable is something quite specific like a constant or variable
-name. So we define a `struct exec` to be a general executable with a
-type, and a `struct binode` which is a subclass of `exec`, forms a
-node in a binary tree, and holds an operation. There will be other
-subclasses, and to access these we need to be able to `cast` the
-`exec` into the various other types.
+executables. This allows for expressions and lists etc. Other times an
+executable is something quite specific like a constant or variable name.
+So we define a `struct exec` to be a general executable with a type, and
+a `struct binode` which is a subclass of `exec`, forms a node in a
+binary tree, and holds an operation. There will be other subclasses,
+and to access these we need to be able to `cast` the `exec` into the
+various other types. The first field in any `struct exec` is the type
+from the `exec_types` enum.
###### macros
#define cast(structname, pointer) ({ \
###### macros
#define cast(structname, pointer) ({ \
fprintf(f, "??:??: "); // NOTEST
}
fprintf(f, "??:??: "); // NOTEST
}
-Each different type of `exec` node needs a number of functions
-defined, a bit like methods. We must be able to be able to free it,
-print it, analyse it and execute it. Once we have specific `exec`
-types we will need to parse them too. Let's take this a bit more
-slowly.
+Each different type of `exec` node needs a number of functions defined,
+a bit like methods. We must be able to free it, print it, analyse it
+and execute it. Once we have specific `exec` types we will need to
+parse them too. Let's take this a bit more slowly.
-As discussed, analysis involves propagating type requirements around
-the program and looking for errors.
+As discussed, analysis involves propagating type requirements around the
+program and looking for errors.
So `propagate_types` is passed an expected type (being a `struct type`
pointer together with some `val_rules` flags) that the `exec` is
So `propagate_types` is passed an expected type (being a `struct type`
pointer together with some `val_rules` flags) that the `exec` is
which needs to look at command line arguments. The `program` will be
interpreted separately.
which needs to look at command line arguments. The `program` will be
interpreted separately.
-Each `exec` can return a value, which may be `Tnone` but must be
-non-NULL; Some `exec`s will return the location of a value, which can
-be updates. To support this, each exec case must store either a value
-in `val` or the pointer to a value in `lval`. If `lval` is set, but a
-simple value is required, `inter_exec()` will dereference `lval` to
-get the value.
+Each `exec` can return a value combined with a type in `struct lrval`.
+The type may be `Tnone` but must be non-NULL. Some `exec`s will return
+the location of a value, which can be updated, in `lval`. Others will
+set `lval` to NULL indicating that there is a value of appropriate type
+in `rval`.
+
###### core functions
struct lrval {
###### core functions
struct lrval {
- struct value val, *lval;
+ struct type *type;
+ struct value rval, *lval;
};
static struct lrval _interp_exec(struct exec *e);
};
static struct lrval _interp_exec(struct exec *e);
- static struct value interp_exec(struct exec *e)
+ static struct value interp_exec(struct exec *e, struct type **typeret)
{
struct lrval ret = _interp_exec(e);
{
struct lrval ret = _interp_exec(e);
+ if (!ret.type) abort();
+ if (typeret)
+ *typeret = ret.type;
- return dup_value(*ret.lval);
- else
- return ret.val;
+ dup_value(ret.type, ret.lval, &ret.rval);
+ return ret.rval;
- static struct value *linterp_exec(struct exec *e)
+ static struct value *linterp_exec(struct exec *e, struct type **typeret)
{
struct lrval ret = _interp_exec(e);
{
struct lrval ret = _interp_exec(e);
+ if (typeret)
+ *typeret = ret.type;
return ret.lval;
}
static struct lrval _interp_exec(struct exec *e)
{
struct lrval ret;
return ret.lval;
}
static struct lrval _interp_exec(struct exec *e)
{
struct lrval ret;
- struct value rv, *lrv = NULL;
- rv.type = Tnone;
+ struct value rv = {}, *lrv = NULL;
+ struct type *rvtype;
+
+ rvtype = ret.type = Tnone;
if (!e) {
ret.lval = lrv;
if (!e) {
ret.lval = lrv;
{
struct binode *b = cast(binode, e);
struct value left, right, *lleft;
{
struct binode *b = cast(binode, e);
struct value left, right, *lleft;
- left.type = right.type = Tnone;
+ struct type *ltype, *rtype;
+ ltype = rtype = Tnone;
switch (b->op) {
## interp binode cases
}
switch (b->op) {
## interp binode cases
}
- free_value(left); free_value(right);
+ free_value(ltype, &left);
+ free_value(rtype, &right);
break;
}
## interp exec cases
}
ret.lval = lrv;
break;
}
## interp exec cases
}
ret.lval = lrv;
+ ret.rval = rv;
+ ret.type = rvtype;
Thus far we have arrays and structs.
Thus far we have arrays and structs.
+Some complex types need do not exist in a name table, so they are kept
+on a linked list in the context (`anon_typelist`). This allows them to
+be freed when parsing is complete.
+
#### Arrays
Arrays can be declared by giving a size and a type, as `[size]type' so
`freq:[26]number` declares `freq` to be an array of 26 numbers. The
#### Arrays
Arrays can be declared by giving a size and a type, as `[size]type' so
`freq:[26]number` declares `freq` to be an array of 26 numbers. The
-size can be an arbitrary expression which is evaluated when the name
-comes into scope.
+size can be either a literal number, or a named constant. Some day an
+arbitrary expression will be supported.
Arrays cannot be assigned. When pointers are introduced we will also
introduce array slices which can refer to part or all of an array -
the assignment syntax will create a slice. For now, an array can only
ever be referenced by the name it is declared with. It is likely that
a "`copy`" primitive will eventually be define which can be used to
Arrays cannot be assigned. When pointers are introduced we will also
introduce array slices which can refer to part or all of an array -
the assignment syntax will create a slice. For now, an array can only
ever be referenced by the name it is declared with. It is likely that
a "`copy`" primitive will eventually be define which can be used to
-make a copy of an array with controllable depth.
+make a copy of an array with controllable recursive depth.
} array;
###### value union fields
} array;
###### value union fields
- struct {
- struct value *elmnts;
- } array;
- static struct value array_prepare(struct type *type)
+ static void array_init(struct type *type, struct value *val)
- struct value ret;
-
- ret.type = type;
- ret.array.elmnts = NULL;
- return ret;
- }
-
- static struct value array_init(struct type *type)
- {
- struct value ret;
if (type->array.vsize) {
mpz_t q;
mpz_init(q);
if (type->array.vsize) {
mpz_t q;
mpz_init(q);
- mpz_tdiv_q(q, mpq_numref(type->array.vsize->val.num),
- mpq_denref(type->array.vsize->val.num));
+ mpz_tdiv_q(q, mpq_numref(type->array.vsize->val->num),
+ mpq_denref(type->array.vsize->val->num));
type->array.size = mpz_get_si(q);
mpz_clear(q);
}
type->array.size = mpz_get_si(q);
mpz_clear(q);
}
- ret.array.elmnts = calloc(type->array.size,
- sizeof(ret.array.elmnts[0]));
- for (i = 0; ret.array.elmnts && i < type->array.size; i++)
- ret.array.elmnts[i] = val_init(type->array.member);
- return ret;
+ type->size = type->array.size * type->array.member->size;
+ type->align = type->array.member->align;
+
+ if (!val)
+ return;
+ for (i = 0; i < type->array.size; i++) {
+ struct value *v;
+ v = (void*)val->ptr + i * type->array.member->size;
+ val_init(type->array.member, v);
+ }
- static void array_free(struct value val)
+ static void array_free(struct type *type, struct value *val)
- if (val.array.elmnts)
- for (i = 0; i < val.type->array.size; i++)
- free_value(val.array.elmnts[i]);
- free(val.array.elmnts);
+ for (i = 0; i < type->array.size; i++) {
+ struct value *v;
+ v = (void*)val->ptr + i * type->array.member->size;
+ free_value(type->array.member, v);
+ }
}
static int array_compat(struct type *require, struct type *have)
}
static int array_compat(struct type *require, struct type *have)
}
static struct type array_prototype = {
}
static struct type array_prototype = {
- .prepare = array_prepare,
.init = array_init,
.print_type = array_print_type,
.compat = array_compat,
.init = array_init,
.print_type = array_print_type,
.compat = array_compat,
- $0->next= c->anon_typelist;
+ $0->next = c->anon_typelist;
c->anon_typelist = $0;
}
}$
c->anon_typelist = $0;
}
}$
$0->array.member = $<4;
$0->array.size = 0;
$0->array.vsize = v;
$0->array.member = $<4;
$0->array.size = 0;
$0->array.vsize = v;
- $0->next= c->anon_typelist;
+ $0->next = c->anon_typelist;
c->anon_typelist = $0;
} }$
c->anon_typelist = $0;
} }$
- lleft = linterp_exec(b->left);
- right = interp_exec(b->right);
+ lleft = linterp_exec(b->left, <ype);
+ right = interp_exec(b->right, &rtype);
mpz_init(q);
mpz_tdiv_q(q, mpq_numref(right.num), mpq_denref(right.num));
i = mpz_get_si(q);
mpz_clear(q);
mpz_init(q);
mpz_tdiv_q(q, mpq_numref(right.num), mpq_denref(right.num));
i = mpz_get_si(q);
mpz_clear(q);
- if (i >= 0 && i < lleft->type->array.size)
- lrv = &lleft->array.elmnts[i];
+ rvtype = ltype->array.member;
+ if (i >= 0 && i < ltype->array.size)
+ lrv = (void*)lleft + i * rvtype->size;
- rv = val_init(lleft->type->array.member);
+ val_init(ltype->array.member, &rv);
+ ltype = NULL;
Structs are only treated as the same if they have the same name.
Simply having the same fields in the same order is not enough. This
Structs are only treated as the same if they have the same name.
Simply having the same fields in the same order is not enough. This
-might change once we can create structure initializes from a list of
+might change once we can create structure initializers from a list of
values.
Each component datum is identified much like a variable is declared,
values.
Each component datum is identified much like a variable is declared,
struct field {
struct text name;
struct type *type;
struct field {
struct text name;
struct type *type;
+ struct value *init;
+ int offset;
-###### value union fields
- struct {
- struct value *fields;
- } structure;
-
###### type functions
void (*print_type_decl)(struct type *type, FILE *f);
###### value functions
###### type functions
void (*print_type_decl)(struct type *type, FILE *f);
###### value functions
- static struct value structure_prepare(struct type *type)
- {
- struct value ret;
-
- ret.type = type;
- ret.structure.fields = NULL;
- return ret;
- }
-
- static struct value structure_init(struct type *type)
+ static void structure_init(struct type *type, struct value *val)
- ret.type = type;
- ret.structure.fields = calloc(type->structure.nfields,
- sizeof(ret.structure.fields[0]));
- for (i = 0; ret.structure.fields && i < type->structure.nfields; i++)
- ret.structure.fields[i] = val_init(type->structure.fields[i].type);
- return ret;
+ for (i = 0; i < type->structure.nfields; i++) {
+ struct value *v;
+ v = (void*) val->ptr + type->structure.fields[i].offset;
+ val_init(type->structure.fields[i].type, v);
+ }
- static void structure_free(struct value val)
+ static void structure_free(struct type *type, struct value *val)
- if (val.structure.fields)
- for (i = 0; i < val.type->structure.nfields; i++)
- free_value(val.structure.fields[i]);
- free(val.structure.fields);
+ for (i = 0; i < type->structure.nfields; i++) {
+ struct value *v;
+ v = (void*)val->ptr + type->structure.fields[i].offset;
+ free_value(type->structure.fields[i].type, v);
+ }
}
static void structure_free_type(struct type *t)
{
int i;
for (i = 0; i < t->structure.nfields; i++)
}
static void structure_free_type(struct type *t)
{
int i;
for (i = 0; i < t->structure.nfields; i++)
- free_value(t->structure.fields[i].init);
+ if (t->structure.fields[i].init) {
+ free_value(t->structure.fields[i].type,
+ t->structure.fields[i].init);
+ free(t->structure.fields[i].init);
+ }
free(t->structure.fields);
}
static struct type structure_prototype = {
free(t->structure.fields);
}
static struct type structure_prototype = {
- .prepare = structure_prepare,
.init = structure_init,
.free = structure_free,
.free_type = structure_free_type,
.init = structure_init,
.free = structure_free,
.free_type = structure_free_type,
if (!st)
type_err(c, "error: unknown type for field access", f->left,
NULL, 0, NULL);
if (!st)
type_err(c, "error: unknown type for field access", f->left,
NULL, 0, NULL);
- else if (st->prepare != structure_prepare)
+ else if (st->init != structure_init)
type_err(c, "error: field reference attempted on %1, not a struct",
f->left, st, 0, NULL);
else if (f->index == -2) {
type_err(c, "error: field reference attempted on %1, not a struct",
f->left, st, 0, NULL);
else if (f->index == -2) {
case Xfieldref:
{
struct fieldref *f = cast(fieldref, e);
case Xfieldref:
{
struct fieldref *f = cast(fieldref, e);
- struct value *lleft = linterp_exec(f->left);
- lrv = &lleft->structure.fields[f->index];
+ struct type *ltype;
+ struct value *lleft = linterp_exec(f->left, <ype);
+ lrv = (void*)lleft->ptr + ltype->structure.fields[f->index].offset;
+ rvtype = ltype->structure.fields[f->index].type;
if (!f)
return;
free_fieldlist(f->prev);
if (!f)
return;
free_fieldlist(f->prev);
+ if (f->f.init) {
+ free_value(f->f.type, f->f.init);
+ free(f->f.init);
+ }
t->structure.fields = calloc(cnt, sizeof(struct field));
f = $3;
while (cnt > 0) {
t->structure.fields = calloc(cnt, sizeof(struct field));
f = $3;
while (cnt > 0) {
+ int a = f->f.type->align;
cnt -= 1;
t->structure.fields[cnt] = f->f;
cnt -= 1;
t->structure.fields[cnt] = f->f;
- f->f.init = val_prepare(Tnone);
+ if (t->size & (a-1))
+ t->size = (t->size | (a-1)) + 1;
+ t->structure.fields[cnt].offset = t->size;
+ t->size += ((f->f.type->size - 1) | (a-1)) + 1;
+ if (a > t->align)
+ t->align = a;
+ f->f.init = NULL;
$0 = calloc(1, sizeof(struct fieldlist));
$0->f.name = $1.txt;
$0->f.type = $<3;
$0 = calloc(1, sizeof(struct fieldlist));
$0->f.name = $1.txt;
$0->f.type = $<3;
- $0->f.init = val_prepare($0->f.type);
do {
ok = 1;
propagate_types($<5, c, &ok, $3, 0);
} while (ok == 2);
if (!ok)
c->parse_error = 1;
do {
ok = 1;
propagate_types($<5, c, &ok, $3, 0);
} while (ok == 2);
if (!ok)
c->parse_error = 1;
- else
- $0->f.init = interp_exec($5);
+ else {
+ struct value vl = interp_exec($5, NULL);
+ $0->f.init = val_alloc($0->f.type, &vl);
+ }
} }$
| IDENTIFIER : Type ${
$0 = calloc(1, sizeof(struct fieldlist));
$0->f.name = $1.txt;
$0->f.type = $<3;
} }$
| IDENTIFIER : Type ${
$0 = calloc(1, sizeof(struct fieldlist));
$0->f.name = $1.txt;
$0->f.type = $<3;
- $0->f.init = val_init($3);
+ $0->f.init = val_alloc($0->f.type, NULL);
struct field *fl = t->structure.fields + i;
fprintf(f, " %.*s : ", fl->name.len, fl->name.txt);
type_print(fl->type, f);
struct field *fl = t->structure.fields + i;
fprintf(f, " %.*s : ", fl->name.len, fl->name.txt);
type_print(fl->type, f);
- if (fl->init.type->print) {
+ if (fl->type->print && fl->init) {
- if (fl->init.type == Tstr)
- print_value(fl->init);
- if (fl->init.type == Tstr)
+ print_value(fl->type, fl->init);
+ if (fl->type == Tstr)
fprintf(f, "\"");
}
printf("\n");
fprintf(f, "\"");
}
printf("\n");
###### ast
struct val {
struct exec;
###### ast
struct val {
struct exec;
+###### ast functions
+ struct val *new_val(struct type *T, struct token tk)
+ {
+ struct val *v = new_pos(val, tk);
+ v->vtype = T;
+ return v;
+ }
+
###### Grammar
$*val
Value -> True ${
###### Grammar
$*val
Value -> True ${
- $0 = new_pos(val, $1);
- $0->val.type = Tbool;
+ $0 = new_val(Tbool, $1);
$0->val.bool = 1;
}$
| False ${
$0->val.bool = 1;
}$
| False ${
- $0 = new_pos(val, $1);
- $0->val.type = Tbool;
+ $0 = new_val(Tbool, $1);
$0->val.bool = 0;
}$
| NUMBER ${
$0->val.bool = 0;
}$
| NUMBER ${
- $0 = new_pos(val, $1);
- $0->val.type = Tnum;
+ $0 = new_val(Tnum, $1);
{
char tail[3];
if (number_parse($0->val.num, tail, $1.txt) == 0)
{
char tail[3];
if (number_parse($0->val.num, tail, $1.txt) == 0)
- $0 = new_pos(val, $1);
- $0->val.type = Tstr;
+ $0 = new_val(Tstr, $1);
{
char tail[3];
string_parse(&$1, '\\', &$0->val.str, tail);
{
char tail[3];
string_parse(&$1, '\\', &$0->val.str, tail);
- $0 = new_pos(val, $1);
- $0->val.type = Tstr;
+ $0 = new_val(Tstr, $1);
{
char tail[3];
string_parse(&$1, '\\', &$0->val.str, tail);
{
char tail[3];
string_parse(&$1, '\\', &$0->val.str, tail);
case Xval:
{
struct val *v = cast(val, e);
case Xval:
{
struct val *v = cast(val, e);
- if (v->val.type == Tstr)
- print_value(v->val);
- if (v->val.type == Tstr)
+ print_value(v->vtype, &v->val);
+ if (v->vtype == Tstr)
case Xval:
{
struct val *val = cast(val, prog);
case Xval:
{
struct val *val = cast(val, prog);
- if (!type_compat(type, val->val.type, rules))
+ if (!type_compat(type, val->vtype, rules))
type_err(c, "error: expected %1%r found %2",
type_err(c, "error: expected %1%r found %2",
- prog, type, rules, val->val.type);
- return val->val.type;
+ prog, type, rules, val->vtype);
+ return val->vtype;
}
###### interp exec cases
case Xval:
}
###### interp exec cases
case Xval:
- rv = dup_value(cast(val, e)->val);
+ rvtype = cast(val, e)->vtype;
+ dup_value(rvtype, &cast(val, e)->val, &rv);
break;
###### ast functions
static void free_val(struct val *v)
{
break;
###### ast functions
static void free_val(struct val *v)
{
- if (!v)
- return;
- free_value(v->val);
+ if (v)
+ free_value(v->vtype, &v->val);
case Xval: free_val(cast(val, e)); break;
###### ast functions
case Xval: free_val(cast(val, e)); break;
###### ast functions
- // Move all nodes from 'b' to 'rv', reversing the order.
+ // Move all nodes from 'b' to 'rv', reversing their order.
// In 'b' 'left' is a list, and 'right' is the last node.
// In 'rv', left' is the first node and 'right' is a list.
static struct binode *reorder_bilist(struct binode *b)
// In 'b' 'left' is a list, and 'right' is the last node.
// In 'rv', left' is the first node and 'right' is a list.
static struct binode *reorder_bilist(struct binode *b)
Just as we used a `val` to wrap a value into an `exec`, we similarly
need a `var` to wrap a `variable` into an exec. While each `val`
Just as we used a `val` to wrap a value into an `exec`, we similarly
need a `var` to wrap a `variable` into an exec. While each `val`
-contained a copy of the value, each `var` hold a link to the variable
+contained a copy of the value, each `var` holds a link to the variable
because it really is the same variable no matter where it appears.
When a variable is used, we need to remember to follow the `->merged`
link to find the primary instance.
because it really is the same variable no matter where it appears.
When a variable is used, we need to remember to follow the `->merged`
link to find the primary instance.
if (v) {
v->where_decl = $0;
v->where_set = $0;
if (v) {
v->where_decl = $0;
v->where_set = $0;
- v->val = val_prepare($<3);
+ v->type = $<Type;
+ v->val = NULL;
} else {
v = var_ref(c, $1.txt);
$0->var = v;
} else {
v = var_ref(c, $1.txt);
$0->var = v;
if (v) {
v->where_decl = $0;
v->where_set = $0;
if (v) {
v->where_decl = $0;
v->where_set = $0;
- v->val = val_prepare($<3);
+ v->type = $<Type;
+ v->val = NULL;
v->constant = 1;
} else {
v = var_ref(c, $1.txt);
v->constant = 1;
} else {
v = var_ref(c, $1.txt);
/* This might be a label - allocate a var just in case */
v = var_decl(c, $1.txt);
if (v) {
/* This might be a label - allocate a var just in case */
v = var_decl(c, $1.txt);
if (v) {
- v->val = val_prepare(Tnone);
+ v->val = NULL;
+ v->type = Tnone;
v->where_decl = $0;
v->where_set = $0;
}
v->where_decl = $0;
v->where_set = $0;
}
prog, NULL, 0, NULL);
type_err(c, "info: name was defined as a constant here",
v->where_decl, NULL, 0, NULL);
prog, NULL, 0, NULL);
type_err(c, "info: name was defined as a constant here",
v->where_decl, NULL, 0, NULL);
- if (v->val.type == Tnone && v->where_decl == prog)
+ if (v->type == Tnone && v->where_decl == prog)
type_err(c, "error: variable used but not declared: %v",
prog, NULL, 0, NULL);
type_err(c, "error: variable used but not declared: %v",
prog, NULL, 0, NULL);
- if (v->val.type == NULL) {
- v->val = val_prepare(type);
+ v->type = type;
+ v->val = NULL;
v->where_set = prog;
*ok = 2;
}
return type;
}
v->where_set = prog;
*ok = 2;
}
return type;
}
- if (!type_compat(type, v->val.type, rules)) {
+ if (!type_compat(type, v->type, rules)) {
type_err(c, "error: expected %1%r but variable '%v' is %2", prog,
type_err(c, "error: expected %1%r but variable '%v' is %2", prog,
- type, rules, v->val.type);
type_err(c, "info: this is where '%v' was set to %1", v->where_set,
type_err(c, "info: this is where '%v' was set to %1", v->where_set,
- v->val.type, rules, NULL);
if (v->merged)
v = v->merged;
if (v->merged)
v = v->merged;
+ lrv = v->val;
+ rvtype = v->type;
Our first user of the `binode` will be conditional expressions, which
is a bit odd as they actually have three components. That will be
handled by having 2 binodes for each expression. The conditional
Our first user of the `binode` will be conditional expressions, which
is a bit odd as they actually have three components. That will be
handled by having 2 binodes for each expression. The conditional
-expression is the lowest precedence operatior, so it gets to define
-what an "Expression" is. The next level up is "BoolExpr", which
-comes next.
+expression is the lowest precedence operator which is why we define it
+first - to start the precedence list.
Conditional expressions are of the form "value `if` condition `else`
other_value". They associate to the right, so everything to the right
Conditional expressions are of the form "value `if` condition `else`
other_value". They associate to the right, so everything to the right
-of `else` is part of an else value, while only the BoolExpr to the
-left of `if` is the if values. Between `if` and `else` there is no
-room for ambiguity, so a full conditional expression is allowed in there.
+of `else` is part of an else value, while only a higher-precedence to
+the left of `if` is the if values. Between `if` and `else` there is no
+room for ambiguity, so a full conditional expression is allowed in
+there.
###### Binode types
CondExpr,
###### Binode types
CondExpr,
case CondExpr: {
struct binode *b2 = cast(binode, b->right);
case CondExpr: {
struct binode *b2 = cast(binode, b->right);
- left = interp_exec(b->left);
+ left = interp_exec(b->left, <ype);
- rv = interp_exec(b2->left);
+ rv = interp_exec(b2->left, &rvtype);
- rv = interp_exec(b2->right);
+ rv = interp_exec(b2->right, &rvtype);
}
break;
### Expressions: Boolean
The next class of expressions to use the `binode` will be Boolean
}
break;
### Expressions: Boolean
The next class of expressions to use the `binode` will be Boolean
-expressions. As I haven't implemented precedence in the parser
-generator yet, we need different names for each precedence level used
-by expressions. The outer most or lowest level precedence after
-conditional expressions are Boolean operators which form an `BoolExpr`
-out of `BTerm`s and `BFact`s. As well as `or` `and`, and `not` we
-have `and then` and `or else` which only evaluate the second operand
-if the result would make a difference.
+expressions. "`and then`" and "`or else`" are similar to `and` and `or`
+have same corresponding precendence. The difference is that they don't
+evaluate the second expression if not necessary.
###### interp binode cases
case And:
###### interp binode cases
case And:
- rv = interp_exec(b->left);
- right = interp_exec(b->right);
+ rv = interp_exec(b->left, &rvtype);
+ right = interp_exec(b->right, &rtype);
rv.bool = rv.bool && right.bool;
break;
case AndThen:
rv.bool = rv.bool && right.bool;
break;
case AndThen:
- rv = interp_exec(b->left);
+ rv = interp_exec(b->left, &rvtype);
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, NULL);
- rv = interp_exec(b->left);
- right = interp_exec(b->right);
+ rv = interp_exec(b->left, &rvtype);
+ right = interp_exec(b->right, &rtype);
rv.bool = rv.bool || right.bool;
break;
case OrElse:
rv.bool = rv.bool || right.bool;
break;
case OrElse:
- rv = interp_exec(b->left);
+ rv = interp_exec(b->left, &rvtype);
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, NULL);
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, &rvtype);
rv.bool = !rv.bool;
break;
### Expressions: Comparison
rv.bool = !rv.bool;
break;
### Expressions: Comparison
-Of slightly higher precedence that Boolean expressions are
-Comparisons.
-A comparison takes arguments of any comparable type, but the two types must be
-the same.
+Of slightly higher precedence that Boolean expressions are Comparisons.
+A comparison takes arguments of any comparable type, but the two types
+must be the same.
To simplify the parsing we introduce an `eop` which can record an
To simplify the parsing we introduce an `eop` which can record an
+expression operator, and the `CMPop` non-terminal will match one of them.
- left = interp_exec(b->left);
- right = interp_exec(b->right);
- cmp = value_cmp(left, right);
- rv.type = Tbool;
+ left = interp_exec(b->left, <ype);
+ right = interp_exec(b->right, &rtype);
+ cmp = value_cmp(ltype, rtype, &left, &right);
+ rvtype = Tbool;
switch (b->op) {
case Less: rv.bool = cmp < 0; break;
case LessEq: rv.bool = cmp <= 0; break;
switch (b->op) {
case Less: rv.bool = cmp < 0; break;
case LessEq: rv.bool = cmp <= 0; break;
case GtrEq: rv.bool = cmp >= 0; break;
case Eql: rv.bool = cmp == 0; break;
case NEql: rv.bool = cmp != 0; break;
case GtrEq: rv.bool = cmp >= 0; break;
case Eql: rv.bool = cmp == 0; break;
case NEql: rv.bool = cmp != 0; break;
- default: rv.bool = 0; break; // NOTEST
+ default: rv.bool = 0; break; // NOTEST
}
break;
}
### Expressions: The rest
}
break;
}
### Expressions: The rest
-The remaining expressions with the highest precedence are arithmetic
-and string concatenation. They are `Expr`, `Term`, and `Factor`.
-The `Factor` is where the `Value` and `Variable` that we already have
-are included.
+The remaining expressions with the highest precedence are arithmetic and
+string concatenation. String concatenation (`++`) has the same
+precedence as multiplication and division, but lower than the uniary.
`+` and `-` are both infix and prefix operations (where they are
absolute value and negation). These have different operator names.
We also have a 'Bracket' operator which records where parentheses were
`+` and `-` are both infix and prefix operations (where they are
absolute value and negation). These have different operator names.
We also have a 'Bracket' operator which records where parentheses were
-found. This makes it easy to reproduce these when printing. Once
-precedence is handled better I might be able to discard this.
+found. This makes it easy to reproduce these when printing. Possibly I
+should only insert brackets were needed for precedence.
###### Binode types
Plus, Minus,
###### Binode types
Plus, Minus,
###### interp binode cases
case Plus:
###### interp binode cases
case Plus:
- rv = interp_exec(b->left);
- right = interp_exec(b->right);
+ rv = interp_exec(b->left, &rvtype);
+ right = interp_exec(b->right, &rtype);
mpq_add(rv.num, rv.num, right.num);
break;
case Minus:
mpq_add(rv.num, rv.num, right.num);
break;
case Minus:
- rv = interp_exec(b->left);
- right = interp_exec(b->right);
+ rv = interp_exec(b->left, &rvtype);
+ right = interp_exec(b->right, &rtype);
mpq_sub(rv.num, rv.num, right.num);
break;
case Times:
mpq_sub(rv.num, rv.num, right.num);
break;
case Times:
- rv = interp_exec(b->left);
- right = interp_exec(b->right);
+ rv = interp_exec(b->left, &rvtype);
+ right = interp_exec(b->right, &rtype);
mpq_mul(rv.num, rv.num, right.num);
break;
case Divide:
mpq_mul(rv.num, rv.num, right.num);
break;
case Divide:
- rv = interp_exec(b->left);
- right = interp_exec(b->right);
+ rv = interp_exec(b->left, &rvtype);
+ right = interp_exec(b->right, &rtype);
mpq_div(rv.num, rv.num, right.num);
break;
case Rem: {
mpz_t l, r, rem;
mpq_div(rv.num, rv.num, right.num);
break;
case Rem: {
mpz_t l, r, rem;
- left = interp_exec(b->left);
- right = interp_exec(b->right);
+ left = interp_exec(b->left, <ype);
+ right = interp_exec(b->right, &rtype);
mpz_init(l); mpz_init(r); mpz_init(rem);
mpz_tdiv_q(l, mpq_numref(left.num), mpq_denref(left.num));
mpz_tdiv_q(r, mpq_numref(right.num), mpq_denref(right.num));
mpz_tdiv_r(rem, l, r);
mpz_init(l); mpz_init(r); mpz_init(rem);
mpz_tdiv_q(l, mpq_numref(left.num), mpq_denref(left.num));
mpz_tdiv_q(r, mpq_numref(right.num), mpq_denref(right.num));
mpz_tdiv_r(rem, l, r);
mpq_set_z(rv.num, rem);
mpz_clear(r); mpz_clear(l); mpz_clear(rem);
mpq_set_z(rv.num, rem);
mpz_clear(r); mpz_clear(l); mpz_clear(rem);
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, &rvtype);
mpq_neg(rv.num, rv.num);
break;
case Absolute:
mpq_neg(rv.num, rv.num);
break;
case Absolute:
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, &rvtype);
mpq_abs(rv.num, rv.num);
break;
case Bracket:
mpq_abs(rv.num, rv.num);
break;
case Bracket:
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, &rvtype);
- left = interp_exec(b->left);
- right = interp_exec(b->right);
- rv.type = Tstr;
+ left = interp_exec(b->left, <ype);
+ right = interp_exec(b->right, &rtype);
+ rvtype = Tstr;
rv.str = text_join(left.str, right.str);
break;
rv.str = text_join(left.str, right.str);
break;
A simple statement list needs no extra syntax. A complex statement
list has two syntactic forms. It can be enclosed in braces (much like
A simple statement list needs no extra syntax. A complex statement
list has two syntactic forms. It can be enclosed in braces (much like
-C blocks), or it can be introduced by a colon and continue until an
+C blocks), or it can be introduced by an indent and continue until an
unindented newline (much like Python blocks). With this extra syntax
it is referred to as a block.
unindented newline (much like Python blocks). With this extra syntax
it is referred to as a block.
###### interp binode cases
case Block:
###### interp binode cases
case Block:
- while (rv.type == Tnone &&
+ while (rvtype == Tnone &&
- rv = interp_exec(b->left);
+ rv = interp_exec(b->left, &rvtype);
b = cast(binode, b->right);
}
break;
b = cast(binode, b->right);
}
break;
if (b->left) {
if (sep)
putchar(sep);
if (b->left) {
if (sep)
putchar(sep);
- left = interp_exec(b->left);
- print_value(left);
- free_value(left);
+ left = interp_exec(b->left, <ype);
+ print_value(ltype, &left);
+ free_value(ltype, &left);
if (b->right)
sep = ' ';
} else if (sep)
eol = 0;
if (b->right)
sep = ' ';
} else if (sep)
eol = 0;
if (eol)
printf("\n");
break;
if (eol)
printf("\n");
break;
###### Assignment statement
An assignment will assign a value to a variable, providing it hasn't
###### Assignment statement
An assignment will assign a value to a variable, providing it hasn't
-be declared as a constant. The analysis phase ensures that the type
+been declared as a constant. The analysis phase ensures that the type
will be correct so the interpreter just needs to perform the
calculation. There is a form of assignment which declares a new
variable as well as assigning a value. If a name is assigned before
will be correct so the interpreter just needs to perform the
calculation. There is a form of assignment which declares a new
variable as well as assigning a value. If a name is assigned before
if (cast(var, b->left)->var->constant) {
if (v->where_decl == v->where_set) {
printf("::");
if (cast(var, b->left)->var->constant) {
if (v->where_decl == v->where_set) {
printf("::");
- type_print(v->val.type, stdout);
+ type_print(v->type, stdout);
printf(" ");
} else
printf(" ::");
} else {
if (v->where_decl == v->where_set) {
printf(":");
printf(" ");
} else
printf(" ::");
} else {
if (v->where_decl == v->where_set) {
printf(":");
- type_print(v->val.type, stdout);
+ type_print(v->type, stdout);
printf(" ");
} else
printf(" :");
printf(" ");
} else
printf(" :");
###### interp binode cases
case Assign:
###### interp binode cases
case Assign:
- lleft = linterp_exec(b->left);
- right = interp_exec(b->right);
+ lleft = linterp_exec(b->left, <ype);
+ right = interp_exec(b->right, &rtype);
- free_value(*lleft);
- *lleft = right;
- } else
- free_value(right); // NOTEST
- right.type = NULL;
+ free_value(ltype, lleft);
+ dup_value(ltype, &right, lleft);
+ ltype = NULL;
+ }
struct variable *v = cast(var, b->left)->var;
if (v->merged)
v = v->merged;
struct variable *v = cast(var, b->left)->var;
if (v->merged)
v = v->merged;
- if (b->right)
- right = interp_exec(b->right);
- else
- right = val_init(v->val.type);
- free_value(v->val);
- v->val = right;
- right.type = NULL;
+ if (b->right) {
+ right = interp_exec(b->right, &rtype);
+ free_value(v->type, v->val);
+ free(v->val);
+ v->val = val_alloc(v->type, &right);
+ rtype = Tnone;
+ } else {
+ free_value(v->type, v->val);
+ v->val = val_alloc(v->type, NULL);
+ }
$0->right = $<2;
if ($0->right->type == Xvar) {
struct var *v = cast(var, $0->right);
$0->right = $<2;
if ($0->right->type == Xvar) {
struct var *v = cast(var, $0->right);
- if (v->var->val.type == Tnone) {
+ if (v->var->type == Tnone) {
/* Convert this to a label */
/* Convert this to a label */
- v->var->val = val_prepare(Tlabel);
- v->var->val.label = &v->var->val;
+ v->var->type = Tlabel;
+ v->var->val = val_alloc(Tlabel, NULL);
+ v->var->val->label = v->var->val;
###### interp binode cases
case Use:
###### interp binode cases
case Use:
- rv = interp_exec(b->right);
+ rv = interp_exec(b->right, &rvtype);
break;
### The Conditional Statement
break;
### The Conditional Statement
case Xcond_statement:
{
struct value v, cnd;
case Xcond_statement:
{
struct value v, cnd;
+ struct type *vtype, *cndtype;
struct casepart *cp;
struct cond_statement *c = cast(cond_statement, e);
if (c->forpart)
struct casepart *cp;
struct cond_statement *c = cast(cond_statement, e);
if (c->forpart)
- interp_exec(c->forpart);
+ interp_exec(c->forpart, NULL);
- cnd = interp_exec(c->condpart);
+ cnd = interp_exec(c->condpart, &cndtype);
- cnd.type = Tnone;
- if (!(cnd.type == Tnone ||
- (cnd.type == Tbool && cnd.bool != 0)))
+ cndtype = Tnone;
+ if (!(cndtype == Tnone ||
+ (cndtype == Tbool && cnd.bool != 0)))
break;
// cnd is Tnone or Tbool, doesn't need to be freed
if (c->dopart)
break;
// cnd is Tnone or Tbool, doesn't need to be freed
if (c->dopart)
- interp_exec(c->dopart);
+ interp_exec(c->dopart, NULL);
- rv = interp_exec(c->thenpart);
- if (rv.type != Tnone || !c->dopart)
+ rv = interp_exec(c->thenpart, &rvtype);
+ if (rvtype != Tnone || !c->dopart)
+ free_value(rvtype, &rv);
+ rvtype = Tnone;
}
} while (c->dopart);
for (cp = c->casepart; cp; cp = cp->next) {
}
} while (c->dopart);
for (cp = c->casepart; cp; cp = cp->next) {
- v = interp_exec(cp->value);
- if (value_cmp(v, cnd) == 0) {
- free_value(v);
- free_value(cnd);
- rv = interp_exec(cp->action);
+ v = interp_exec(cp->value, &vtype);
+ if (value_cmp(cndtype, vtype, &v, &cnd) == 0) {
+ free_value(vtype, &v);
+ free_value(cndtype, &cnd);
+ rv = interp_exec(cp->action, &rvtype);
+ free_value(cndtype, &cnd);
- rv = interp_exec(c->elsepart);
+ rv = interp_exec(c->elsepart, &rvtype);
if (!ok)
c->parse_error = 1;
else if (v) {
if (!ok)
c->parse_error = 1;
else if (v) {
- v->val = interp_exec($5);
+ struct value res = interp_exec($5, &v->type);
+ v->val = val_alloc(v->type, &res);
target = i;
} else {
printf(" %.*s :: ", v->name->name.len, v->name->name.txt);
target = i;
} else {
printf(" %.*s :: ", v->name->name.len, v->name->name.txt);
- type_print(v->val.type, stdout);
+ type_print(v->type, stdout);
- if (v->val.type == Tstr)
- print_value(v->val);
- if (v->val.type == Tstr)
+ print_value(v->type, v->val);
+ if (v->type == Tstr)
printf("\"");
printf("\n");
target -= 1;
printf("\"");
printf("\n");
target -= 1;
for (b = cast(binode, b->left); b; b = cast(binode, b->right)) {
struct var *v = cast(var, b->left);
for (b = cast(binode, b->left); b; b = cast(binode, b->right)) {
struct var *v = cast(var, b->left);
- if (!v->var->val.type) {
- v->var->val = val_prepare(Tstr);
+ v->var->type = Tstr;
+ v->var->val = NULL;
}
}
b = cast(binode, prog);
}
}
b = cast(binode, prog);
struct binode *p = cast(binode, prog);
struct binode *al;
struct value v;
struct binode *p = cast(binode, prog);
struct binode *al;
struct value v;
if (!prog)
return; // NOTEST
al = cast(binode, p->left);
while (al) {
struct var *v = cast(var, al->left);
if (!prog)
return; // NOTEST
al = cast(binode, p->left);
while (al) {
struct var *v = cast(var, al->left);
- struct value *vl = &v->var->val;
+ struct value *vl = v->var->val;
if (argv[0] == NULL) {
printf("Not enough args\n");
exit(1);
}
al = cast(binode, al->right);
if (argv[0] == NULL) {
printf("Not enough args\n");
exit(1);
}
al = cast(binode, al->right);
- free_value(*vl);
- *vl = parse_value(vl->type, argv[0]);
- if (vl->type == NULL)
+ if (vl)
+ free_value(v->var->type, vl);
+ if (!vl) {
+ vl = val_alloc(v->var->type, NULL);
+ v->var->val = vl;
+ }
+ free_value(v->var->type, vl);
+ if (!parse_value(v->var->type, argv[0], vl))
- v = interp_exec(p->right);
- free_value(v);
+ v = interp_exec(p->right, &vtype);
+ free_value(vtype, &v);
}
###### interp binode cases
}
###### interp binode cases
code / ocean / commitdiff