Change structs/enums so they allow for field/tag names that are C

keywords

4 files changed, 24 insertions, 24 deletions

diff --git a/compile.c b/compile.c
index a9e55b9e..0f8c792e 100644
--- a/compile.c
+++ b/compile.c
@@ -246,7 +246,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
 
             auto tag_struct = Match(tag_type, StructType);
             if (clause->args && !clause->args->next && tag_struct->fields && tag_struct->fields->next) {
-                code = CORD_all(code, compile_type(tag_type), " ", compile(env, clause->args->ast), " = subject.", clause_tag_name, ";\n");
+                code = CORD_all(code, compile_type(tag_type), " ", compile(env, clause->args->ast), " = subject.$", clause_tag_name, ";\n");
                 scope = fresh_scope(scope);
                 set_binding(scope, Match(clause->args->ast, Var)->name, new(binding_t, .type=tag_type));
             } else if (clause->args) {
@@ -258,7 +258,7 @@ CORD compile_statement(env_t *env, ast_t *ast)
                         code_err(clause->tag_name, "The field %T.%s.%s wasn't accounted for", subject_t, clause_tag_name, field->name);
                     if (!field)
                         code_err(var->ast, "This is one more field than %T has", subject_t);
-                    code = CORD_all(code, compile_type(field->type), " ", compile(env, var->ast), " = subject.", clause_tag_name, ".", field->name, ";\n");
+                    code = CORD_all(code, compile_type(field->type), " ", compile(env, var->ast), " = subject.$", clause_tag_name, ".$", field->name, ";\n");
                     set_binding(scope, Match(var->ast, Var)->name, new(binding_t, .type=field->type));
                     var = var->next;
                     field = field->next;
@@ -2112,10 +2112,10 @@ CORD compile(env_t *env, ast_t *ast)
                 if (streq(field->name, f->field)) {
                     if (fielded_t->tag == PointerType) {
                         CORD fielded = compile_to_pointer_depth(env, f->fielded, 1, false);
-                        return CORD_asprintf("(%r)->%s", fielded, f->field);
+                        return CORD_asprintf("(%r)->$%s", fielded, f->field);
                     } else {
                         CORD fielded = compile(env, f->fielded);
-                        return CORD_asprintf("(%r).%s", fielded, f->field);
+                        return CORD_asprintf("(%r).$%s", fielded, f->field);
                     }
                 }
             }
diff --git a/enums.c b/enums.c
index 9b73f3f7..10446f52 100644
--- a/enums.c
+++ b/enums.c
@@ -44,7 +44,7 @@ static CORD compile_str_method(env_t *env, ast_t *ast)
 
         for (arg_ast_t *field = tag->fields; field; field = field->next) {
             type_t *field_t = get_arg_ast_type(env, field);
-            CORD field_str = expr_as_text(env, CORD_all("obj->", tag->name, ".", field->name), field_t, "use_color");
+            CORD field_str = expr_as_text(env, CORD_all("obj->$", tag->name, ".$", field->name), field_t, "use_color");
             str_func = CORD_all(str_func, ", \"", field->name, "=\", ", field_str);
             if (field->next) str_func = CORD_cat(str_func, ", \", \"");
         }
