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
 138 constraintExprData_termSetTerm (/*@returned@*/ constraintExprData data,
 139                                 /*@only@*/ constraintTerm term)
 140 {
 141   llassert (constraintExprData_isDefined (data));
 142
 143   if (constraintTerm_isDefined (data->term))
 144     {
 145       constraintTerm_free (data->term);
 146     }
 147
 148   data->term = term;
 149   return data;
 150 }
 151
 152
 153
 154 /*@observer@*/ constraintTerm
 155 constraintExprData_termGetTerm (/*@observer@*/ constraintExprData data)
 156 {
 157   llassert (constraintExprData_isDefined (data));
 158   /*@i22*/
 159   return data->term;
 160 }
 161
 162
 163 constraintExprUnaryOpKind
 164 constraintExprData_unaryExprGetOp (/*@observer@*/ constraintExprData data)
 165 {
 166   llassert (constraintExprData_isDefined (data));
 167   return (data->unaryOp.unaryOp);
 168 }
 169
 170
 171 constraintExpr
 172 constraintExprData_unaryExprGetExpr (/*@observer@*/ constraintExprData data)
 173 {
 174   llassert (constraintExprData_isDefined (data));
 175   return (data->unaryOp.expr);
 176 }
 177
 178 constraintExprData
 179 constraintExprData_unaryExprSetOp (/*@returned@*/ constraintExprData data,
 180                                    constraintExprUnaryOpKind op)
 181 {
 182   llassert (constraintExprData_isDefined (data));
 183   data->unaryOp.unaryOp = op;
 184   return data;
 185 }
 186
 187 constraintExprData
 188 constraintExprData_unaryExprSetExpr (constraintExprData data,
 189                                      /*@only@*/ constraintExpr expr)
 190 {
 191   llassert (constraintExprData_isDefined (data));
 192
 193   if (constraintExpr_isDefined (data->unaryOp.expr))
 194     {
 195       constraintExpr_free (data->unaryOp.expr);
 196     }
 197
 198   data->unaryOp.expr = expr;
 199   return data;
 200 }
 201
 202 /*
 203 ** binaryExpr stuff
 204 */
 205
 206 constraintExprBinaryOpKind constraintExprData_binaryExprGetOp (constraintExprData data)
 207 {
 208   llassert (constraintExprData_isDefined (data));
 209   return (data->binaryOp.binaryOp);
 210 }
 211
 212 constraintExpr constraintExprData_binaryExprGetExpr1 (constraintExprData data)
 213 {
 214   llassert (constraintExprData_isDefined (data));
 215   return (data->binaryOp.expr1);
 216 }
 217
 218 constraintExpr constraintExprData_binaryExprGetExpr2 (constraintExprData data)
 219 {
 220   llassert (constraintExprData_isDefined(data));
 221   /*@i22*/
 222   return (data->binaryOp.expr2);
 223 }
 224
 225 constraintExprData
 226 constraintExprData_binaryExprSetExpr1 (/*@returned@*/ constraintExprData data,
 227                                        /*@only@*/ constraintExpr expr)
 228 {
 229   llassert (constraintExprData_isDefined (data));
 230
 231   if (constraintExpr_isDefined (data->binaryOp.expr1))
 232     constraintExpr_free(data->binaryOp.expr1);
 233
 234   data->binaryOp.expr1 = expr;
 235   return data;
 236 }
 237
 238 constraintExprData
 239 constraintExprData_binaryExprSetExpr2 (constraintExprData data, constraintExpr expr)
 240 {
 241   llassert (constraintExprData_isDefined (data));
 242
 243   if (constraintExpr_isDefined (data->binaryOp.expr2))
 244     constraintExpr_free (data->binaryOp.expr2);
 245
 246   data->binaryOp.expr2 = expr;
 247   return data;
 248 }
 249
 250 constraintExprData
 251 constraintExprData_binaryExprSetOp (constraintExprData data,
 252                                     constraintExprBinaryOpKind op)
 253 {
 254   llassert (constraintExprData_isDefined (data));
 255   data->binaryOp.binaryOp = op;
 256   return data;
 257 }
 258