ast.c

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