@@ -76,7 +76,7 @@ static CORD compile_compare_method(env_t *env, ast_t *ast)
         if (tag->fields) {
             type_t *tag_type = Table$str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
             cmp_func = CORD_all(cmp_func, "\tcase ", full_name, "$tag$", tag->name, ": "
-                                "return generic_compare(&x->", tag->name, ", &y->", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
+                                "return generic_compare(&x->$", tag->name, ", &y->$", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
         } else {
             cmp_func = CORD_all(cmp_func, "\tcase ", full_name, "$tag$", tag->name, ": return 0;\n");
         }
@@ -106,7 +106,7 @@ static CORD compile_equals_method(env_t *env, ast_t *ast)
         if (tag->fields) {
             type_t *tag_type = Table$str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
             eq_func = CORD_all(eq_func, "\tcase ", full_name, "$tag$", tag->name, ": "
-                                "return generic_equal(&x->", tag->name, ", &y->", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
+                                "return generic_equal(&x->$", tag->name, ", &y->$", tag->name, ", ", compile_type_info(env, tag_type), ");\n");
         } else {
             eq_func = CORD_all(eq_func, "\tcase ", full_name, "$tag$", tag->name, ": return yes;\n");
         }
@@ -136,7 +136,7 @@ static CORD compile_hash_method(env_t *env, ast_t *ast)
         if (tag->fields) {
             type_t *tag_type = Table$str_get(*env->types, CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)));
             hash_func = CORD_all(hash_func, "\tcase ", full_name, "$tag$", tag->name, ": "
-                                 "hashes[1] = generic_hash(&obj->", tag->name, ", ", compile_type_info(env, tag_type), ");\n"
+                                 "hashes[1] = generic_hash(&obj->$", tag->name, ", ", compile_type_info(env, tag_type), ");\n"
                                  "break;\n");
         } else {
             hash_func = CORD_all(hash_func, "\tcase ", full_name, "$tag$", tag->name, ": break;\n");
@@ -159,14 +159,14 @@ void compile_enum_def(env_t *env, ast_t *ast)
             CORD arg_sig = CORD_EMPTY;
             for (arg_ast_t *field = tag->fields; field; field = field->next) {
                 type_t *field_t = get_arg_ast_type(env, field);
-                arg_sig = CORD_all(arg_sig, compile_declaration(field_t, field->name));
+                arg_sig = CORD_all(arg_sig, compile_declaration(field_t, CORD_all("$", field->name)));
                 if (field->next) arg_sig = CORD_cat(arg_sig, ", ");
             }
             if (arg_sig == CORD_EMPTY) arg_sig = "void";
             CORD constructor_impl = CORD_all("public inline ", full_name, "_t ", full_name, "$tagged$", tag->name, "(", arg_sig, ") { return (",
-                                             full_name, "_t){.$tag=", full_name, "$tag$", tag->name, ", .", tag->name, "={");
+                                             full_name, "_t){.$tag=", full_name, "$tag$", tag->name, ", .$", tag->name, "={");
             for (arg_ast_t *field = tag->fields; field; field = field->next) {
-                constructor_impl = CORD_all(constructor_impl, field->name);
+                constructor_impl = CORD_all(constructor_impl, "$", field->name);
                 if (field->next) constructor_impl = CORD_cat(constructor_impl, ", ");
             }
             constructor_impl = CORD_cat(constructor_impl, "}}; }\n");
@@ -216,7 +216,7 @@ CORD compile_enum_typedef(env_t *env, ast_t *ast)
     for (tag_ast_t *tag = def->tags; tag; tag = tag->next) {
         CORD field_def = compile_struct_typedef(env, WrapAST(ast, StructDef, .name=CORD_to_const_char_star(CORD_all(def->name, "$", tag->name)), .fields=tag->fields));
         all_defs = CORD_all(all_defs, field_def);
-        enum_def = CORD_all(enum_def, full_name, "$", tag->name, "_t ", tag->name, ";\n");
+        enum_def = CORD_all(enum_def, full_name, "$", tag->name, "_t $", tag->name, ";\n");
     }
     enum_def = CORD_cat(enum_def, "};\n};\n");
     all_defs = CORD_all(all_defs, enum_def);
@@ -235,7 +235,7 @@ CORD compile_enum_declarations(env_t *env, ast_t *ast)
             CORD arg_sig = CORD_EMPTY;
             for (arg_ast_t *field = tag->fields; field; field = field->next) {
                 type_t *field_t = get_arg_ast_type(env, field);
-                arg_sig = CORD_all(arg_sig, compile_declaration(field_t, field->name));
+                arg_sig = CORD_all(arg_sig, compile_declaration(field_t, CORD_all("$", field->name)));
                 if (field->next) arg_sig = CORD_cat(arg_sig, ", ");
             }
             if (arg_sig == CORD_EMPTY) arg_sig = "void";
diff --git a/environment.c b/environment.c
index c81156c5..30580667 100644
--- a/environment.c
+++ b/environment.c
@@ -358,7 +358,7 @@ env_t *for_scope(env_t *env, ast_t *ast)
                 code_err(var->ast, "This is one variable too many for this iterator, which returns a %T", fn->ret);
             const char *name = Match(var->ast, Var)->name;
             type_t *t = get_arg_type(env, iter_field);
-            set_binding(scope, name, new(binding_t, .type=t, .code=CORD_cat("cur.Next.", iter_field->name)));
+            set_binding(scope, name, new(binding_t, .type=t, .code=CORD_cat("cur.$Next.$", iter_field->name)));
             iter_field = iter_field->next;
         }
         return scope;
