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