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