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
  32 static /*@out@*/ constraintExprData constraintExprData_alloc (void)
  33 {
  34   constraintExprData ret;
  35
  36   ret = dmalloc (sizeof (*ret) );
  37
  38   return ret;
  39 }
  40
  41 static /*@out@*/ constraintExprData constraintExprData_allocBinaryOp (void)
  42 {
  43   constraintExprData ret;
  44
  45   ret = constraintExprData_alloc();
  46
  47   ret->binaryOp.expr1 = constraintExpr_undefined;
  48   ret->binaryOp.expr2 = constraintExpr_undefined;
  49
  50   return ret;
  51 }
  52
  53 static /*@out@*/ constraintExprData constraintExprData_allocUnaryOp (void)
  54 {
  55   constraintExprData ret;
  56
  57   ret = constraintExprData_alloc();
  58
  59   ret->unaryOp.expr = constraintExpr_undefined;
  60
  61   return ret;
  62 }
  63
  64 static /*@out@*/ constraintExprData constraintExprData_allocTerm (void)
  65 {
  66   constraintExprData ret;
  67
  68   ret = constraintExprData_alloc();
  69
  70   ret->term = NULL;
  71   return ret;
  72 }
  73
  74
  75 void constraintExprData_freeBinaryExpr (/*@only@*/constraintExprData data)
  76 {
  77   constraintExpr_free (data->binaryOp.expr1);
  78   constraintExpr_free (data->binaryOp.expr2);
  79   free(data);
  80 }
  81
  82 constraintExprData constraintExprData_copyBinaryExpr(/*@observer@*/ constraintExprData data)
  83 {
  84   constraintExprData ret;
  85   llassert(constraintExprData_isDefined(data));
  86
  87   ret = constraintExprData_allocBinaryOp();
  88
  89   ret->binaryOp.binaryOp = data->binaryOp.binaryOp;
  90   ret->binaryOp.expr1 = constraintExpr_copy (data->binaryOp.expr1);
  91   ret->binaryOp.expr2 = constraintExpr_copy (data->binaryOp.expr2);
  92   return ret;
  93 }
  94
  95 void constraintExprData_freeUnaryExpr (/*@only@*/constraintExprData data)
  96 {
  97   constraintExpr_free (data->unaryOp.expr);
  98   free(data);
  99 }
 100
 101 constraintExprData constraintExprData_copyUnaryExpr(/*@observer@*/ constraintExprData data)
 102 {
 103  constraintExprData ret;
 104   llassert(constraintExprData_isDefined(data));
 105
 106   ret = constraintExprData_allocUnaryOp();
 107
 108   ret->unaryOp.unaryOp = data->unaryOp.unaryOp;
 109   ret->unaryOp.expr = constraintExpr_copy (data->unaryOp.expr);
 110
 111   return ret;
 112 }
 113
 114 void constraintExprData_freeTerm (/*@only@*/constraintExprData data)
 115 {
 116   constraintTerm_free (data->term);
 117   free(data);
 118 }
 119
 120
 121 constraintExprData constraintExprData_copyTerm (/*@observer@*/ constraintExprData data)
 122 {
 123  constraintExprData ret;
 124   llassert(constraintExprData_isDefined(data));
 125
 126   ret = constraintExprData_allocTerm();
 127
 128   ret->term = constraintTerm_copy (data->term);
 129   return ret;
 130 }
 131
 132 constraintExprData
 133 constraintExprData_termSetTerm (/*@returned@*/ constraintExprData data,
 134                                 /*@only@*/ constraintTerm term)
 135 {
 136   llassert (constraintExprData_isDefined (data));
 137
 138   if (constraintTerm_isDefined (data->term))
 139     {
 140       constraintTerm_free (data->term);
 141     }
 142
 143   data->term = term;
 144   return data;
 145 }
 146
 147 /*@exposed@*/ constraintTerm
 148 constraintExprData_termGetTerm (/*@observer@*/ constraintExprData data)
 149 {
 150   llassert (constraintExprData_isDefined (data));
 151   return data->term;
 152 }
 153
 154
 155 constraintExprUnaryOpKind
 156 constraintExprData_unaryExprGetOp (/*@observer@*/ constraintExprData data)
 157 {
 158   llassert (constraintExprData_isDefined (data));
 159   return (data->unaryOp.unaryOp);
 160 }
 161
 162
 163 constraintExpr
 164 constraintExprData_unaryExprGetExpr (/*@observer@*/ constraintExprData data)
 165 {
 166   llassert (constraintExprData_isDefined (data));
 167   return (data->unaryOp.expr);
 168 }
 169
 170 constraintExprData
 171 constraintExprData_unaryExprSetOp (/*@returned@*/ constraintExprData data,
 172                                    constraintExprUnaryOpKind op)
 173 {
 174   llassert (constraintExprData_isDefined (data));
 175   data->unaryOp.unaryOp = op;
 176   return data;
 177 }
 178
 179 constraintExprData
 180 constraintExprData_unaryExprSetExpr (constraintExprData data,
 181                                      /*@only@*/ constraintExpr expr)
 182 {
 183   llassert (constraintExprData_isDefined (data));
 184
 185   if (constraintExpr_isDefined (data->unaryOp.expr))
 186     {
 187       constraintExpr_free (data->unaryOp.expr);
 188     }
 189
 190   data->unaryOp.expr = expr;
 191   return data;
 192 }
 193
 194 /*
 195 ** binaryExpr stuff
 196 */
 197
 198 constraintExprBinaryOpKind constraintExprData_binaryExprGetOp (constraintExprData data)
 199 {
 200   llassert (constraintExprData_isDefined (data));
 201   return (data->binaryOp.binaryOp);
 202 }
 203
 204 constraintExpr constraintExprData_binaryExprGetExpr1 (constraintExprData data)
 205 {
 206   llassert (constraintExprData_isDefined (data));
 207   return (data->binaryOp.expr1);
 208 }
 209
 210 constraintExpr constraintExprData_binaryExprGetExpr2 (constraintExprData data)
 211 {
 212   llassert (constraintExprData_isDefined(data));
 213   return (data->binaryOp.expr2);
 214 }
 215
 216 constraintExprData
 217 constraintExprData_binaryExprSetExpr1 (/*@returned@*/ constraintExprData data,
 218                                        /*@only@*/ constraintExpr expr)
 219 {
 220   llassert (constraintExprData_isDefined (data));
 221
 222   if (constraintExpr_isDefined (data->binaryOp.expr1))
 223     constraintExpr_free(data->binaryOp.expr1);
 224
 225   data->binaryOp.expr1 = expr;
 226   return data;
 227 }
 228
 229 constraintExprData
 230 constraintExprData_binaryExprSetExpr2 (constraintExprData data, constraintExpr expr)
 231 {
 232   llassert (constraintExprData_isDefined (data));
 233
 234   if (constraintExpr_isDefined (data->binaryOp.expr2))
 235     constraintExpr_free (data->binaryOp.expr2);
 236
 237   data->binaryOp.expr2 = expr;
 238   return data;
 239 }
 240
 241 constraintExprData
 242 constraintExprData_binaryExprSetOp (constraintExprData data,
 243                                     constraintExprBinaryOpKind op)
 244 {
 245   llassert (constraintExprData_isDefined (data));
 246   data->binaryOp.binaryOp = op;
 247   return data;
 248 }
 249