altos/scheme: Rework display/write code

[fw/altos] / src / scheme / ao_scheme_make_const.c

diff --git a/src/scheme/ao_scheme_make_const.c b/src/scheme/ao_scheme_make_const.c
index 6bd552f5aed29d2dc71addc2aca258c1a5883558..79ba1bf19ba8aef9b15c65819ecac8021df43634 100644 (file)
--- a/src/scheme/ao_scheme_make_const.c
+++ b/src/scheme/ao_scheme_make_const.c
@@ -30,15 +30,15 @@ ao_scheme_make_builtin(enum ao_scheme_builtin_id func, int args) {
 }
 
 struct builtin_func {
-       char    *feature;
-       char    *name;
-       int     args;
+       const char      *feature;
+       const char      *name;
+       int             args;
        enum ao_scheme_builtin_id       func;
 };
 
 struct builtin_atom {
-       char    *feature;
-       char    *name;
+       const char      *feature;
+       const char      *name;
 };
 
 #define AO_SCHEME_BUILTIN_CONSTS
@@ -80,7 +80,7 @@ ao_fec_crc_byte(uint8_t byte, uint16_t crc)
        return crc;
 }
 
-uint16_t
+static uint16_t
 ao_fec_crc(const uint8_t *bytes, uint8_t len)
 {
        uint16_t        crc = AO_FEC_CRC_INIT;
@@ -97,7 +97,7 @@ struct ao_scheme_macro_stack {
 
 struct ao_scheme_macro_stack *macro_stack;
 
-int
+static int
 ao_scheme_macro_push(ao_poly p)
 {
        struct ao_scheme_macro_stack *m = macro_stack;
@@ -114,7 +114,7 @@ ao_scheme_macro_push(ao_poly p)
        return 0;
 }
 
-void
+static void
 ao_scheme_macro_pop(void)
 {
        struct ao_scheme_macro_stack *m = macro_stack;
@@ -141,7 +141,7 @@ void indent(void)
 ao_poly
 ao_has_macro(ao_poly p);
 
-ao_poly
+static ao_poly
 ao_macro_test_get(ao_poly atom)
 {
        ao_poly *ref = ao_scheme_atom_ref(atom, NULL);
@@ -150,7 +150,7 @@ ao_macro_test_get(ao_poly atom)
        return AO_SCHEME_NIL;
 }
 
-ao_poly
+static ao_poly
 ao_is_macro(ao_poly p)
 {
        struct ao_scheme_builtin        *builtin;
@@ -220,7 +220,7 @@ ao_has_macro(ao_poly p)
 
                list = cons->cdr;
                p = AO_SCHEME_NIL;
-               while (list != AO_SCHEME_NIL && ao_scheme_poly_type(list) == AO_SCHEME_CONS) {
+               while (list != AO_SCHEME_NIL && AO_SCHEME_IS_CONS(list)) {
                        cons = ao_scheme_poly_cons(list);
                        m = ao_has_macro(cons->car);
                        if (m) {
@@ -269,7 +269,7 @@ ao_scheme_seen_builtin(struct ao_scheme_builtin *b)
        return 0;
 }
 
-int
+static int
 ao_scheme_read_eval_abort(void)
 {
        ao_poly in, out = AO_SCHEME_NIL;
@@ -280,7 +280,7 @@ ao_scheme_read_eval_abort(void)
                out = ao_scheme_eval(in);
                if (ao_scheme_exception)
                        return 0;
-               ao_scheme_poly_write(out);
+               ao_scheme_poly_write(out, true);
                putchar ('\n');
        }
        return 1;
@@ -297,7 +297,7 @@ struct feature {
 static struct feature *enable;
 static struct feature *disable;
 
-void
+static void
 ao_scheme_add_feature(struct feature **list, char *name)
 {
        struct feature *feature = malloc (sizeof (struct feature) + strlen(name) + 1);
@@ -306,8 +306,8 @@ ao_scheme_add_feature(struct feature **list, char *name)
        *list = feature;
 }
 
-bool
-ao_scheme_has_feature(struct feature *list, char *name)
+static bool
+ao_scheme_has_feature(struct feature *list, const char *name)
 {
        while (list) {
                if (!strcmp(list->name, name))
@@ -317,17 +317,20 @@ ao_scheme_has_feature(struct feature *list, char *name)
        return false;
 }
 
-void
-ao_scheme_add_features(struct feature **list, char *names)
+static void
+ao_scheme_add_features(struct feature **list, const char *names)
 {
        char    *saveptr = NULL;
        char    *name;
+       char    *copy = strdup(names);
+       char    *save = copy;
 
-       while ((name = strtok_r(names, ",", &saveptr)) != NULL) {
-               names = NULL;
+       while ((name = strtok_r(copy, ",", &saveptr)) != NULL) {
+               copy = NULL;
                if (!ao_scheme_has_feature(*list, name))
                        ao_scheme_add_feature(list, name);
        }
+       free(save);
 }
 
 int
@@ -356,6 +359,7 @@ main(int argc, char **argv)
        ao_poly val;
        struct ao_scheme_atom   *a;
        struct ao_scheme_builtin        *b;
+       struct feature                  *d;
        int     in_atom = 0;
        char    *out_name = NULL;
        int     c;
@@ -391,6 +395,7 @@ main(int argc, char **argv)
 
        prev_func = _builtin_last;
        target_func = 0;
+       b = NULL;
        for (f = 0; f < (int) N_FUNC; f++) {
                if (ao_scheme_has_feature(enable, funcs[f].feature) || !ao_scheme_has_feature(disable, funcs[f].feature)) {
                        if (funcs[f].func != prev_func) {
@@ -407,7 +412,7 @@ main(int argc, char **argv)
                                 */
                                func_map[prev_func] = target_func++;
                        }
-                       a = ao_scheme_atom_intern(funcs[f].name);
+                       a = ao_scheme_atom_intern((char *) funcs[f].name);
                        ao_scheme_atom_def(ao_scheme_atom_poly(a),
                                           ao_scheme_builtin_poly(b));
                }
@@ -441,7 +446,7 @@ main(int argc, char **argv)
                if (val != AO_SCHEME_NIL) {
                        printf("error: function %s contains unresolved macro: ",
                               ao_scheme_poly_atom(vals->vals[f].atom)->name);
-                       ao_scheme_poly_write(val);
+                       ao_scheme_poly_write(val, true);
                        printf("\n");
                        exit(1);
                }
@@ -464,6 +469,9 @@ main(int argc, char **argv)
 
        fprintf(out, "/* Generated file, do not edit */\n\n");
 
+       for (d = disable; d; d = d->next)
+               fprintf(out, "#undef AO_SCHEME_FEATURE_%s\n", d->name);
+
        fprintf(out, "#define AO_SCHEME_POOL_CONST %d\n", ao_scheme_top);
        fprintf(out, "extern const uint8_t ao_scheme_const[AO_SCHEME_POOL_CONST] __attribute__((aligned(4)));\n");
        fprintf(out, "#define ao_builtin_atoms 0x%04x\n", ao_scheme_atom_poly(ao_scheme_atoms));
@@ -474,32 +482,33 @@ main(int argc, char **argv)
        fprintf(out, "#define _ao_scheme_bool_true 0x%04x\n", ao_scheme_bool_poly(ao_scheme_true));
 
        for (a = ao_scheme_atoms; a; a = ao_scheme_poly_atom(a->next)) {
-               char    *n = a->name, c;
+               const char      *n = a->name;
+               char            ch;
                fprintf(out, "#define _ao_scheme_atom_");
-               while ((c = *n++)) {
-                       if (isalnum(c))
-                               fprintf(out, "%c", c);
+               while ((ch = *n++)) {
+                       if (isalnum(ch))
+                               fprintf(out, "%c", ch);
                        else
-                               fprintf(out, "%02x", c);
+                               fprintf(out, "%02x", ch);
                }
                fprintf(out, "  0x%04x\n", ao_scheme_atom_poly(a));
        }
        fprintf(out, "#ifdef AO_SCHEME_CONST_BITS\n");
        fprintf(out, "const uint8_t ao_scheme_const[AO_SCHEME_POOL_CONST] __attribute((aligned(4))) = {");
        for (o = 0; o < ao_scheme_top; o++) {
-               uint8_t c;
+               uint8_t ch;
                if ((o & 0xf) == 0)
                        fprintf(out, "\n\t");
                else
                        fprintf(out, " ");
-               c = ao_scheme_const[o];
+               ch = ao_scheme_const[o];
                if (!in_atom)
                        in_atom = is_atom(o);
                if (in_atom) {
-                       fprintf(out, " '%c',", c);
+                       fprintf(out, " '%c',", ch);
                        in_atom--;
                } else {
-                       fprintf(out, "0x%02x,", c);
+                       fprintf(out, "0x%02x,", ch);
                }
        }
        fprintf(out, "\n};\n");