ast.c

   1 #include <stdlib.h>
   2 #include <stdio.h>
   3 #include <string.h>
   4
   5 #include "util.h"
   6 #include "ast.h"
   7
   8 static const char *binop_str[] = {
   9         [binor] = "||", [binand] = "&&", [eq] = "==", [neq] = "!=",
  10         [leq] = "<=", [le] = "<", [geq] = ">=", [ge] = ">", [cons] = ":",
  11         [plus] = "+", [minus] = "-", [times] = "*", [divide] = "/",
  12         [modulo] = "%", [power] = "^",
  13 };
  14 static const char *fieldspec_str[] = {
  15         [fst] = "fst", [snd] = "snd", [hd] = "hd", [tl] = "tl"};
  16 static const char *unop_str[] = { [inverse] = "!", [negate] = "-", };
  17
  18 struct ast *ast(struct list *decls)
  19 {
  20         struct ast *res = safe_malloc(sizeof(struct ast));
  21         res->decls = (struct decl **)list_to_array(decls, &res->ndecls, true);
  22         return res;
  23 }
  24
  25 struct decl *decl_fun(char *ident, struct list *args, struct list *body)
  26 {
  27         struct decl *res = safe_malloc(sizeof(struct decl));
  28         res->type = dfundecl;
  29         res->data.dfun.ident = ident;
  30         res->data.dfun.args = (char **)
  31                 list_to_array(args, &res->data.dfun.nargs, true);
  32         res->data.dfun.body = (struct stmt **)
  33                 list_to_array(body, &res->data.dfun.nbody, true);
  34         return res;
  35 }
  36
  37 struct decl *decl_var(struct vardecl vardecl)
  38 {
  39         struct decl *res = safe_malloc(sizeof(struct decl));
  40         res->type = dvardecl;
  41         res->data.dvar = vardecl;
  42         return res;
  43 }
  44
  45 struct stmt *stmt_assign(char *ident, struct expr *expr)
  46 {
  47         struct stmt *res = safe_malloc(sizeof(struct stmt));
  48         res->type = sassign;
  49         res->data.sassign.ident = ident;
  50         res->data.sassign.expr = expr;
  51         return res;
  52 }
  53
  54 struct stmt *stmt_if(struct expr *pred, struct list *then, struct list *els)
  55 {
  56         struct stmt *res = safe_malloc(sizeof(struct stmt));
  57         res->type = sif;
  58         res->data.sif.pred = pred;
  59         res->data.sif.then = (struct stmt **)
  60                 list_to_array(then, &res->data.sif.nthen, true);
  61         res->data.sif.els = (struct stmt **)
  62                 list_to_array(els, &res->data.sif.nels, true);
  63         return res;
  64 }
  65
  66 struct stmt *stmt_return(struct expr *rtrn)
  67 {
  68         struct stmt *res = safe_malloc(sizeof(struct stmt));
  69         res->type = sreturn;
  70         res->data.sreturn = rtrn;
  71         return res;
  72 }
  73
  74 struct stmt *stmt_expr(struct expr *expr)
  75 {
  76         struct stmt *res = safe_malloc(sizeof(struct stmt));
  77         res->type = sexpr;
  78         res->data.sexpr = expr;
  79         return res;
  80 }
  81
  82 struct stmt *stmt_vardecl(struct vardecl vardecl)
  83 {
  84         struct stmt *res = safe_malloc(sizeof(struct stmt));
  85         res->type = svardecl;
  86         res->data.svardecl = vardecl;
  87         return res;
  88 }
  89
  90 struct stmt *stmt_while(struct expr *pred, struct list *body)
  91 {
  92         struct stmt *res = safe_malloc(sizeof(struct stmt));
  93         res->type = swhile;
  94         res->data.swhile.pred = pred;
  95         res->data.swhile.body = (struct stmt **)
  96                 list_to_array(body, &res->data.swhile.nbody, true);
  97         return res;
  98 }
  99
 100 struct expr *expr_binop(struct expr *l, enum binop op, struct expr *r)
 101 {
 102         struct expr *res = safe_malloc(sizeof(struct expr));
 103         res->type = ebinop;
 104         res->data.ebinop.l = l;
 105         res->data.ebinop.op = op;
 106         res->data.ebinop.r = r;
 107         return res;
 108 }
 109
 110 struct expr *expr_bool(bool b)
 111 {
 112         struct expr *res = safe_malloc(sizeof(struct expr));
 113         res->type = ebool;
 114         res->data.ebool = b;
 115         return res;
 116 }
 117 int fromHex(char c)
 118 {
 119         if (c >= '0' && c <= '9')
 120                 return c-'0';
 121         if (c >= 'a' && c <= 'f')
 122                 return c-'a'+10;
 123         if (c >= 'A' && c <= 'F')
 124                 return c-'A'+10;
 125         return -1;
 126 }
 127
 128 struct expr *expr_char(const char *c)
 129 {
 130         struct expr *res = safe_malloc(sizeof(struct expr));
 131         res->type = echar;
 132         //regular char
 133         if (strlen(c) == 3)
 134                 res->data.echar = c[1];
 135         //escape
 136         if (strlen(c) == 4)
 137                 switch(c[2]) {
 138                 case '0': res->data.echar = '\0'; break;
 139                 case 'a': res->data.echar = '\a'; break;
 140                 case 'b': res->data.echar = '\b'; break;
 141                 case 't': res->data.echar = '\t'; break;
 142                 case 'v': res->data.echar = '\v'; break;
 143                 case 'f': res->data.echar = '\f'; break;
 144                 case 'r': res->data.echar = '\r'; break;
 145                 }
 146         //hex escape
 147         if (strlen(c) == 6)
 148                 res->data.echar = (fromHex(c[3])<<4)+fromHex(c[4]);
 149         return res;
 150 }
 151
 152 struct expr *expr_funcall(char *ident, struct list *args)
 153 {
 154         struct expr *res = safe_malloc(sizeof(struct expr));
 155         res->type = efuncall;
 156         res->data.efuncall.ident = ident;
 157         res->data.efuncall.args = (struct expr **)
 158                 list_to_array(args, &res->data.efuncall.nargs, true);
 159         return res;
 160 }
 161
 162 struct expr *expr_int(int integer)
 163 {
 164         struct expr *res = safe_malloc(sizeof(struct expr));
 165         res->type = eint;
 166         res->data.eint = integer;
 167         return res;
 168 }
 169
 170 struct expr *expr_ident(char *ident, struct list *fields)
 171 {
 172         struct expr *res = safe_malloc(sizeof(struct expr));
 173         res->type = eident;
 174         res->data.eident.ident = ident;
 175
 176         void **els = list_to_array(fields, &res->data.eident.nfields, true);
 177         res->data.eident.fields = (enum fieldspec *)safe_malloc(
 178                 res->data.eident.nfields*sizeof(enum fieldspec));
 179         for (int i = 0; i<res->data.eident.nfields; i++) {
 180                 char *t = els[i];
 181                 if (strcmp(t, "fst") == 0)
 182                         res->data.eident.fields[i] = fst;
 183                 else if (strcmp(t, "snd") == 0)
 184                         res->data.eident.fields[i] = snd;
 185                 else if (strcmp(t, "hd") == 0)
 186                         res->data.eident.fields[i] = hd;
 187                 else if (strcmp(t, "tl") == 0)
 188                         res->data.eident.fields[i] = tl;
 189                 free(t);
 190         }
 191         free(els);
 192         return res;
 193 }
 194
 195 struct expr *expr_nil()
 196 {
 197         struct expr *res = safe_malloc(sizeof(struct expr));
 198         res->type = enil;
 199         return res;
 200 }
 201
 202 struct expr *expr_tuple(struct expr *left, struct expr *right)
 203 {
 204         struct expr *res = safe_malloc(sizeof(struct expr));
 205         res->type = etuple;
 206         res->data.etuple.left = left;
 207         res->data.etuple.right = right;
 208         return res;
 209 }
 210
 211 struct expr *expr_unop(enum unop op, struct expr *l)
 212 {
 213         struct expr *res = safe_malloc(sizeof(struct expr));
 214         res->type = eunop;
 215         res->data.eunop.op = op;
 216         res->data.eunop.l = l;
 217         return res;
 218 }
 219
 220 const char *cescapes[] = {
 221         [0] = "\\0", [1] = "\\x01", [2] = "\\x02", [3] = "\\x03",
 222         [4] = "\\x04", [5] = "\\x05", [6] = "\\x06", [7] = "\\a", [8] = "\\b",
 223         [9] = "\\t", [10] = "\\n", [11] = "\\v", [12] = "\\f", [13] = "\\r",
 224         [14] = "\\x0E", [15] = "\\x0F", [16] = "\\x10", [17] = "\\x11",
 225         [18] = "\\x12", [19] = "\\x13", [20] = "\\x14", [21] = "\\x15",
 226         [22] = "\\x16", [23] = "\\x17", [24] = "\\x18", [25] = "\\x19",
 227         [26] = "\\x1A", [27] = "\\x1B", [28] = "\\x1C", [29] = "\\x1D",
 228         [30] = "\\x1E", [31] = "\\x1F",
 229         [127] = "\\x7F"
 230 };
 231
 232 void ast_print(struct ast *ast, FILE *out)
 233 {
 234         if (ast == NULL)
 235                 return;
 236         for (int i = 0; i<ast->ndecls; i++)
 237                 decl_print(ast->decls[i], 0, out);
 238 }
 239
 240 void decl_print(struct decl *decl, int indent, FILE *out)
 241 {
 242         if (decl == NULL)
 243                 return;
 244         switch(decl->type) {
 245         case dfundecl:
 246                 pindent(indent, out);
 247                 safe_fprintf(out, "%s (", decl->data.dfun.ident);
 248                 for (int i = 0; i<decl->data.dfun.nargs; i++) {
 249                         safe_fprintf(out, "%s", decl->data.dfun.args[i]);
 250                         if (i < decl->data.dfun.nargs - 1)
 251                                 safe_fprintf(out, ", ");
 252                 }
 253                 safe_fprintf(out, ") {\n");
 254                 for (int i = 0; i<decl->data.dfun.nbody; i++)
 255                         stmt_print(decl->data.dfun.body[i], indent+1, out);
 256                 pindent(indent, out);
 257                 safe_fprintf(out, "}\n");
 258                 break;
 259         case dvardecl:
 260                 pindent(indent, out);
 261                 safe_fprintf(out, "var %s = ", decl->data.dvar.ident);
 262                 expr_print(decl->data.dvar.expr, out);
 263                 safe_fprintf(out, ";\n");
 264                 break;
 265         default:
 266                 die("Unsupported decl node\n");
 267         }
 268 }
 269
 270 void stmt_print(struct stmt *stmt, int indent, FILE *out)
 271 {
 272         if (stmt == NULL)
 273                 return;
 274         switch(stmt->type) {
 275         case sassign:
 276                 pindent(indent, out);
 277                 fprintf(out, "%s", stmt->data.sassign.ident);
 278                 safe_fprintf(out, " = ");
 279                 expr_print(stmt->data.sassign.expr, out);
 280                 safe_fprintf(out, ";\n");
 281                 break;
 282         case sif:
 283                 pindent(indent, out);
 284                 safe_fprintf(out, "if (");
 285                 expr_print(stmt->data.sif.pred, out);
 286                 safe_fprintf(out, ") {\n");
 287                 for (int i = 0; i<stmt->data.sif.nthen; i++)
 288                         stmt_print(stmt->data.sif.then[i], indent+1, out);
 289                 pindent(indent, out);
 290                 safe_fprintf(out, "} else {\n");
 291                 for (int i = 0; i<stmt->data.sif.nels; i++)
 292                         stmt_print(stmt->data.sif.els[i], indent+1, out);
 293                 pindent(indent, out);
 294                 safe_fprintf(out, "}\n");
 295                 break;
 296         case sreturn:
 297                 pindent(indent, out);
 298                 safe_fprintf(out, "return ");
 299                 expr_print(stmt->data.sreturn, out);
 300                 safe_fprintf(out, ";\n");
 301                 break;
 302         case sexpr:
 303                 pindent(indent, out);
 304                 expr_print(stmt->data.sexpr, out);
 305                 safe_fprintf(out, ";\n");
 306                 break;
 307         case svardecl:
 308                 pindent(indent, out);
 309                 safe_fprintf(out, "var %s = ", stmt->data.svardecl.ident);
 310                 expr_print(stmt->data.svardecl.expr, out);
 311                 safe_fprintf(out, ";\n");
 312                 break;
 313         case swhile:
 314                 pindent(indent, out);
 315                 safe_fprintf(out, "while (");
 316                 expr_print(stmt->data.swhile.pred, out);
 317                 safe_fprintf(out, ") {\n");
 318                 for (int i = 0; i<stmt->data.swhile.nbody; i++) {
 319                         stmt_print(stmt->data.swhile.body[i], indent+1, out);
 320                 }
 321                 pindent(indent, out);
 322                 safe_fprintf(out, "}\n");
 323                 break;
 324         default:
 325                 die("Unsupported stmt node\n");
 326         }
 327 }
 328
 329 void expr_print(struct expr *expr, FILE *out)
 330 {
 331         if (expr == NULL)
 332                 return;
 333         switch(expr->type) {
 334         case ebinop:
 335                 safe_fprintf(out, "(");
 336                 expr_print(expr->data.ebinop.l, out);
 337                 safe_fprintf(out, "%s", binop_str[expr->data.ebinop.op]);
 338                 expr_print(expr->data.ebinop.r, out);
 339                 safe_fprintf(out, ")");
 340                 break;
 341         case ebool:
 342                 safe_fprintf(out, "%s", expr->data.ebool ? "true" : "false");
 343                 break;
 344         case echar:
 345                 if (expr->data.echar < 0)
 346                         safe_fprintf(out, "'?'");
 347                 if (expr->data.echar < ' ' || expr->data.echar == 127)
 348                         safe_fprintf(out, "'%s'",
 349                                 cescapes[(int)expr->data.echar]);
 350                 else
 351                         safe_fprintf(out, "'%c'", expr->data.echar);
 352                 break;
 353         case efuncall:
 354                 safe_fprintf(out, "%s(", expr->data.efuncall.ident);
 355                 for(int i = 0; i<expr->data.efuncall.nargs; i++) {
 356                         expr_print(expr->data.efuncall.args[i], out);
 357                         if (i+1 < expr->data.efuncall.nargs)
 358                                 safe_fprintf(out, ", ");
 359                 }
 360                 safe_fprintf(out, ")");
 361                 break;
 362         case eint:
 363                 safe_fprintf(out, "%d", expr->data.eint);
 364                 break;
 365         case eident:
 366                 fprintf(out, "%s", expr->data.eident.ident);
 367                 for (int i = 0; i<expr->data.eident.nfields; i++)
 368                         fprintf(out, ".%s",
 369                                 fieldspec_str[expr->data.eident.fields[i]]);
 370                 break;
 371         case enil:
 372                 safe_fprintf(out, "[]");
 373                 break;
 374         case etuple:
 375                 safe_fprintf(out, "(");
 376                 expr_print(expr->data.etuple.left, out);
 377                 safe_fprintf(out, ", ");
 378                 expr_print(expr->data.etuple.right, out);
 379                 safe_fprintf(out, ")");
 380                 break;
 381         case eunop:
 382                 safe_fprintf(out, "(%s", unop_str[expr->data.eunop.op]);
 383                 expr_print(expr->data.eunop.l, out);
 384                 safe_fprintf(out, ")");
 385                 break;
 386         default:
 387                 die("Unsupported expr node\n");
 388         }
 389 }
 390
 391 void ast_free(struct ast *ast)
 392 {
 393         if (ast == NULL)
 394                 return;
 395         for (int i = 0; i<ast->ndecls; i++)
 396                 decl_free(ast->decls[i]);
 397         free(ast->decls);
 398         free(ast);
 399 }
 400
 401 void decl_free(struct decl *decl)
 402 {
 403         if (decl == NULL)
 404                 return;
 405         switch(decl->type) {
 406         case dfundecl:
 407                 free(decl->data.dfun.ident);
 408                 for (int i = 0; i<decl->data.dfun.nargs; i++)
 409                         free(decl->data.dfun.args[i]);
 410                 free(decl->data.dfun.args);
 411                 for (int i = 0; i<decl->data.dfun.nbody; i++)
 412                         stmt_free(decl->data.dfun.body[i]);
 413                 free(decl->data.dfun.body);
 414                 break;
 415         case dvardecl:
 416                 free(decl->data.dvar.ident);
 417                 expr_free(decl->data.dvar.expr);
 418                 break;
 419         default:
 420                 die("Unsupported decl node\n");
 421         }
 422         free(decl);
 423 }
 424
 425 void stmt_free(struct stmt *stmt)
 426 {
 427         if (stmt == NULL)
 428                 return;
 429         switch(stmt->type) {
 430         case sassign:
 431                 free(stmt->data.sassign.ident);
 432                 expr_free(stmt->data.sassign.expr);
 433                 break;
 434         case sif:
 435                 expr_free(stmt->data.sif.pred);
 436                 for (int i = 0; i<stmt->data.sif.nthen; i++)
 437                         stmt_free(stmt->data.sif.then[i]);
 438                 free(stmt->data.sif.then);
 439                 for (int i = 0; i<stmt->data.sif.nels; i++)
 440                         stmt_free(stmt->data.sif.els[i]);
 441                 free(stmt->data.sif.els);
 442                 break;
 443         case sreturn:
 444                 expr_free(stmt->data.sreturn);
 445                 break;
 446         case sexpr:
 447                 expr_free(stmt->data.sexpr);
 448                 break;
 449         case svardecl:
 450                 free(stmt->data.svardecl.ident);
 451                 expr_free(stmt->data.svardecl.expr);
 452                 break;
 453         case swhile:
 454                 expr_free(stmt->data.swhile.pred);
 455                 for (int i = 0; i<stmt->data.swhile.nbody; i++)
 456                         stmt_free(stmt->data.swhile.body[i]);
 457                 free(stmt->data.swhile.body);
 458                 break;
 459         default:
 460                 die("Unsupported stmt node\n");
 461         }
 462         free(stmt);
 463 }
 464
 465 void expr_free(struct expr *expr)
 466 {
 467         switch(expr->type) {
 468         case ebinop:
 469                 expr_free(expr->data.ebinop.l);
 470                 expr_free(expr->data.ebinop.r);
 471                 break;
 472         case ebool:
 473                 break;
 474         case echar:
 475                 break;
 476         case efuncall:
 477                 free(expr->data.efuncall.ident);
 478                 for (int i = 0; i<expr->data.efuncall.nargs; i++)
 479                         expr_free(expr->data.efuncall.args[i]);
 480                 free(expr->data.efuncall.args);
 481                 break;
 482         case eint:
 483                 break;
 484         case eident:
 485                 free(expr->data.eident.ident);
 486                 free(expr->data.eident.fields);
 487                 break;
 488         case enil:
 489                 break;
 490         case etuple:
 491                 expr_free(expr->data.etuple.left);
 492                 expr_free(expr->data.etuple.right);
 493                 break;
 494         case eunop:
 495                 expr_free(expr->data.eunop.l);
 496                 break;
 497         default:
 498                 die("Unsupported expr node\n");
 499         }
 500         free(expr);
 501 }