src/exprData.c

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