Repair/RepairInterpreter/element.cc

   1 // provides an object wrapper around elementary types
   2
   3 #include <stdlib.h>
   4 #include <stdio.h>
   5 #include <assert.h>
   6 #include "element.h"
   7
   8
   9 Element::Element() {
  10   typevalue=ELEMENT_OBJECT;
  11   token=NULL;
  12   object=NULL;
  13   integervalue=0;
  14   bytevalue=0;
  15   bitvalue=false;
  16   shortvalue=0;
  17   itemtype=NULL;
  18 }
  19
  20 char * Element::gettoken() {
  21   assert(typevalue==ELEMENT_TOKEN);
  22   return token;
  23 }
  24
  25 bool Element::isnumber() {
  26   if ((type()==ELEMENT_INT)||
  27       (type()==ELEMENT_BYTE)||
  28       (type()==ELEMENT_SHORT))
  29     return true;
  30   else
  31     return false;
  32 }
  33
  34 Element::Element(void * objptr, structure * str) {
  35   object=objptr;
  36   typevalue=ELEMENT_OBJECT;
  37   itemtype=str;
  38   token=NULL;
  39   integervalue=0;
  40   bytevalue=0;
  41   bitvalue=false;
  42   shortvalue=0;
  43 }
  44
  45 Element::Element(int value) {
  46   typevalue=ELEMENT_INT;
  47   integervalue=value;
  48   object=NULL;
  49   itemtype=NULL;
  50   bytevalue=0;
  51   bitvalue=false;
  52   token=NULL;
  53   shortvalue=0;
  54 }
  55
  56 Element::Element(short value) {
  57   typevalue=ELEMENT_SHORT;
  58   shortvalue=value;
  59   integervalue=0;
  60   object=NULL;
  61   itemtype=NULL;
  62   bytevalue=0;
  63   bitvalue=false;
  64   token=NULL;
  65 }
  66
  67 Element::Element(bool b) {
  68   typevalue=ELEMENT_BIT;
  69   bitvalue=b;
  70   integervalue=0;
  71   object=NULL;
  72   itemtype=NULL;
  73   bytevalue=0;
  74   token=NULL;
  75   shortvalue=0;
  76 }
  77
  78 Element::Element(char byte) {
  79   typevalue=ELEMENT_BYTE;
  80   bytevalue=byte;
  81   integervalue=0;
  82   object=NULL;
  83   itemtype=NULL;
  84   token=NULL;
  85   bitvalue=false;
  86   shortvalue=0;
  87 }
  88
  89 Element::Element(char * token) {/*Value destroyed by this destructor*/
  90   this->token=token;
  91   typevalue=ELEMENT_TOKEN;
  92   integervalue=0;
  93   bytevalue=0;
  94   bitvalue=false;
  95   object=NULL;
  96   itemtype=NULL;
  97   shortvalue=0;
  98 }
  99
 100 Element::Element(Element * o) {
 101   this->integervalue=o->integervalue;
 102   this->bytevalue=o->bytevalue;
 103   this->itemtype=o->itemtype;
 104   this->token=copystr(o->token);
 105   this->object=o->object;
 106   this->typevalue=o->typevalue;
 107   this->bitvalue=o->bitvalue;
 108   this->shortvalue=o->shortvalue;
 109 }
 110
 111 void Element::print() {
 112   switch(typevalue) {
 113   case ELEMENT_INT:
 114 #ifndef TOOL
 115     printf("Int(%d)",integervalue);
 116 #else
 117     printf("%d", integervalue);
 118 #endif
 119     break;
 120
 121   case ELEMENT_SHORT:
 122 #ifndef TOOL
 123     printf("Short(%d)",shortvalue);
 124 #else
 125     printf("%d", shortvalue);
 126 #endif
 127     break;
 128
 129   case ELEMENT_BIT:
 130     if (bitvalue)
 131 #ifndef TOOL
 132       printf("Bit(true)");
 133 #else
 134     printf("true");
 135 #endif
 136     else
 137 #ifndef TOOL
 138       printf("Bit(false)");
 139 #else
 140     printf("false");
 141 #endif
 142     break;
 143
 144   case ELEMENT_BYTE:
 145 #ifndef TOOL
 146     printf("Int(%c)",bytevalue);
 147 #else
 148     printf("%c",bytevalue);
 149 #endif
 150     break;
 151
 152   case ELEMENT_TOKEN:
 153 #ifndef TOOL
 154     printf("Token(%s)",token);
 155 #else
 156     printf("%s",token);
 157 #endif
 158     break;
 159
 160   case ELEMENT_OBJECT:
 161     printf("Object(%p)",object);
 162     break;
 163   }
 164 }
 165
 166 unsigned int Element::hashCode() {
 167   switch(typevalue) {
 168   case ELEMENT_INT:
 169     return integervalue;
 170   case ELEMENT_SHORT:
 171     return shortvalue;
 172   case ELEMENT_BIT:
 173     if (bitvalue)
 174       return 1;
 175     else
 176       return 0;
 177   case ELEMENT_BYTE:
 178     return bytevalue;
 179   case ELEMENT_TOKEN:
 180     return hashstring(token);
 181   case ELEMENT_OBJECT:
 182     return (int)object;
 183   }
 184 }
 185
 186 bool Element::equals(ElementWrapper *other) {
 187   if (other->type()!=typevalue)
 188     return false;
 189   switch(typevalue) {
 190   case ELEMENT_INT:
 191     return (this->integervalue==((Element *)other)->integervalue);
 192   case ELEMENT_SHORT:
 193     return (this->shortvalue==((Element *)other)->shortvalue);
 194   case ELEMENT_BIT:
 195     return (this->bitvalue==((Element *)other)->bitvalue);
 196   case ELEMENT_BYTE:
 197     return (this->bytevalue==((Element *)other)->bytevalue);
 198   case ELEMENT_TOKEN:
 199     return (equivalentstrings(token,((Element *)other)->token)==1);
 200   case ELEMENT_OBJECT:
 201     return object==((Element *)other)->object;
 202   }
 203 }
 204
 205 int Element::intvalue() {
 206   switch(typevalue) {
 207   case ELEMENT_INT:
 208     return integervalue;
 209   case ELEMENT_SHORT:
 210     return shortvalue;
 211   case ELEMENT_BYTE:
 212     return bytevalue;
 213   default:
 214     printf("Illegal int conversion on Element\n");
 215     exit(-1);
 216   }
 217 }
 218
 219 short Element::getshortvalue() {
 220   assert(typevalue==ELEMENT_SHORT);
 221   return shortvalue;
 222 }
 223
 224 char Element::getbytevalue() {
 225   assert(typevalue==ELEMENT_BYTE);
 226   return bytevalue;
 227 }
 228
 229 bool Element::getboolvalue() {
 230   assert(typevalue==ELEMENT_BIT);
 231   return bitvalue;
 232 }
 233
 234 void * Element::getobject() {
 235   assert(typevalue==ELEMENT_OBJECT);
 236   return object;
 237 }
 238
 239 int Element::type() {
 240   return typevalue;
 241 }
 242
 243 structure * Element::getstructure() {
 244   return itemtype;
 245 }
 246
 247 Element::~Element() {
 248   if(typevalue==ELEMENT_TOKEN)
 249     delete[] token;
 250 }
 251
 252 unsigned int hashelement(ElementWrapper *e) {
 253   return e->hashCode();
 254 }
 255
 256 int elementequals(ElementWrapper *e1, ElementWrapper *e2) {
 257   return e1->equals(e2);
 258 }