src/exprData.i

   1 /* ;-*-C-*-; */
   2
   3 /*
   4 ** freeShallow: free exprData created from exprNode_effect calls.
   5 **    All but the innermost storage is free'd.
   6 */
   7
   8 /*@i777*/
   9 /*@-fcnuse*/
  10 /*@-shadow*/
  11
  12 static void exprData_freeShallow (/*@only@*/ exprData data, exprKind kind)
  13 {
  14   /*@-compdestroy@*/
  15
  16   if (data == exprData_undefined)
  17     {
  18       return;
  19     }
  20
  21   switch (kind)
  22     {
  23     case XPR_INITBLOCK:
  24     case XPR_CALL:
  25       exprNode_freeShallow (data->call->fcn);
  26       exprNodeList_freeShallow (data->call->args);
  27       sfree (data->call);
  28       break;
  29     case XPR_COMMA:
  30     case XPR_FETCH:
  31     case XPR_OP:
  32     case XPR_ASSIGN:
  33     case XPR_IF:
  34     case XPR_WHILE:
  35     case XPR_DOWHILE:
  36     case XPR_STMTLIST:
  37     case XPR_SWITCH:
  38     case XPR_FOR:
  39       exprNode_freeShallow (data->op->a);
  40       exprNode_freeShallow (data->op->b);
  41       sfree (data->op);
  42       break;
  43
  44     case XPR_STMT:
  45     case XPR_PREOP:
  46     case XPR_POSTOP:
  47     case XPR_PARENS:
  48       exprNode_freeShallow (data->uop->a);
  49       sfree (data->uop);
  50       break;
  51
  52     case XPR_FTCASE:
  53     case XPR_CASE:
  54     case XPR_RETURN:
  55     case XPR_WHILEPRED:
  56     case XPR_BLOCK:
  57       exprNode_freeShallow (data->single);
  58       break;
  59
  60     case XPR_CAST:
  61     case XPR_VAARG:
  62       exprNode_freeShallow (data->cast->exp);
  63       /* NO: qtype_free (data->cast->q); */
  64       sfree (data->cast);
  65       break;
  66
  67     case XPR_ITERCALL:
  68       exprNodeList_freeShallow (data->itercall->args);
  69       sfree (data->itercall);
  70       break;
  71
  72     case XPR_ITER:
  73       exprNodeList_freeShallow (data->iter->args);
  74       exprNode_freeShallow (data->iter->body);
  75       sfree (data->iter);
  76       break;
  77
  78     case XPR_FORPRED:
  79     case XPR_COND:
  80     case XPR_IFELSE:
  81       exprNode_freeShallow (data->triple->pred);
  82       exprNode_freeShallow (data->triple->tbranch);
  83       exprNode_freeShallow (data->triple->fbranch);
  84       sfree (data->triple);
  85       break;
  86
  87     case XPR_INIT:
  88       exprNode_freeShallow (data->init->exp);
  89       /* NO: idDecl_free (data->init->id); */
  90       sfree (data->init);
  91       break;
  92
  93     case XPR_FACCESS:
  94     case XPR_ARROW:
  95       exprNode_freeShallow (data->field->rec);
  96       /* NO: cstring_free (data->field->field); */
  97       sfree (data->field);
  98       break;
  99
 100     case XPR_LABEL:
 101     case XPR_CONST:
 102     case XPR_VAR:
 103       break;
 104
 105     case XPR_OFFSETOF:
 106     case XPR_ALIGNOFT:
 107     case XPR_ALIGNOF:
 108     case XPR_SIZEOFT:
 109     case XPR_SIZEOF:
 110     case XPR_GOTO:
 111     case XPR_CONTINUE:
 112     case XPR_BREAK:
 113     case XPR_NULLRETURN:
 114     case XPR_TOK:
 115     case XPR_FTDEFAULT:
 116     case XPR_DEFAULT:
 117       break;
 118
 119     case XPR_STRINGLITERAL:
 120     case XPR_NUMLIT:
 121       llcontbuglit ("exprData_freeShallow: not shallow!");
 122       break;
 123
 124     case XPR_EMPTY:
 125       llcontbuglit ("XPR_EMPTY case!");
 126       break;
 127
 128     case XPR_BODY:
 129       llcontbuglit ("XPR_BODY case!");
 130       break;
 131     case XPR_NODE:
 132       llcontbuglit ("XPR_NODE case!");
 133       break;
 134     }
 135
 136   sfree (data);
 137   /*@=compdestroy@*/
 138 }
 139
 140 static void exprData_free (/*@only@*/ exprData data, exprKind kind)
 141 {
 142   if (data == exprData_undefined)
 143     {
 144       return;
 145     }
 146
 147   switch (kind)
 148     {
 149     case XPR_INITBLOCK:
 150     case XPR_CALL:
 151       exprNode_free (data->call->fcn);
 152       exprNodeList_free (data->call->args);
 153       sfree (data->call);
 154       break;
 155
 156     case XPR_LABEL:
 157     case XPR_CONST:
 158     case XPR_VAR:
 159       cstring_free (data->id);
 160       break;
 161
 162     case XPR_COMMA:
 163     case XPR_FETCH:
 164     case XPR_OP:
 165     case XPR_ASSIGN:
 166     case XPR_IF:
 167     case XPR_WHILE:
 168     case XPR_DOWHILE:
 169     case XPR_STMTLIST:
 170     case XPR_SWITCH:
 171     case XPR_FOR:
 172       exprNode_free (data->op->a);
 173       exprNode_free (data->op->b);
 174       sfree (data->op);
 175       break;
 176
 177     case XPR_STMT:
 178     case XPR_PREOP:
 179     case XPR_POSTOP:
 180     case XPR_PARENS:
 181       exprNode_free (data->uop->a);
 182       sfree (data->uop);
 183       break;
 184
 185     case XPR_OFFSETOF:
 186       qtype_free (data->offset->q);
 187       cstringList_free (data->offset->field);
 188       sfree (data->offset);
 189       break;
 190
 191     case XPR_ALIGNOFT:
 192     case XPR_SIZEOFT:
 193       qtype_free (data->qt);
 194       break;
 195
 196     case XPR_FTCASE:
 197     case XPR_CASE:
 198     case XPR_SIZEOF:
 199     case XPR_ALIGNOF:
 200     case XPR_RETURN:
 201     case XPR_WHILEPRED:
 202     case XPR_BLOCK:
 203       exprNode_free (data->single);
 204       break;
 205
 206     case XPR_CAST:
 207     case XPR_VAARG:
 208       exprNode_free (data->cast->exp);
 209       qtype_free (data->cast->q);
 210       sfree (data->cast);
 211       break;
 212
 213     case XPR_ITERCALL:
 214       exprNodeList_free (data->itercall->args);
 215       sfree (data->itercall);
 216       break;
 217
 218     case XPR_ITER:
 219       exprNodeList_free (data->iter->args);
 220       exprNode_free (data->iter->body);
 221       sfree (data->iter);
 222       break;
 223
 224     case XPR_FORPRED:
 225     case XPR_COND:
 226     case XPR_IFELSE:
 227       exprNode_free (data->triple->pred);
 228       exprNode_free (data->triple->tbranch);
 229       exprNode_free (data->triple->fbranch);
 230       sfree (data->triple);
 231       break;
 232
 233     case XPR_GOTO:
 234     case XPR_STRINGLITERAL:
 235     case XPR_NUMLIT:
 236       cstring_free (data->literal);
 237       break;
 238
 239     case XPR_CONTINUE:
 240     case XPR_BREAK:
 241     case XPR_NULLRETURN:
 242       break;
 243
 244     case XPR_FTDEFAULT:
 245     case XPR_DEFAULT:
 246     case XPR_TOK:
 247       break;
 248
 249     case XPR_INIT:
 250       exprNode_free (data->init->exp);
 251       idDecl_free (data->init->id);
 252       sfree (data->init);
 253       break;
 254
 255     case XPR_FACCESS:
 256     case XPR_ARROW:
 257       exprNode_free (data->field->rec);
 258       cstring_free (data->field->field);
 259       sfree (data->field);
 260       break;
 261
 262     case XPR_EMPTY:
 263       llcontbuglit ("XPR_EMPTY case!");
 264       break;
 265     case XPR_BODY:
 266       llcontbuglit ("XPR_BODY case!");
 267       break;
 268     case XPR_NODE:
 269       llcontbuglit ("XPR_NODE case!");
 270       break;
 271     }
 272
 273   sfree (data);
 274 }
 275
 276 static /*@exposed@*/ exprNode exprData_getInitNode (exprData data) /*@*/
 277 {
 278   llassert (data != exprData_undefined);
 279   return (data->init->exp);
 280 }
 281
 282 static /*@exposed@*/ idDecl exprData_getInitId (exprData data) /*@*/
 283 {
 284   llassert (data != exprData_undefined);
 285   return (data->init->id);
 286 }
 287
 288 static /*@exposed@*/ exprNode exprData_getOpA (exprData data) /*@*/
 289 {
 290   llassert (data != exprData_undefined);
 291   return (data->op->a);
 292 }
 293
 294 static /*@exposed@*/ exprNode exprData_getOpB (exprData data) /*@*/
 295 {
 296   llassert (data != exprData_undefined);
 297   return (data->op->b);
 298 }
 299
 300 static /*@observer@*/ lltok exprData_getOpTok (exprData data) /*@*/
 301 {
 302   llassert (data != exprData_undefined);
 303   return (data->op->op);
 304 }
 305
 306 static /*@exposed@*/ exprNode exprData_getPairA (exprData data) /*@*/
 307 {
 308   llassert (data != exprData_undefined);
 309   return (data->pair->a);
 310 }
 311
 312 static /*@exposed@*/ exprNode exprData_getPairB (exprData data) /*@*/
 313 {
 314   llassert (data != exprData_undefined);
 315   return (data->pair->b);
 316 }
 317
 318
 319 static /*@exposed@*/ uentry exprData_getIterSname (exprData data) /*@*/
 320 {
 321   llassert (data != exprData_undefined);
 322   return (data->iter->sname);
 323 }
 324
 325 static /*@exposed@*/ exprNodeList exprData_getIterAlist (exprData data) /*@*/
 326 {
 327   llassert (data != exprData_undefined);
 328   return (data->iter->args);
 329 }
 330
 331 static /*@exposed@*/ exprNode exprData_getIterBody (exprData data) /*@*/
 332 {
 333   llassert (data != exprData_undefined);
 334   return (data->iter->body);
 335 }
 336
 337 static /*@exposed@*/ uentry exprData_getIterEname (exprData data) /*@*/
 338 {
 339   llassert (data != exprData_undefined);
 340   return (data->iter->ename);
 341 }
 342
 343 static /*@exposed@*/ exprNode exprData_getFcn (exprData data) /*@*/
 344 {
 345   llassert (data != exprData_undefined);
 346   return (data->call->fcn);
 347 }
 348
 349 static /*@exposed@*/ exprNodeList exprData_getArgs (exprData data) /*@*/
 350 {
 351   llassert (data != exprData_undefined);
 352   return (data->call->args);
 353 }
 354
 355 static /*@exposed@*/ exprNode exprData_getTriplePred (exprData data) /*@*/
 356 {
 357   llassert (data != exprData_undefined);
 358   return (data->triple->pred);
 359 }
 360
 361 static /*@exposed@*/ uentry exprData_getIterCallIter (exprData data) /*@*/
 362 {
 363   llassert (data != exprData_undefined);
 364   return (data->itercall->iter);
 365 }
 366
 367 static /*@exposed@*/ exprNodeList
 368   exprData_getIterCallArgs (exprData data) /*@*/
 369 {
 370   llassert (data != exprData_undefined);
 371   return (data->itercall->args);
 372 }
 373
 374 static /*@exposed@*/ exprNode exprData_getTripleInit (exprData data) /*@*/
 375 {
 376   llassert (data != exprData_undefined);
 377   return (data->triple->pred);
 378 }
 379
 380 static /*@exposed@*/ exprNode exprData_getTripleTrue (exprData data) /*@*/
 381 {
 382   llassert (data != exprData_undefined);
 383   return (data->triple->tbranch);
 384 }
 385
 386 static /*@exposed@*/ exprNode exprData_getTripleTest (exprData data) /*@*/
 387 {
 388   llassert (data != exprData_undefined);
 389   return (data->triple->tbranch);
 390 }
 391
 392 static /*@exposed@*/ exprNode exprData_getTripleFalse (exprData data) /*@*/
 393 {
 394   llassert (data != exprData_undefined);
 395   return (data->triple->fbranch);
 396 }
 397
 398 static /*@exposed@*/ exprNode exprData_getTripleInc (exprData data) /*@*/
 399 {
 400   llassert (data != exprData_undefined);
 401   return (data->triple->fbranch);
 402 }
 403
 404 static /*@exposed@*/ exprNode exprData_getFieldNode (exprData data) /*@*/
 405 {
 406   llassert (data != exprData_undefined);
 407   return (data->field->rec);
 408 }
 409
 410 static /*@exposed@*/ cstring exprData_getFieldName (exprData data) /*@*/
 411 {
 412   llassert (data != exprData_undefined);
 413   return (data->field->field);
 414 }
 415
 416 static /*@observer@*/ lltok exprData_getUopTok (exprData data) /*@*/
 417 {
 418   llassert (data != exprData_undefined);
 419   return (data->uop->op);
 420 }
 421
 422 static /*@exposed@*/ exprNode exprData_getUopNode (exprData data) /*@*/
 423 {
 424   llassert (data != exprData_undefined);
 425   return (data->uop->a);
 426 }
 427
 428 static /*@exposed@*/ exprNode exprData_getCastNode (exprData data) /*@*/
 429 {
 430   llassert (data != exprData_undefined);
 431   return (data->cast->exp);
 432 }
 433
 434 static /*@observer@*/ lltok exprData_getCastTok (exprData data) /*@*/
 435 {
 436   llassert (data != exprData_undefined);
 437   return (data->cast->tok);
 438 }
 439
 440 static /*@exposed@*/ qtype exprData_getCastType (exprData data) /*@*/
 441 {
 442   llassert (data != exprData_undefined);
 443   return (data->cast->q);
 444 }
 445
 446 static /*@exposed@*/ cstring exprData_getLiteral (exprData data) /*@*/
 447 {
 448   llassert (data != exprData_undefined);
 449   return (data->literal);
 450 }
 451
 452 static /*@exposed@*/ cstring exprData_getId (exprData data) /*@*/
 453 {
 454   llassert (data != exprData_undefined);
 455   return (data->id);
 456 }
 457
 458 static /*@observer@*/ lltok exprData_getTok (exprData data) /*@*/
 459 {
 460   llassert (data != exprData_undefined);
 461   return (*data->tok);
 462 }
 463
 464 static /*@exposed@*/ qtype exprData_getType (exprData data) /*@*/
 465 {
 466   llassert (data != exprData_undefined);
 467   return (data->qt);
 468 }
 469
 470 static /*@exposed@*/ qtype exprData_getOffsetType (exprData data) /*@*/
 471 {
 472   llassert (data != exprData_undefined);
 473   return (data->offset->q);
 474 }
 475
 476 static /*@exposed@*/ cstringList exprData_getOffsetName (exprData data) /*@*/
 477 {
 478   llassert (data != exprData_undefined);
 479   return (data->offset->field);
 480 }
 481
 482 static /*@exposed@*/ exprNode exprData_getSingle (exprData data)
 483 {
 484   exprNode ret;
 485   llassert (data != exprData_undefined);
 486
 487   ret = data->single;
 488   return (ret);
 489 }
 490
 491
 492 static /*@only@*/ exprData
 493   exprData_makeOp (/*@keep@*/ exprNode a, /*@keep@*/ exprNode b, /*@keep@*/ lltok op)
 494 {
 495   exprData ed = (exprData) dmalloc (sizeof (*ed));
 496
 497   ed->op = (exprOp) dmalloc (sizeof (*ed->op));
 498   ed->op->a = a;
 499   ed->op->b = b;
 500   ed->op->op = op;
 501
 502   return ed;
 503 }
 504
 505 static /*@only@*/ exprData exprData_makeUop (/*@keep@*/ exprNode a, /*@keep@*/ lltok op)
 506 {
 507   exprData ed = (exprData) dmalloc (sizeof (*ed));
 508
 509   ed->uop = (exprUop) dmalloc (sizeof (*ed->uop));
 510   ed->uop->a = a;
 511   ed->uop->op = op;
 512
 513   return ed;
 514 }
 515
 516 static /*@only@*/ exprData exprData_makeSingle (/*@only@*/ exprNode a)
 517 {
 518   exprData ed = (exprData) dmalloc (sizeof (*ed));
 519
 520   ed->single = a;
 521   return ed;
 522 }
 523
 524 static /*@only@*/ exprData exprData_makeTok (/*@only@*/ lltok op)
 525 {
 526   exprData ed = (exprData) dmalloc (sizeof (*ed));
 527
 528   ed->tok = (lltok *) dmalloc (sizeof (*(ed->tok)));
 529   *(ed->tok) = op;
 530   return ed;
 531 }
 532
 533 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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 static /*@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
 657 /*@=fcnuse*/
 658
 659 /*@=shadow*/