src/exprData.c

   1 /*
   2 ** exprData.c
   3 */
   4
   5 # include <ctype.h> /* for isdigit */
   6 # include "splintMacros.nf"
   7 # include "basic.h"
   8 # include "cgrammar.h"
   9 # include "cgrammar_tokens.h"
  10
  11 # include "exprChecks.h"
  12 # include "exprNodeSList.h"
  13
  14 void exprData_freeShallow (/*@only@*/ exprData data, exprKind kind)
  15 {
  16   /*@-compdestroy@*/
  17
  18   if (data == exprData_undefined)
  19     {
  20       return;
  21     }
  22
  23   switch (kind)
  24     {
  25     case XPR_INITBLOCK:
  26     case XPR_CALL:
  27       exprNode_freeShallow (data->call->fcn);
  28       exprNodeList_freeShallow (data->call->args);
  29       sfree (data->call);
  30       break;
  31     case XPR_COMMA:
  32     case XPR_FETCH:
  33     case XPR_OP:
  34     case XPR_ASSIGN:
  35     case XPR_IF:
  36     case XPR_WHILE:
  37     case XPR_DOWHILE:
  38     case XPR_STMTLIST:
  39     case XPR_SWITCH:
  40     case XPR_FOR:
  41       exprNode_freeShallow (data->op->a);
  42       exprNode_freeShallow (data->op->b);
  43       sfree (data->op);
  44       break;
  45
  46     case XPR_STMT:
  47     case XPR_PREOP:
  48     case XPR_POSTOP:
  49     case XPR_PARENS:
  50       exprNode_freeShallow (data->uop->a);
  51       sfree (data->uop);
  52       break;
  53
  54     case XPR_FTCASE:
  55     case XPR_CASE:
  56     case XPR_RETURN:
  57     case XPR_WHILEPRED:
  58     case XPR_BLOCK:
  59       exprNode_freeShallow (data->single);
  60       break;
  61
  62     case XPR_CAST:
  63     case XPR_VAARG:
  64       exprNode_freeShallow (data->cast->exp);
  65       /* NO: qtype_free (data->cast->q); */
  66       sfree (data->cast);
  67       break;
  68
  69     case XPR_ITERCALL:
  70       exprNodeList_freeShallow (data->itercall->args);
  71       sfree (data->itercall);
  72       break;
  73
  74     case XPR_ITER:
  75       exprNodeList_freeShallow (data->iter->args);
  76       exprNode_freeShallow (data->iter->body);
  77       sfree (data->iter);
  78       break;
  79
  80     case XPR_FORPRED:
  81     case XPR_COND:
  82     case XPR_IFELSE:
  83       exprNode_freeShallow (data->triple->pred);
  84       exprNode_freeShallow (data->triple->tbranch);
  85       exprNode_freeShallow (data->triple->fbranch);
  86       sfree (data->triple);
  87       break;
  88
  89     case XPR_INIT:
  90       exprNode_freeShallow (data->init->exp);
  91       /* NO: idDecl_free (data->init->id); */
  92       sfree (data->init);
  93       break;
  94
  95     case XPR_FACCESS:
  96     case XPR_ARROW:
  97       exprNode_freeShallow (data->field->rec);
  98       /* NO: cstring_free (data->field->field); */
  99       sfree (data->field);
 100       break;
 101
 102     case XPR_LABEL:
 103     case XPR_CONST:
 104     case XPR_VAR:
 105       break;
 106
 107     case XPR_OFFSETOF:
 108     case XPR_ALIGNOFT:
 109     case XPR_ALIGNOF:
 110     case XPR_SIZEOFT:
 111     case XPR_SIZEOF:
 112     case XPR_GOTO:
 113     case XPR_CONTINUE:
 114     case XPR_BREAK:
 115     case XPR_NULLRETURN:
 116     case XPR_TOK:
 117     case XPR_FTDEFAULT:
 118     case XPR_DEFAULT:
 119       break;
 120
 121     case XPR_STRINGLITERAL:
 122     case XPR_NUMLIT:
 123       llcontbuglit ("exprData_freeShallow: not shallow!");
 124       break;
 125
 126     case XPR_EMPTY:
 127       llcontbuglit ("XPR_EMPTY case!");
 128       break;
 129
 130     case XPR_BODY:
 131       llcontbuglit ("XPR_BODY case!");
 132       break;
 133     case XPR_NODE:
 134       llcontbuglit ("XPR_NODE case!");
 135       break;
 136     }
 137
 138   sfree (data);
 139   /*@=compdestroy@*/
 140 }
 141
 142 void exprData_free (/*@only@*/ exprData data, exprKind kind)
 143 {
 144   if (data == exprData_undefined)
 145     {
 146       return;
 147     }
 148
 149   switch (kind)
 150     {
 151     case XPR_INITBLOCK:
 152     case XPR_CALL:
 153       exprNode_free (data->call->fcn);
 154       exprNodeList_free (data->call->args);
 155       sfree (data->call);
 156       break;
 157
 158     case XPR_LABEL:
 159     case XPR_CONST:
 160     case XPR_VAR:
 161       cstring_free (data->id);
 162       break;
 163
 164     case XPR_COMMA:
 165     case XPR_FETCH:
 166     case XPR_OP:
 167     case XPR_ASSIGN:
 168     case XPR_IF:
 169     case XPR_WHILE:
 170     case XPR_DOWHILE:
 171     case XPR_STMTLIST:
 172     case XPR_SWITCH:
 173     case XPR_FOR:
 174       exprNode_free (data->op->a);
 175       exprNode_free (data->op->b);
 176       sfree (data->op);
 177       break;
 178
 179     case XPR_STMT:
 180     case XPR_PREOP:
 181     case XPR_POSTOP:
 182     case XPR_PARENS:
 183       exprNode_free (data->uop->a);
 184       sfree (data->uop);
 185       break;
 186
 187     case XPR_OFFSETOF:
 188       qtype_free (data->offset->q);
 189       cstringList_free (data->offset->field);
 190       sfree (data->offset);
 191       break;
 192
 193     case XPR_ALIGNOFT:
 194     case XPR_SIZEOFT:
 195       qtype_free (data->qt);
 196       break;
 197
 198     case XPR_FTCASE:
 199     case XPR_CASE:
 200     case XPR_SIZEOF:
 201     case XPR_ALIGNOF:
 202     case XPR_RETURN:
 203     case XPR_WHILEPRED:
 204     case XPR_BLOCK:
 205       exprNode_free (data->single);
 206       break;
 207
 208     case XPR_CAST:
 209     case XPR_VAARG:
 210       exprNode_free (data->cast->exp);
 211       qtype_free (data->cast->q);
 212       sfree (data->cast);
 213       break;
 214
 215     case XPR_ITERCALL:
 216       exprNodeList_free (data->itercall->args);
 217       sfree (data->itercall);
 218       break;
 219
 220     case XPR_ITER:
 221       exprNodeList_free (data->iter->args);
 222       exprNode_free (data->iter->body);
 223       sfree (data->iter);
 224       break;
 225
 226     case XPR_FORPRED:
 227     case XPR_COND:
 228     case XPR_IFELSE:
 229       exprNode_free (data->triple->pred);
 230       exprNode_free (data->triple->tbranch);
 231       exprNode_free (data->triple->fbranch);
 232       sfree (data->triple);
 233       break;
 234
 235     case XPR_GOTO:
 236     case XPR_STRINGLITERAL:
 237     case XPR_NUMLIT:
 238       cstring_free (data->literal);
 239       break;
 240
 241     case XPR_CONTINUE:
 242     case XPR_BREAK:
 243     case XPR_NULLRETURN:
 244       break;
 245
 246     case XPR_FTDEFAULT:
 247     case XPR_DEFAULT:
 248     case XPR_TOK:
 249       break;
 250
 251     case XPR_INIT:
 252       exprNode_free (data->init->exp);
 253       idDecl_free (data->init->id);
 254       sfree (data->init);
 255       break;
 256
 257     case XPR_FACCESS:
 258     case XPR_ARROW:
 259       exprNode_free (data->field->rec);
 260       cstring_free (data->field->field);
 261       sfree (data->field);
 262       break;
 263
 264     case XPR_EMPTY:
 265       llcontbuglit ("XPR_EMPTY case!");
 266       break;
 267     case XPR_BODY:
 268       llcontbuglit ("XPR_BODY case!");
 269       break;
 270     case XPR_NODE:
 271       llcontbuglit ("XPR_NODE case!");
 272       break;
 273     }
 274
 275   sfree (data);
 276 }
 277
 278 /*@exposed@*/ exprNode exprData_getInitNode (exprData data) /*@*/
 279 {
 280   llassert (data != exprData_undefined);
 281   return (data->init->exp);
 282 }
 283
 284 /*@exposed@*/ idDecl exprData_getInitId (exprData data) /*@*/
 285 {
 286   llassert (data != exprData_undefined);
 287   return (data->init->id);
 288 }
 289
 290 /*@exposed@*/ exprNode exprData_getOpA (exprData data) /*@*/
 291 {
 292   llassert (data != exprData_undefined);
 293   return (data->op->a);
 294 }
 295
 296 /*@exposed@*/ exprNode exprData_getOpB (exprData data) /*@*/
 297 {
 298   llassert (data != exprData_undefined);
 299   return (data->op->b);
 300 }
 301
 302 /*@observer@*/ lltok exprData_getOpTok (exprData data) /*@*/
 303 {
 304   llassert (data != exprData_undefined);
 305   return (data->op->op);
 306 }
 307
 308 /*@exposed@*/ exprNode exprData_getPairA (exprData data) /*@*/
 309 {
 310   llassert (data != exprData_undefined);
 311   return (data->pair->a);
 312 }
 313
 314 /*@exposed@*/ exprNode exprData_getPairB (exprData data) /*@*/
 315 {
 316   llassert (data != exprData_undefined);
 317   return (data->pair->b);
 318 }
 319
 320
 321 /*@exposed@*/ uentry exprData_getIterSname (exprData data) /*@*/
 322 {
 323   llassert (data != exprData_undefined);
 324   return (data->iter->sname);
 325 }
 326
 327 /*@exposed@*/ exprNodeList exprData_getIterAlist (exprData data) /*@*/
 328 {
 329   llassert (data != exprData_undefined);
 330   return (data->iter->args);
 331 }
 332
 333 /*@exposed@*/ exprNode exprData_getIterBody (exprData data) /*@*/
 334 {
 335   llassert (data != exprData_undefined);
 336   return (data->iter->body);
 337 }
 338
 339 /*@exposed@*/ uentry exprData_getIterEname (exprData data) /*@*/
 340 {
 341   llassert (data != exprData_undefined);
 342   return (data->iter->ename);
 343 }
 344
 345 /*@exposed@*/ exprNode exprData_getFcn (exprData data) /*@*/
 346 {
 347   llassert (data != exprData_undefined);
 348   return (data->call->fcn);
 349 }
 350
 351 /*@exposed@*/ exprNodeList exprData_getArgs (exprData data) /*@*/
 352 {
 353   llassert (data != exprData_undefined);
 354   return (data->call->args);
 355 }
 356
 357 /*@exposed@*/ exprNode exprData_getTriplePred (exprData data) /*@*/
 358 {
 359   llassert (data != exprData_undefined);
 360   return (data->triple->pred);
 361 }
 362
 363 /*@exposed@*/ uentry exprData_getIterCallIter (exprData data) /*@*/
 364 {
 365   llassert (data != exprData_undefined);
 366   return (data->itercall->iter);
 367 }
 368
 369 /*@exposed@*/ exprNodeList
 370   exprData_getIterCallArgs (exprData data) /*@*/
 371 {
 372   llassert (data != exprData_undefined);
 373   return (data->itercall->args);
 374 }
 375
 376 /*@exposed@*/ exprNode exprData_getTripleInit (exprData data) /*@*/
 377 {
 378   llassert (data != exprData_undefined);
 379   return (data->triple->pred);
 380 }
 381
 382 /*@exposed@*/ exprNode exprData_getTripleTrue (exprData data) /*@*/
 383 {
 384   llassert (data != exprData_undefined);
 385   return (data->triple->tbranch);
 386 }
 387
 388 /*@exposed@*/ exprNode exprData_getTripleTest (exprData data) /*@*/
 389 {
 390   llassert (data != exprData_undefined);
 391   return (data->triple->tbranch);
 392 }
 393
 394 /*@exposed@*/ exprNode exprData_getTripleFalse (exprData data) /*@*/
 395 {
 396   llassert (data != exprData_undefined);
 397   return (data->triple->fbranch);
 398 }
 399
 400 /*@exposed@*/ exprNode exprData_getTripleInc (exprData data) /*@*/
 401 {
 402   llassert (data != exprData_undefined);
 403   return (data->triple->fbranch);
 404 }
 405
 406 /*@exposed@*/ exprNode exprData_getFieldNode (exprData data) /*@*/
 407 {
 408   llassert (data != exprData_undefined);
 409   return (data->field->rec);
 410 }
 411
 412 /*@exposed@*/ cstring exprData_getFieldName (exprData data) /*@*/
 413 {
 414   llassert (data != exprData_undefined);
 415   return (data->field->field);
 416 }
 417
 418 /*@observer@*/ lltok exprData_getUopTok (exprData data) /*@*/
 419 {
 420   llassert (data != exprData_undefined);
 421   return (data->uop->op);
 422 }
 423
 424 /*@exposed@*/ exprNode exprData_getUopNode (exprData data) /*@*/
 425 {
 426   llassert (data != exprData_undefined);
 427   return (data->uop->a);
 428 }
 429
 430 /*@exposed@*/ exprNode exprData_getCastNode (exprData data) /*@*/
 431 {
 432   llassert (data != exprData_undefined);
 433   return (data->cast->exp);
 434 }
 435
 436 /*@observer@*/ lltok exprData_getCastTok (exprData data) /*@*/
 437 {
 438   llassert (data != exprData_undefined);
 439   return (data->cast->tok);
 440 }
 441
 442 /*@exposed@*/ qtype exprData_getCastType (exprData data) /*@*/
 443 {
 444   llassert (data != exprData_undefined);
 445   return (data->cast->q);
 446 }
 447
 448 /*@exposed@*/ cstring exprData_getLiteral (exprData data) /*@*/
 449 {
 450   llassert (data != exprData_undefined);
 451   return (data->literal);
 452 }
 453
 454 /*@exposed@*/ cstring exprData_getId (exprData data) /*@*/
 455 {
 456   llassert (data != exprData_undefined);
 457   return (data->id);
 458 }
 459
 460 /*@observer@*/ lltok exprData_getTok (exprData data) /*@*/
 461 {
 462   llassert (data != exprData_undefined);
 463   return (*data->tok);
 464 }
 465
 466 /*@exposed@*/ qtype exprData_getType (exprData data) /*@*/
 467 {
 468   llassert (data != exprData_undefined);
 469   return (data->qt);
 470 }
 471
 472 /*@exposed@*/ qtype exprData_getOffsetType (exprData data) /*@*/
 473 {
 474   llassert (data != exprData_undefined);
 475   return (data->offset->q);
 476 }
 477
 478 /*@exposed@*/ cstringList exprData_getOffsetName (exprData data) /*@*/
 479 {
 480   llassert (data != exprData_undefined);
 481   return (data->offset->field);
 482 }
 483
 484 /*@exposed@*/ exprNode exprData_getSingle (exprData data) /*@*/
 485 {
 486   exprNode ret;
 487   llassert (data != exprData_undefined);
 488
 489   ret = data->single;
 490   return (ret);
 491 }
 492
 493
 494 /*@only@*/ exprData
 495   exprData_makeOp (/*@keep@*/ exprNode a, /*@keep@*/ exprNode b, /*@keep@*/ lltok op)
 496 {
 497   exprData ed = (exprData) dmalloc (sizeof (*ed));
 498
 499   ed->op = (exprOp) dmalloc (sizeof (*ed->op));
 500   ed->op->a = a;
 501   ed->op->b = b;
 502   ed->op->op = op;
 503
 504   return ed;
 505 }
 506
 507 /*@only@*/ exprData exprData_makeUop (/*@keep@*/ exprNode a, /*@keep@*/ lltok op)
 508 {
 509   exprData ed = (exprData) dmalloc (sizeof (*ed));
 510
 511   ed->uop = (exprUop) dmalloc (sizeof (*ed->uop));
 512   ed->uop->a = a;
 513   ed->uop->op = op;
 514
 515   return ed;
 516 }
 517
 518 /*@only@*/ exprData exprData_makeSingle (/*@only@*/ exprNode a)
 519 {
 520   exprData ed = (exprData) dmalloc (sizeof (*ed));
 521
 522   ed->single = a;
 523   return ed;
 524 }
 525
 526 /*@only@*/ exprData exprData_makeTok (/*@only@*/ lltok op)
 527 {
 528   exprData ed = (exprData) dmalloc (sizeof (*ed));
 529
 530   ed->tok = (lltok *) dmalloc (sizeof (*(ed->tok)));
 531   *(ed->tok) = op;
 532   return ed;
 533 }
 534
 535 /*@only@*/ exprData
 536 exprData_makeIter (/*@exposed@*/ uentry sname, /*@keep@*/ exprNodeList args,
 537                    /*@keep@*/ exprNode body, /*@exposed@*/ uentry ename)
 538 {
 539   exprData ed = (exprData) dmalloc (sizeof (*ed));
 540
 541   ed->iter = (exprIter) dmalloc (sizeof (*ed->iter));
 542   ed->iter->sname = uentry_isVar (sname) ? uentry_copy (sname) : sname;
 543   ed->iter->args = args;
 544   ed->iter->body = body;
 545   ed->iter->ename = uentry_isVar (ename) ? uentry_copy (ename) : ename;
 546   return ed;
 547 }
 548
 549 /*@only@*/ exprData exprData_makeTriple (/*@keep@*/ exprNode pred,
 550                                                 /*@keep@*/ exprNode tbranch,
 551                                                 /*@keep@*/ exprNode fbranch)
 552 {
 553   exprData ed = (exprData) dmalloc (sizeof (*ed));
 554
 555   ed->triple = (exprTriple) dmalloc (sizeof (*ed->triple));
 556   ed->triple->pred = pred;
 557   ed->triple->tbranch = tbranch;
 558   ed->triple->fbranch = fbranch;
 559
 560   return ed;
 561 }
 562
 563 /*@only@*/ exprData exprData_makeCall (/*@keep@*/ exprNode fcn,
 564                                               /*@keep@*/ exprNodeList args)
 565 {
 566   exprData ed = (exprData) dmalloc (sizeof (*ed));
 567
 568   ed->call = (exprCall) dmalloc (sizeof (*ed->call));
 569   ed->call->fcn = fcn;
 570   ed->call->args = args;
 571
 572   return ed;
 573 }
 574
 575 /*@only@*/ exprData exprData_makeIterCall (/*@dependent@*/ uentry iter,
 576                                                   /*@keep@*/ exprNodeList args)
 577 {
 578   exprData ed = (exprData) dmalloc (sizeof (*ed));
 579
 580   ed->itercall = (exprIterCall) dmalloc (sizeof (*ed->itercall));
 581   ed->itercall->iter = uentry_isVar (iter) ? uentry_copy (iter) : iter;
 582   ed->itercall->args = args;
 583
 584   return ed;
 585 }
 586
 587 /*@only@*/ exprData exprData_makeField (/*@keep@*/ exprNode rec,
 588                                                /*@keep@*/ cstring field)
 589 {
 590   exprData ed = (exprData) dmalloc (sizeof (*ed));
 591
 592   ed->field = (exprField) dmalloc (sizeof (*ed->field));
 593   ed->field->rec = rec;
 594   ed->field->field = field;
 595
 596   return ed;
 597 }
 598
 599 /*@only@*/ exprData exprData_makeOffsetof (/*@only@*/ qtype q,
 600                                                   /*@keep@*/ cstringList s)
 601 {
 602   exprData ed = (exprData) dmalloc (sizeof (*ed));
 603   ed->offset = (exprOffsetof) dmalloc (sizeof (*ed->offset));
 604
 605   ed->offset->q = q;
 606   ed->offset->field = s;
 607   return ed;
 608 }
 609
 610 /*@only@*/ exprData exprData_makeSizeofType (/*@only@*/ qtype q)
 611 {
 612   exprData ed = (exprData) dmalloc (sizeof (*ed));
 613
 614   ed->qt = q;
 615   return ed;
 616 }
 617
 618 /*@only@*/ exprData
 619   exprData_makeCast (/*@keep@*/ lltok tok, /*@keep@*/ exprNode e, /*@only@*/ qtype q)
 620 {
 621   exprData ed = (exprData) dmalloc (sizeof (*ed));
 622
 623   ed->cast = (exprCast) dmalloc (sizeof (*ed->cast));
 624   ed->cast->tok = tok;
 625   ed->cast->exp = e;
 626   ed->cast->q = q;
 627
 628   return ed;
 629 }
 630
 631 /*@only@*/ exprData
 632   exprData_makeInit (/*@keep@*/ idDecl t, /*@keep@*/ exprNode e)
 633 {
 634   exprData ed = (exprData) dmalloc (sizeof (*ed));
 635
 636   ed->init = (exprInit) dmalloc (sizeof (*ed->init));
 637   ed->init->exp = e;
 638   ed->init->id = t;
 639
 640   return ed;
 641 }
 642
 643 /*@only@*/ exprData exprData_makeCond (/*@keep@*/ exprNode pred,
 644                                               /*@keep@*/ exprNode ifclause,
 645                                               /*@keep@*/ exprNode elseclause)
 646 {
 647   return exprData_makeTriple (pred, ifclause, elseclause);
 648 }
 649
 650 /*@only@*/ exprData exprData_makeFor (/*@keep@*/ exprNode init,
 651                                       /*@keep@*/ exprNode pred,
 652                                       /*@keep@*/ exprNode inc)
 653 {
 654   return exprData_makeTriple (init, pred, inc);
 655 }
 656
 657
 658 /*@only@*/ exprData exprData_makeLiteral (/*@only@*/ cstring s)
 659 {
 660   exprData ed = (exprData) dmalloc (sizeof (*ed));
 661
 662   ed->literal = s;
 663   return ed;
 664 }
 665
 666 /*@only@*/ exprData exprData_makeId (/*@temp@*/ uentry id)
 667 {
 668   exprData ed = (exprData) dmalloc (sizeof (*ed));
 669   ed->id = cstring_copy (uentry_rawName (id));
 670   return ed;
 671 }
 672
 673 /*@only@*/ exprData exprData_makePair (/*@keep@*/ exprNode a, /*@keep@*/ exprNode b)
 674 {
 675   exprData ed = (exprData) dmalloc (sizeof (*ed));
 676
 677   ed->pair = (exprPair) dmalloc (sizeof (*ed->pair));
 678   ed->pair->a = a;
 679   ed->pair->b = b;
 680
 681   return ed;
 682 }