genc.c

   1 #include <stdbool.h>
   2
   3 #include "ast.h"
   4
   5 #define gdie(msg) { fprintf(stderr, "%s", msg); return 1; }
   6
   7 int expr_genc(struct expr *expr, FILE *cout);
   8
   9 void binop_genc(char *fun, struct expr *l, struct expr *r, FILE *cout)
  10 {
  11         safe_fprintf(cout, "%s(", fun);
  12         expr_genc(l, cout);
  13         safe_fprintf(cout, ", ");
  14         expr_genc(r, cout);
  15         safe_fprintf(cout, ")");
  16 }
  17
  18 int expr_genc(struct expr *expr, FILE *cout)
  19 {
  20         int r = 0;
  21         char buf[] = "\\x55";
  22         if (expr == NULL)
  23                 return 0;
  24         switch(expr->type) {
  25         case ebinop:
  26                 if (expr->type == ebinop && expr->data.ebinop.op == cons) {
  27                         binop_genc("splc_cons", expr->data.ebinop.l,
  28                                 expr->data.ebinop.r, cout);
  29                 } else if (expr->type == ebinop && expr->data.ebinop.op == power) {
  30                         binop_genc("splc_power", expr->data.ebinop.l,
  31                                 expr->data.ebinop.r, cout);
  32                 } else {
  33                         safe_fprintf(cout, "(");
  34                         expr_genc(expr->data.ebinop.l, cout);
  35                         safe_fprintf(cout, "%s", binop_str[expr->data.ebinop.op]);
  36                         expr_genc(expr->data.ebinop.r, cout);
  37                         safe_fprintf(cout, ")");
  38                 }
  39                 break;
  40         case ebool:
  41                 safe_fprintf(cout, "%s", expr->data.ebool ? "true" : "false");
  42                 break;
  43         case echar:
  44                 safe_fprintf(cout, "'%s'",
  45                         escape_char(expr->data.echar, buf, false));
  46                 break;
  47         case efuncall:
  48                 safe_fprintf(cout, "%s(", expr->data.efuncall.ident);
  49                 for(int i = 0; i<expr->data.efuncall.nargs; i++) {
  50                         expr_genc(expr->data.efuncall.args[i], cout);
  51                         if (i+1 < expr->data.efuncall.nargs)
  52                                 safe_fprintf(cout, ", ");
  53                 }
  54                 safe_fprintf(cout, ")");
  55                 for (int i = 0; i<expr->data.efuncall.nfields; i++)
  56                         fprintf(cout, "->%s",
  57                                 fieldspec_str[expr->data.efuncall.fields[i]]);
  58                 break;
  59         case eint:
  60                 safe_fprintf(cout, "%d", expr->data.eint);
  61                 break;
  62         case eident:
  63                 fprintf(cout, "%s", expr->data.eident.ident);
  64                 for (int i = 0; i<expr->data.eident.nfields; i++)
  65                         fprintf(cout, "->%s",
  66                                 fieldspec_str[expr->data.eident.fields[i]]);
  67                 break;
  68         case enil:
  69                 safe_fprintf(cout, "NULL");
  70                 break;
  71         case etuple:
  72                 binop_genc("splc_tuple", expr->data.etuple.left,
  73                         expr->data.etuple.right, cout);
  74                 break;
  75         case estring:
  76                 safe_fprintf(cout, "\"");
  77                 for (int i = 0; i<expr->data.estring.nchars; i++)
  78                         safe_fprintf(cout, "%s", escape_char(
  79                                 expr->data.estring.chars[i], buf, true));
  80                 safe_fprintf(cout, "\"");
  81                 break;
  82         case eunop:
  83                 safe_fprintf(cout, "(%s", unop_str[expr->data.eunop.op]);
  84                 expr_genc(expr->data.eunop.l, cout);
  85                 safe_fprintf(cout, ")");
  86                 break;
  87         default:
  88                 die("Unknown expression node\n");
  89         }
  90         return r;
  91 }
  92
  93 int type_genc(struct type *type, FILE *cout)
  94 {
  95         if (type == NULL) {
  96                 fprintf(cout, "WORD ");
  97         } else {
  98                 switch(type->type) {
  99                 case tbasic:
 100                         fprintf(cout, "WORD ");
 101                         break;
 102                 case tlist:
 103                         fprintf(cout, "struct splc_list *");
 104                         break;
 105                 case ttuple:
 106                         fprintf(cout, "struct splc_tuple *");
 107                         break;
 108                 case tvar:
 109                         fprintf(cout, "WORD ");
 110                         break;
 111                 default:
 112                         die("Unsupported type node\n");
 113                 }
 114         }
 115         return 0;
 116 }
 117
 118 int vardecl_genc(struct vardecl *vardecl, int indent, FILE *cout)
 119 {
 120         int r = 0;
 121         if (vardecl == NULL)
 122                 return 0;
 123         pindent(indent, cout);
 124         type_genc(vardecl->type, cout);
 125         fprintf(cout, "%s = ", vardecl->ident);
 126         r = expr_genc(vardecl->expr, cout);
 127         fprintf(cout, ";\n");
 128         return r;
 129 }
 130
 131 void stmt_genc(struct stmt *stmt, int indent, FILE *cout)
 132 {
 133         if (stmt == NULL)
 134                 return;
 135         switch(stmt->type) {
 136         case sassign:
 137                 pindent(indent, cout);
 138                 fprintf(cout, "%s", stmt->data.sassign.ident);
 139                 for (int i = 0; i<stmt->data.sassign.nfields; i++)
 140                         fprintf(cout, "->%s", stmt->data.sassign.fields[i]);
 141                 safe_fprintf(cout, " = ");
 142                 expr_genc(stmt->data.sassign.expr, cout);
 143                 safe_fprintf(cout, ";\n");
 144                 break;
 145         case sif:
 146                 pindent(indent, cout);
 147                 safe_fprintf(cout, "if (");
 148                 expr_genc(stmt->data.sif.pred, cout);
 149                 safe_fprintf(cout, ") {\n");
 150                 for (int i = 0; i<stmt->data.sif.nthen; i++)
 151                         stmt_genc(stmt->data.sif.then[i], indent+1, cout);
 152                 pindent(indent, cout);
 153                 safe_fprintf(cout, "} else {\n");
 154                 for (int i = 0; i<stmt->data.sif.nels; i++)
 155                         stmt_genc(stmt->data.sif.els[i], indent+1, cout);
 156                 pindent(indent, cout);
 157                 safe_fprintf(cout, "}\n");
 158                 break;
 159         case sreturn:
 160                 pindent(indent, cout);
 161                 safe_fprintf(cout, "return ");
 162                 expr_genc(stmt->data.sreturn, cout);
 163                 safe_fprintf(cout, ";\n");
 164                 break;
 165         case sexpr:
 166                 pindent(indent, cout);
 167                 expr_genc(stmt->data.sexpr, cout);
 168                 safe_fprintf(cout, ";\n");
 169                 break;
 170         case svardecl:
 171                 vardecl_genc(stmt->data.svardecl, indent, cout);
 172                 break;
 173         case swhile:
 174                 pindent(indent, cout);
 175                 safe_fprintf(cout, "while (");
 176                 expr_genc(stmt->data.swhile.pred, cout);
 177                 safe_fprintf(cout, ") {\n");
 178                 for (int i = 0; i<stmt->data.swhile.nbody; i++)
 179                         stmt_genc(stmt->data.swhile.body[i], indent+1, cout);
 180                 pindent(indent, cout);
 181                 safe_fprintf(cout, "}\n");
 182                 break;
 183         default:
 184                 die("Unsupported stmt node\n");
 185         }
 186 }
 187
 188 int decl_genc(struct decl *decl, FILE *cout)
 189 {
 190         switch (decl->type) {
 191         case dfundecl:
 192                 type_genc(decl->data.dfun.rtype, cout);
 193                 safe_fprintf(cout, "%s (", decl->data.dfun.ident);
 194                 for (int i = 0; i<decl->data.dfun.nargs; i++) {
 195                         if (i < decl->data.dfun.natypes)
 196                                 type_genc(decl->data.dfun.atypes[i], cout);
 197                         safe_fprintf(cout, "%s", decl->data.dfun.args[i]);
 198                         if (i < decl->data.dfun.nargs - 1)
 199                                 safe_fprintf(cout, ", ");
 200                 }
 201                 safe_fprintf(cout, ") /*");
 202                 if (decl->data.dfun.rtype != NULL) {
 203                         safe_fprintf(cout, " :: ");
 204                         for (int i = 0; i<decl->data.dfun.natypes; i++) {
 205                                 type_print(decl->data.dfun.atypes[i], cout);
 206                                 safe_fprintf(cout, " ");
 207                         }
 208                         safe_fprintf(cout, "-> ");
 209                         type_print(decl->data.dfun.rtype, cout);
 210                 }
 211                 safe_fprintf(cout, "*/ {\n");
 212                 for (int i = 0; i<decl->data.dfun.nbody; i++)
 213                         stmt_genc(decl->data.dfun.body[i], 1, cout);
 214                 safe_fprintf(cout, "}\n");
 215                 break;
 216         case dvardecl:
 217                 return vardecl_genc(decl->data.dvar, 0, cout);
 218         }
 219         return 0;
 220 }
 221
 222 int genc(struct ast *ast, FILE *cout)
 223 {
 224         fprintf(cout,
 225                 "#include <stdint.h>\n"
 226                 "#include <stdlib.h>\n"
 227                 "#define WORD intptr_t\n"
 228                 "struct splc_tuple { WORD fst; WORD snd; };\n"
 229                 "struct splc_list { WORD hd; struct splc_list *tl; };\n"
 230                 "struct splc_tuple *splc_tuple(WORD fst, WORD snd) {\n"
 231                 "\tstruct splc_tuple *res = malloc(sizeof(splc_tuple));\n"
 232                 "\tres->fst = fst;\n"
 233                 "\tres->snd = snd;\n"
 234                 "\treturn res;\n"
 235                 "}\n"
 236                 "struct splc_list *splc_cons(WORD hd, struct splc_list *tl) {\n"
 237                 "\tstruct splc_list *res = malloc(sizeof(splc_tuple));\n"
 238                 "\tres->hd = hd;\n"
 239                 "\tres->tl = tl;\n"
 240                 "\treturn res;\n"
 241                 "}\n"
 242                 "WORD splc_power(WORD l, WORD r) {\n"
 243                 "\tWORD res = 1;\n"
 244                 "\twhile(l-- >= 0)\n"
 245                 "\t\tres *= r;\n"
 246                 "\treturn res;\n"
 247                 "}\n"
 248                 );
 249         int r = 0;
 250         for (int i = 0; i<ast->ndecls && r == 0; i++) {
 251                 fprintf(cout, "\n");
 252                 r = decl_genc(ast->decls[i], cout);
 253         }
 254         return r;
 255 }