src/constraintExprData.c

   1 /*
   2 ** Splint - annotation-assisted static program checker
   3 ** Copyright (C) 1994-2003 University of Virginia,
   4 **         Massachusetts Institute of Technology
   5 **
   6 ** This program is free software; you can redistribute it and/or modify it
   7 ** under the terms of the GNU General Public License as published by the
   8 ** Free Software Foundation; either version 2 of the License, or (at your
   9 ** option) any later version.
  10 **
  11 ** This program is distributed in the hope that it will be useful, but
  12 ** WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 ** General Public License for more details.
  15 **
  16 ** The GNU General Public License is available from http://www.gnu.org/ or
  17 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  18 ** MA 02111-1307, USA.
  19 **
  20 ** For information on splint: info@splint.org
  21 ** To report a bug: splint-bug@splint.org
  22 ** For more information: http://www.splint.org
  23 */
  24
  25 /*
  26 ** constraintExprData.c
  27 */
  28
  29 # include "splintMacros.nf"
  30 # include "basic.h"
  31 # include "cgrammar.h"
  32 # include "cgrammar_tokens.h"
  33
  34 # include "exprChecks.h"
  35 # include "exprNodeSList.h"
  36
  37 static /*@out@*/ constraintExprData constraintExprData_alloc (void)
  38 {
  39   constraintExprData ret;
  40
  41   ret = dmalloc (sizeof (*ret) );
  42
  43   return ret;
  44 }
  45
  46 static /*@out@*/ constraintExprData constraintExprData_allocBinaryOp (void)
  47 {
  48   constraintExprData ret;
  49
  50   ret = constraintExprData_alloc();
  51
  52   ret->binaryOp.expr1 = constraintExpr_undefined;
  53   ret->binaryOp.expr2 = constraintExpr_undefined;
  54
  55   return ret;
  56 }
  57
  58 static /*@out@*/ constraintExprData constraintExprData_allocUnaryOp (void)
  59 {
  60   constraintExprData ret;
  61
  62   ret = constraintExprData_alloc();
  63
  64   ret->unaryOp.expr = constraintExpr_undefined;
  65
  66   return ret;
  67 }
  68
  69 static /*@out@*/ constraintExprData constraintExprData_allocTerm (void)
  70 {
  71   constraintExprData ret;
  72
  73   ret = constraintExprData_alloc();
  74
  75   ret->term = NULL;
  76   return ret;
  77 }
  78
  79
  80 void constraintExprData_freeBinaryExpr (/*@only@*/constraintExprData data)
  81 {
  82   constraintExpr_free (data->binaryOp.expr1);
  83   constraintExpr_free (data->binaryOp.expr2);
  84   free(data);
  85 }
  86
  87 constraintExprData constraintExprData_copyBinaryExpr(/*@observer@*/ constraintExprData data)
  88 {
  89   constraintExprData ret;
  90   llassert(constraintExprData_isDefined(data));
  91
  92   ret = constraintExprData_allocBinaryOp();
  93
  94   ret->binaryOp.binaryOp = data->binaryOp.binaryOp;
  95   ret->binaryOp.expr1 = constraintExpr_copy (data->binaryOp.expr1);
  96   ret->binaryOp.expr2 = constraintExpr_copy (data->binaryOp.expr2);
  97   return ret;
  98 }
  99
 100 void constraintExprData_freeUnaryExpr (/*@only@*/constraintExprData data)
 101 {
 102   constraintExpr_free (data->unaryOp.expr);
 103   free(data);
 104 }
 105
 106 constraintExprData constraintExprData_copyUnaryExpr(/*@observer@*/ constraintExprData data)
 107 {
 108  constraintExprData ret;
 109   llassert(constraintExprData_isDefined(data));
 110
 111   ret = constraintExprData_allocUnaryOp();
 112
 113   ret->unaryOp.unaryOp = data->unaryOp.unaryOp;
 114   ret->unaryOp.expr = constraintExpr_copy (data->unaryOp.expr);
 115
 116   return ret;
 117 }
 118
 119 void constraintExprData_freeTerm (/*@only@*/constraintExprData data)
 120 {
 121   constraintTerm_free (data->term);
 122   free(data);
 123 }
 124
 125
 126 constraintExprData constraintExprData_copyTerm (/*@observer@*/ constraintExprData data)
 127 {
 128  constraintExprData ret;
 129   llassert(constraintExprData_isDefined(data));
 130
 131   ret = constraintExprData_allocTerm();
 132
 133   ret->term = constraintTerm_copy (data->term);
 134   return ret;
 135 }
 136
 137 constraintExprData constraintExprData_termSetTerm (/*@returned@*/  constraintExprData data,  /*@only@*/constraintTerm term)
 138 {
 139   llassert (constraintExprData_isDefined(data));
 140
 141   if (constraintTerm_isDefined(data->term) )
 142     constraintTerm_free(data->term);
 143
 144   data->term = term;
 145   return data;
 146 }
 147
 148
 149
 150 /*@observer@*/ constraintTerm constraintExprData_termGetTerm (/*@observer@*/ constraintExprData data)
 151 {
 152   llassert (constraintExprData_isDefined(data));
 153   /*@i22*/return data->term;
 154 }
 155
 156
 157 constraintExprUnaryOpKind constraintExprData_unaryExprGetOp (/*@observer@*/ constraintExprData data)
 158 {
 159   llassert (constraintExprData_isDefined(data));
 160   return (data->unaryOp.unaryOp);
 161 }
 162
 163
 164 constraintExpr  constraintExprData_unaryExprGetExpr (/*@observer@*/ constraintExprData data)
 165 {
 166   llassert (constraintExprData_isDefined (data));
 167   return (data->unaryOp.expr);
 168 }
 169
 170
 171
 172 constraintExprData constraintExprData_unaryExprSetOp ( /*@returned@*/ constraintExprData data, constraintExprUnaryOpKind op)
 173 {
 174   llassert (constraintExprData_isDefined (data));
 175
 176   data->unaryOp.unaryOp = op;
 177   return data;
 178 }
 179
 180 constraintExprData  constraintExprData_unaryExprSetExpr (constraintExprData data, /*@only@*/ constraintExpr expr)
 181 {
 182   llassert (constraintExprData_isDefined(data));
 183
 184   if (constraintExpr_isDefined(data->unaryOp.expr) )
 185     constraintExpr_free(data->unaryOp.expr);
 186
 187   data->unaryOp.expr = expr;
 188   return data;
 189 }
 190
 191 /*
 192 ** binaryExpr stuff
 193 */
 194
 195 constraintExprBinaryOpKind  constraintExprData_binaryExprGetOp (constraintExprData data)
 196 {
 197   llassert (constraintExprData_isDefined(data));
 198
 199   return (data->binaryOp.binaryOp);
 200 }
 201
 202
 203 constraintExpr  constraintExprData_binaryExprGetExpr1 (constraintExprData data)
 204 {
 205   llassert (constraintExprData_isDefined(data));
 206
 207
 208   return (data->binaryOp.expr1);
 209 }
 210
 211
 212 constraintExpr  constraintExprData_binaryExprGetExpr2 (constraintExprData data)
 213 {
 214   llassert (constraintExprData_isDefined(data));
 215   /*@i22*/ return (data->binaryOp.expr2);
 216 }
 217
 218
 219 constraintExprData  constraintExprData_binaryExprSetExpr1 (  /*@returned@*/ constraintExprData data, /*@only@*/ constraintExpr expr)
 220 {
 221   llassert (constraintExprData_isDefined(data));
 222
 223   if (constraintExpr_isDefined(data->binaryOp.expr1) )
 224     constraintExpr_free(data->binaryOp.expr1);
 225
 226   data->binaryOp.expr1 = expr;
 227   return data;
 228 }
 229
 230 constraintExprData  constraintExprData_binaryExprSetExpr2 (constraintExprData data, constraintExpr expr)
 231 {
 232   llassert (constraintExprData_isDefined(data));
 233   if (constraintExpr_isDefined(data->binaryOp.expr2) )
 234     constraintExpr_free(data->binaryOp.expr2);
 235
 236   data->binaryOp.expr2 = expr;
 237   return data;
 238 }
 239
 240
 241 constraintExprData  constraintExprData_binaryExprSetOp (constraintExprData data, constraintExprBinaryOpKind op)
 242 {
 243   llassert (constraintExprData_isDefined(data));
 244   data->binaryOp.binaryOp = op;
 245   return data;
 246 }
 247