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