diff --git a/structs.c b/structs.c
index 80049cdc..fba22c04 100644
--- a/structs.c
+++ b/structs.c
@@ -27,7 +27,7 @@ static CORD compile_str_method(env_t *env, ast_t *ast)
         CORD_appendf(&str_func, "\treturn CORD_all(use_color ? \"\\x1b[0;1m%s\\x1b[m(\" : \"%s(\"", name, name);
         for (arg_ast_t *field = def->fields; field; field = field->next) {
             type_t *field_type = get_arg_ast_type(env, field);
-            CORD field_str = expr_as_text(env, CORD_cat("obj->", field->name), field_type, "use_color");
+            CORD field_str = expr_as_text(env, CORD_cat("obj->$", field->name), field_type, "use_color");
             CORD_appendf(&str_func, ", \"%s=\", %r", field->name, field_str);
             if (field->next) CORD_appendf(&str_func, ", \", \"");
         }
@@ -48,13 +48,13 @@ static CORD compile_compare_method(env_t *env, ast_t *ast)
         type_t *field_type = get_arg_ast_type(env, field);
         switch (field_type->tag) {
         case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
-            cmp_func = CORD_all(cmp_func, "diff = (x->", field->name, " > y->", field->name, ") - (x->", field->name, " < y->", field->name, ");");
+            cmp_func = CORD_all(cmp_func, "diff = (x->$", field->name, " > y->$", field->name, ") - (x->$", field->name, " < y->$", field->name, ");");
             break;
         case TextType:
-            cmp_func = CORD_all(cmp_func, "diff = CORD_cmp(x->", field->name, ", y->", field->name, ");");
+            cmp_func = CORD_all(cmp_func, "diff = CORD_cmp(x->$", field->name, ", y->$", field->name, ");");
             break;
         default:
-            cmp_func = CORD_all(cmp_func, "diff = generic_compare(&x->", field->name, ", &y->", field->name, ", ",
+            cmp_func = CORD_all(cmp_func, "diff = generic_compare(&x->$", field->name, ", &y->$", field->name, ", ",
                                 compile_type_info(env, field_type), ");\n");
             break;
         }
@@ -78,13 +78,13 @@ static CORD compile_equals_method(env_t *env, ast_t *ast)
         type_t *field_type = get_arg_ast_type(env, field);
         switch (field_type->tag) {
         case BoolType: case IntType: case NumType: case PointerType: case FunctionType:
-            condition = CORD_all(condition, "(x->", field->name, " == y->", field->name, ")");
+            condition = CORD_all(condition, "(x->$", field->name, " == y->$", field->name, ")");
             break;
         case TextType:
-            condition = CORD_all(condition, "(CORD_cmp(x->", field->name, ", y->", field->name, ") == 0)");
+            condition = CORD_all(condition, "(CORD_cmp(x->$", field->name, ", y->$", field->name, ") == 0)");
             break;
         default:
-            condition = CORD_all(condition, "generic_equal(&x->", field->name, ", &y->", field->name, ", ",
+            condition = CORD_all(condition, "generic_equal(&x->$", field->name, ", &y->$", field->name, ", ",
                                 compile_type_info(env, field_type), ")");
             break;
         }
@@ -103,9 +103,9 @@ static CORD compile_hash_method(env_t *env, ast_t *ast)
     for (arg_ast_t *field = def->fields; field; field = field->next) {
         type_t *field_type = get_arg_ast_type(env, field);
         if (field_type->tag == BoolType) // Bools can be bit fields, so you can't use *obj->field there:
-            hash_func = CORD_all(hash_func, "\n(uint32_t)(obj->", field->name, "),");
+            hash_func = CORD_all(hash_func, "\n(uint32_t)(obj->$", field->name, "),");
         else
-            hash_func = CORD_all(hash_func, "\ngeneric_hash(&obj->", field->name, ", ", compile_type_info(env, field_type), "),");
+            hash_func = CORD_all(hash_func, "\ngeneric_hash(&obj->$", field->name, ", ", compile_type_info(env, field_type), "),");
     }
     hash_func = CORD_all(hash_func, "};\n"
                          "uint32_t hash;\n"
@@ -175,7 +175,7 @@ CORD compile_struct_typedef(env_t *env, ast_t *ast)
     for (arg_ast_t *field = def->fields; field; field = field->next) {
         type_t *field_t = get_arg_ast_type(env, field);
         CORD type_code = compile_type(field_t);
-        CORD_appendf(&struct_code, "%r %s%s;\n", type_code, field->name,
+        CORD_appendf(&struct_code, "%r $%s%s;\n", type_code, field->name,
                      CORD_cmp(type_code, "Bool_t") ? "" : ":1");
     }
     struct_code = CORD_all(struct_code, "};\n");