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   llassertretval (data != exprData_undefined, exprNode_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   llassertretval (data != exprData_undefined, exprNode_undefined);
 311   return (data->pair->a);
 312 }
 313
 314 /*@exposed@*/ exprNode exprData_getPairB (exprData data) /*@*/
 315 {
 316   llassertretval (data != exprData_undefined, exprNode_undefined);
 317   return (data->pair->b);
 318 }
 319
 320 /*@exposed@*/ uentry exprData_getIterSname (exprData data) /*@*/
 321 {
 322   llassertretval (data != exprData_undefined, uentry_undefined);
 323   return (data->iter->sname);
 324 }
 325
 326 /*@exposed@*/ exprNodeList exprData_getIterAlist (exprData data) /*@*/
 327 {
 328   llassert (data != exprData_undefined);
 329   return (data->iter->args);
 330 }
 331
 332 /*@exposed@*/ exprNode exprData_getIterBody (exprData data) /*@*/
 333 {
 334   llassertretval (data != exprData_undefined, exprNode_undefined);
 335   return (data->iter->body);
 336 }
 337
 338 /*@exposed@*/ uentry exprData_getIterEname (exprData data) /*@*/
 339 {
 340   llassertretval (data != exprData_undefined, uentry_undefined);
 341   return (data->iter->ename);
 342 }
 343
 344 /*@exposed@*/ exprNode exprData_getFcn (exprData data) /*@*/
 345 {
 346   llassertretval (data != exprData_undefined, exprNode_undefined);
 347   return (data->call->fcn);
 348 }
 349
 350 /*@exposed@*/ exprNodeList exprData_getArgs (exprData data) /*@*/
 351 {
 352   llassert (data != exprData_undefined);
 353   return (data->call->args);
 354 }
 355
 356 /*@exposed@*/ exprNode exprData_getTriplePred (exprData data) /*@*/
 357 {
 358   llassert (data != exprData_undefined);
 359   return (data->triple->pred);
 360 }
 361
 362 /*@exposed@*/ uentry exprData_getIterCallIter (exprData data) /*@*/
 363 {
 364   llassert (data != exprData_undefined);
 365   return (data->itercall->iter);
 366 }
 367
 368 /*@exposed@*/ exprNodeList
 369   exprData_getIterCallArgs (exprData data) /*@*/
 370 {
 371   llassert (data != exprData_undefined);
 372   return (data->itercall->args);
 373 }
 374
 375 /*@exposed@*/ exprNode exprData_getTripleInit (exprData data) /*@*/
 376 {
 377   llassert (data != exprData_undefined);
 378   return (data->triple->pred);
 379 }
 380
 381 /*@exposed@*/ exprNode exprData_getTripleTrue (exprData data) /*@*/
 382 {
 383   llassert (data != exprData_undefined);
 384   return (data->triple->tbranch);
 385 }
 386
 387 /*@exposed@*/ exprNode exprData_getTripleTest (exprData data) /*@*/
 388 {
 389   llassert (data != exprData_undefined);
 390   return (data->triple->tbranch);
 391 }
 392
 393 /*@exposed@*/ exprNode exprData_getTripleFalse (exprData data) /*@*/
 394 {
 395   llassert (data != exprData_undefined);
 396   return (data->triple->fbranch);
 397 }
 398
 399 /*@exposed@*/ exprNode exprData_getTripleInc (exprData data) /*@*/
 400 {
 401   llassert (data != exprData_undefined);
 402   return (data->triple->fbranch);
 403 }
 404
 405 /*@exposed@*/ exprNode exprData_getFieldNode (exprData data) /*@*/
 406 {
 407   llassert (data != exprData_undefined);
 408   return (data->field->rec);
 409 }
 410
 411 /*@exposed@*/ cstring exprData_getFieldName (exprData data) /*@*/
 412 {
 413   llassert (data != exprData_undefined);
 414   return (data->field->field);
 415 }
 416
 417 /*@observer@*/ lltok exprData_getUopTok (exprData data) /*@*/
 418 {
 419   llassert (data != exprData_undefined);
 420   return (data->uop->op);
 421 }
 422
 423 /*@exposed@*/ exprNode exprData_getUopNode (exprData data) /*@*/
 424 {
 425   llassert (data != exprData_undefined);
 426   return (data->uop->a);
 427 }
 428
 429 /*@exposed@*/ exprNode exprData_getCastNode (exprData data) /*@*/
 430 {
 431   llassert (data != exprData_undefined);
 432   return (data->cast->exp);
 433 }
 434
 435 /*@observer@*/ lltok exprData_getCastTok (exprData data) /*@*/
 436 {
 437   llassert (data != exprData_undefined);
 438   return (data->cast->tok);
 439 }
 440
 441 /*@exposed@*/ qtype exprData_getCastType (exprData data) /*@*/
 442 {
 443   llassert (data != exprData_undefined);
 444   return (data->cast->q);
 445 }
 446
 447 /*@exposed@*/ cstring exprData_getLiteral (exprData data) /*@*/
 448 {
 449   llassert (data != exprData_undefined);
 450   return (data->literal);
 451 }
 452
 453 /*@exposed@*/ cstring exprData_getId (exprData data) /*@*/
 454 {
 455   llassert (data != exprData_undefined);
 456   return (data->id);
 457 }
 458
 459 /*@observer@*/ lltok exprData_getTok (exprData data) /*@*/
 460 {
 461   llassert (data != exprData_undefined);
 462   return data->tok;
 463 }
 464
 465 /*@exposed@*/ qtype exprData_getType (exprData data) /*@*/
 466 {
 467   llassert (data != exprData_undefined);
 468   return (data->qt);
 469 }
 470
 471 /*@exposed@*/ qtype exprData_getOffsetType (exprData data) /*@*/
 472 {
 473   llassert (data != exprData_undefined);
 474   return (data->offset->q);
 475 }
 476
 477 /*@exposed@*/ cstringList exprData_getOffsetName (exprData data) /*@*/
 478 {
 479   llassert (data != exprData_undefined);
 480   return (data->offset->field);
 481 }
 482
 483 /*@exposed@*/ exprNode exprData_getSingle (exprData data) /*@*/
 484 {
 485   exprNode ret;
 486   llassert (data != exprData_undefined);
 487
 488   ret = data->single;
 489   return (ret);
 490 }
 491
 492
 493 /*@only@*/ exprData
 494   exprData_makeOp (/*@keep@*/ exprNode a, /*@keep@*/ exprNode b, /*@keep@*/ lltok op)
 495 {
 496   exprData ed = (exprData) dmalloc (sizeof (*ed));
 497
 498   ed->op = (exprOp) dmalloc (sizeof (*ed->op));
 499   ed->op->a = a;
 500   ed->op->b = b;
 501   ed->op->op = op;
 502
 503   return ed;
 504 }
 505
 506 /*@only@*/ exprData exprData_makeUop (/*@keep@*/ exprNode a, /*@keep@*/ lltok op)
 507 {
 508   exprData ed = (exprData) dmalloc (sizeof (*ed));
 509
 510   ed->uop = (exprUop) dmalloc (sizeof (*ed->uop));
 511   ed->uop->a = a;
 512   ed->uop->op = op;
 513
 514   return ed;
 515 }
 516
 517 /*@only@*/ exprData exprData_makeSingle (/*@only@*/ exprNode a)
 518 {
 519   exprData ed = (exprData) dmalloc (sizeof (*ed));
 520
 521   ed->single = a;
 522   return ed;
 523 }
 524
 525 /*@only@*/ exprData exprData_makeTok (/*@only@*/ lltok op)
 526 {
 527   exprData ed = (exprData) dmalloc (sizeof (*ed));
 528   ed->tok = op;
 529
 530   return ed;
 531 }
 532
 533 /*@only@*/ exprData
 534 exprData_makeIter (/*@exposed@*/ uentry sname, /*@keep@*/ exprNodeList args,
 535                    /*@keep@*/ exprNode body, /*@exposed@*/ uentry ename)
 536 {
 537   exprData ed = (exprData) dmalloc (sizeof (*ed));
 538
 539   ed->iter = (exprIter) dmalloc (sizeof (*ed->iter));
 540   ed->iter->sname = uentry_isVar (sname) ? uentry_copy (sname) : sname;
 541   ed->iter->args = args;
 542   ed->iter->body = body;
 543   ed->iter->ename = uentry_isVar (ename) ? uentry_copy (ename) : ename;
 544   return ed;
 545 }
 546
 547 /*@only@*/ exprData exprData_makeTriple (/*@keep@*/ exprNode pred,
 548                                                 /*@keep@*/ exprNode tbranch,
 549                                                 /*@keep@*/ exprNode fbranch)
 550 {
 551   exprData ed = (exprData) dmalloc (sizeof (*ed));
 552
 553   ed->triple = (exprTriple) dmalloc (sizeof (*ed->triple));
 554   ed->triple->pred = pred;
 555   ed->triple->tbranch = tbranch;
 556   ed->triple->fbranch = fbranch;
 557
 558   return ed;
 559 }
 560
 561 /*@only@*/ exprData exprData_makeCall (/*@keep@*/ exprNode fcn,
 562                                               /*@keep@*/ exprNodeList args)
 563 {
 564   exprData ed = (exprData) dmalloc (sizeof (*ed));
 565
 566   ed->call = (exprCall) dmalloc (sizeof (*ed->call));
 567   ed->call->fcn = fcn;
 568   ed->call->args = args;
 569
 570   return ed;
 571 }
 572
 573 /*@only@*/ exprData exprData_makeIterCall (/*@dependent@*/ uentry iter,
 574                                                   /*@keep@*/ exprNodeList args)
 575 {
 576   exprData ed = (exprData) dmalloc (sizeof (*ed));
 577
 578   ed->itercall = (exprIterCall) dmalloc (sizeof (*ed->itercall));
 579   ed->itercall->iter = uentry_isVar (iter) ? uentry_copy (iter) : iter;
 580   ed->itercall->args = args;
 581
 582   return ed;
 583 }
 584
 585 /*@only@*/ exprData exprData_makeField (/*@keep@*/ exprNode rec,
 586                                                /*@keep@*/ cstring field)
 587 {
 588   exprData ed = (exprData) dmalloc (sizeof (*ed));
 589
 590   ed->field = (exprField) dmalloc (sizeof (*ed->field));
 591   ed->field->rec = rec;
 592   ed->field->field = field;
 593
 594   return ed;
 595 }
 596
 597 /*@only@*/ exprData exprData_makeOffsetof (/*@only@*/ qtype q,
 598                                                   /*@keep@*/ cstringList s)
 599 {
 600   exprData ed = (exprData) dmalloc (sizeof (*ed));
 601   ed->offset = (exprOffsetof) dmalloc (sizeof (*ed->offset));
 602
 603   ed->offset->q = q;
 604   ed->offset->field = s;
 605   return ed;
 606 }
 607
 608 /*@only@*/ exprData exprData_makeSizeofType (/*@only@*/ qtype q)
 609 {
 610   exprData ed = (exprData) dmalloc (sizeof (*ed));
 611
 612   ed->qt = q;
 613   return ed;
 614 }
 615
 616 /*@only@*/ exprData
 617   exprData_makeCast (/*@keep@*/ lltok tok, /*@keep@*/ exprNode e, /*@only@*/ qtype q)
 618 {
 619   exprData ed = (exprData) dmalloc (sizeof (*ed));
 620
 621   ed->cast = (exprCast) dmalloc (sizeof (*ed->cast));
 622   ed->cast->tok = tok;
 623   ed->cast->exp = e;
 624   ed->cast->q = q;
 625
 626   return ed;
 627 }
 628
 629 /*@only@*/ exprData
 630   exprData_makeInit (/*@keep@*/ idDecl t, /*@keep@*/ exprNode e)
 631 {
 632   exprData ed = (exprData) dmalloc (sizeof (*ed));
 633
 634   ed->init = (exprInit) dmalloc (sizeof (*ed->init));
 635   ed->init->exp = e;
 636   ed->init->id = t;
 637
 638   return ed;
 639 }
 640
 641 /*@only@*/ exprData exprData_makeCond (/*@keep@*/ exprNode pred,
 642                                               /*@keep@*/ exprNode ifclause,
 643                                               /*@keep@*/ exprNode elseclause)
 644 {
 645   return exprData_makeTriple (pred, ifclause, elseclause);
 646 }
 647
 648 /*@only@*/ exprData exprData_makeFor (/*@keep@*/ exprNode init,
 649                                       /*@keep@*/ exprNode pred,
 650                                       /*@keep@*/ exprNode inc)
 651 {
 652   return exprData_makeTriple (init, pred, inc);
 653 }
 654
 655
 656 /*@only@*/ exprData exprData_makeLiteral (/*@only@*/ cstring s)
 657 {
 658   exprData ed = (exprData) dmalloc (sizeof (*ed));
 659
 660   ed->literal = s;
 661   return ed;
 662 }
 663
 664 /*@only@*/ exprData exprData_makeId (/*@temp@*/ uentry id)
 665 {
 666   exprData ed = (exprData) dmalloc (sizeof (*ed));
 667   ed->id = cstring_copy (uentry_rawName (id));
 668   return ed;
 669 }
 670
 671 /*@only@*/ exprData exprData_makePair (/*@keep@*/ exprNode a, /*@keep@*/ exprNode b)
 672 {
 673   exprData ed = (exprData) dmalloc (sizeof (*ed));
 674
 675   ed->pair = (exprPair) dmalloc (sizeof (*ed->pair));
 676   ed->pair->a = a;
 677   ed->pair->b = b;
 678
 679   return ed;
 680 }