bundles/org.simantics.databoard/cpp/DataBoardTest/DataBoard/DataValueRepository.cpp

   1 #include <string>\r
   2 \r
   3 #include "DataValueRepository.h"\r
   4 \r
   5 #include "DataBoardRepository.h"\r
   6 #include "Value.h"\r
   7 #include "RecordValue.h"\r
   8 #include "StringValue.h"\r
   9 #include "IntegerValue.h"\r
  10 #include "DoubleValue.h"\r
  11 #include "BooleanValue.h"\r
  12 #include "FloatValue.h"\r
  13 #include "LongValue.h"\r
  14 #include "MapValue.h"\r
  15 #include "ArrayValue.h"\r
  16 #include "OptionalValue.h"\r
  17 #include "UnionValue.h"\r
  18 #include "VariantValue.h"\r
  19 \r
  20 #include "RecordType.h"\r
  21 #include "Component.h"\r
  22 #include "BooleanType.h"\r
  23 #include "StringType.h"\r
  24 #include "IntegerType.h"\r
  25 #include "DoubleType.h"\r
  26 #include "FloatType.h"\r
  27 #include "LongType.h"\r
  28 #include "MapType.h"\r
  29 #include "ArrayType.h"\r
  30 #include "OptionalType.h"\r
  31 #include "UnionType.h"\r
  32 #include "VariantType.h"\r
  33 \r
  34 #include "Constants.h"\r
  35 \r
  36 #include <string>\r
  37 #include <iostream>\r
  38 #include <sstream>\r
  39 \r
  40 namespace Databoard {\r
  41         namespace Value {\r
  42 \r
  43                 std::string strDataValueDefinition::writeOut() const\r
  44                 {\r
  45                         std::string r;\r
  46 \r
  47                         r += name + " : " + type + " = ";\r
  48 \r
  49                         if(value != NULL)\r
  50                         {\r
  51                                 r += value->writeOut();\r
  52                         }\r
  53 \r
  54                         return r;\r
  55                 }\r
  56 \r
  57                 DataValueRepository::DataValueRepository()\r
  58                 {\r
  59                 }\r
  60 \r
  61                 DataValueRepository::~DataValueRepository()\r
  62                 {\r
  63                         for(int i=0;i<(int)values.size();++i)\r
  64                         {\r
  65                                 delete values.at(i).value;\r
  66                         }\r
  67 \r
  68                         values.size();\r
  69                 }\r
  70 \r
  71                 void DataValueRepository::addDataValue(std::string name, std::string type, Value* dataValue)\r
  72                 {\r
  73                         strDataValueDefinition value_;\r
  74 \r
  75                         value_.name = name;\r
  76                         value_.type = type;\r
  77                         value_.value = dataValue;\r
  78 \r
  79                         values.push_back(value_);\r
  80                 }\r
  81 \r
  82                 const Databoard::Type::strTypeDefinition* DataValueRepository::parseTypeReference(pANTLR3_BASE_TREE tree)\r
  83                 {\r
  84                         switch(tree->getType(tree)) {\r
  85                                 case TYPE_REFERENCE:\r
  86 \r
  87                                         if(tree->getChildCount(tree) == 1)\r
  88                                         {\r
  89                                                 pANTLR3_BASE_TREE referenceName = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);\r
  90 \r
  91                                                 std::string id((char*)referenceName->getText(referenceName)->chars);\r
  92 \r
  93                                                 const Databoard::Type::strTypeDefinition* dataBoard = dataBoardRepository->get(id);\r
  94 \r
  95                                                 return dataBoard;\r
  96                                         }\r
  97 \r
  98                                         break;\r
  99                                 default:\r
 100                                         break;\r
 101                         }\r
 102 \r
 103                         return NULL;\r
 104                 }\r
 105 \r
 106                 Value* DataValueRepository::parseValues(pANTLR3_BASE_TREE tree, Databoard::Type::DataType* dataBoard, int indent)\r
 107                 {\r
 108                         if(dynamic_cast<Databoard::Type::OptionalType*>(dataBoard) != NULL)\r
 109                         {\r
 110                                 Databoard::Type::OptionalType* optionalType = (Databoard::Type::OptionalType*)dataBoard;\r
 111 \r
 112                                 Value* value = parseValues(tree, optionalType->getComponentType(), indent + 1);\r
 113 \r
 114                                 OptionalValue* optionalValue = new OptionalValue(optionalType);\r
 115 \r
 116                                 optionalValue->setValue(value);\r
 117 \r
 118                                 return optionalValue;\r
 119                         }\r
 120                         else if(dynamic_cast<Databoard::Type::StringType*>(dataBoard) != NULL)\r
 121                         {\r
 122                                 Databoard::Type::StringType* stringType = (Databoard::Type::StringType*)dataBoard;\r
 123 \r
 124                                 StringValue* stringValue = new StringValue(dataBoard);\r
 125 \r
 126                                 std::string value((char*)tree->getText(tree)->chars);\r
 127 \r
 128                                 value = removeQuotes(value);\r
 129 \r
 130                                 stringValue->setValue(value);\r
 131 \r
 132                                 return stringValue;\r
 133                         }\r
 134                         else if(dynamic_cast<Databoard::Type::IntegerType*>(dataBoard) != NULL)\r
 135                         {\r
 136                                 Databoard::Type::IntegerType* integerType = (Databoard::Type::IntegerType*)dataBoard;\r
 137 \r
 138                                 IntegerValue* integerValue = new IntegerValue(dataBoard);\r
 139 \r
 140                                 std::istringstream iss((char*)tree->getText(tree)->chars);\r
 141 \r
 142                                 int value;\r
 143 \r
 144                                 iss >> value;\r
 145 \r
 146                                 integerValue->setValue(value);\r
 147 \r
 148                                 return integerValue;\r
 149                         }\r
 150                         else if(dynamic_cast<Databoard::Type::LongType*>(dataBoard) != NULL)\r
 151                         {\r
 152                                 Databoard::Type::LongType* longType = (Databoard::Type::LongType*)dataBoard;\r
 153 \r
 154                                 LongValue* longValue = new LongValue(dataBoard);\r
 155 \r
 156                                 std::istringstream iss((char*)tree->getText(tree)->chars);\r
 157 \r
 158                                 long value;\r
 159 \r
 160                                 iss >> value;\r
 161 \r
 162                                 longValue->setValue(value);\r
 163 \r
 164                                 return longValue;\r
 165                         }\r
 166                         else if(dynamic_cast<Databoard::Type::FloatType*>(dataBoard) != NULL)\r
 167                         {\r
 168                                 Databoard::Type::FloatType* floatType = (Databoard::Type::FloatType*)dataBoard;\r
 169 \r
 170                                 FloatValue* floatValue = new FloatValue(dataBoard);\r
 171 \r
 172                                 std::istringstream iss((char*)tree->getText(tree)->chars);\r
 173 \r
 174                                 float value;\r
 175 \r
 176                                 iss >> value;\r
 177 \r
 178                                 floatValue->setValue(value);\r
 179 \r
 180                                 return floatValue;\r
 181                         }\r
 182                         else if(dynamic_cast<Databoard::Type::DoubleType*>(dataBoard) != NULL)\r
 183                         {\r
 184                                 Databoard::Type::DoubleType* doubleType = (Databoard::Type::DoubleType*)dataBoard;\r
 185 \r
 186                                 DoubleValue* doubleValue = new DoubleValue(dataBoard);\r
 187 \r
 188                                 std::istringstream iss((char*)tree->getText(tree)->chars);\r
 189 \r
 190                                 double value;\r
 191 \r
 192                                 iss >> value;\r
 193 \r
 194                                 doubleValue->setValue(value);\r
 195 \r
 196                                 return doubleValue;\r
 197                         }\r
 198                         else if(dynamic_cast<Databoard::Type::RecordType*>(dataBoard) != NULL)\r
 199                         {\r
 200                                 if(tree->getType(tree) == TUPLE)\r
 201                                 {\r
 202                                         Databoard::Type::RecordType* recordType = (Databoard::Type::RecordType*)dataBoard;\r
 203 \r
 204                                         RecordValue* recordValue = new RecordValue(recordType);\r
 205 \r
 206                                         int i2 = (int)tree->getChildCount(tree);\r
 207                                         int i3 = recordType->count();\r
 208 \r
 209                                         if((int)tree->getChildCount(tree) == recordType->count())\r
 210                                         {\r
 211                                                 for(int i=0;i<(int)tree->getChildCount(tree);++i)\r
 212                                                 {\r
 213                                                         pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)tree->getChild(tree, i);\r
 214 \r
 215                                                         std::string strId((char*)value->getText(value)->chars);\r
 216 \r
 217                                                         Databoard::Type::Component* component = recordType->getComponent(i);\r
 218 \r
 219                                                         if(component != NULL)\r
 220                                                         {\r
 221                                                                 Databoard::Type::DataType* dataBoardType = component->getDataBoard();\r
 222 \r
 223                                                                 Value* childValue = parseValues(value, dataBoardType, indent + 1);\r
 224 \r
 225                                                                 recordValue->setField(i, childValue);\r
 226                                                         }\r
 227                                                 }\r
 228 \r
 229                                                 return recordValue;\r
 230                                         }\r
 231                                         else\r
 232                                         {\r
 233                                                 std::cout << "mismatch in tuple count: " << (int)tree->getChildCount(tree) << " != " << recordType->count() << std::endl;\r
 234                                                 return NULL;\r
 235                                         }\r
 236                                 }\r
 237                                 else if(tree->getType(tree) == RECORD)\r
 238                                 {\r
 239                                         Databoard::Type::RecordType* recordType = (Databoard::Type::RecordType*)dataBoard;\r
 240 \r
 241                                         RecordValue* recordValue = new RecordValue(recordType);\r
 242 \r
 243                                         for(int i=0;i<(int)tree->getChildCount(tree);++i)\r
 244                                         {\r
 245                                                 pANTLR3_BASE_TREE assignment = (pANTLR3_BASE_TREE)tree->getChild(tree, i);\r
 246 \r
 247                                                 if(assignment->getType(assignment) == ASSIGNMENT)\r
 248                                                 {\r
 249                                                         if(assignment->getChildCount(assignment) == 2)\r
 250                                                         {\r
 251                                                                 pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)assignment->getChild(assignment, 0);\r
 252                                                                 pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)assignment->getChild(assignment, 1);\r
 253 \r
 254                                                                 std::string strId((char*)id->getText(id)->chars);\r
 255 \r
 256                                                                 Databoard::Type::Component* component = recordType->getComponent(strId);\r
 257 \r
 258                                                                 if(component != NULL)\r
 259                                                                 {\r
 260                                                                         Databoard::Type::DataType* dataBoardType = component->getDataBoard();\r
 261 \r
 262                                                                         if(dataBoardType != NULL)\r
 263                                                                         {\r
 264                                                                                 Value* childValue = parseValues(value, dataBoardType, indent + 1);\r
 265 \r
 266                                                                                 int index = recordType->getComponentIndex(strId);\r
 267 \r
 268                                                                                 recordValue->setField(index, childValue);\r
 269                                                                         }\r
 270                                                                 }\r
 271                                                         }\r
 272                                                 }\r
 273                                         }\r
 274 \r
 275                                         return recordValue;\r
 276                                 }\r
 277                         }\r
 278                         else if(dynamic_cast<Databoard::Type::MapType*>(dataBoard) != NULL)\r
 279                         {\r
 280                                 Databoard::Type::MapType* mapType = (Databoard::Type::MapType*)dataBoard;\r
 281 \r
 282                                 MapValue* mapValue = new MapValue(mapType);\r
 283 \r
 284                                 int childCount = tree->getChildCount(tree);\r
 285 \r
 286                                 if(childCount > 0)\r
 287                                 {\r
 288                                         for(int i = 0; i < childCount; ++i)\r
 289                                         {\r
 290                                                 pANTLR3_BASE_TREE assignment = (pANTLR3_BASE_TREE)tree->getChild(tree, i);\r
 291 \r
 292                                                 if(assignment->getType(assignment) == ASSIGNMENT)\r
 293                                                 {\r
 294                                                         if(assignment->getChildCount(assignment) == 2)\r
 295                                                         {\r
 296                                                                 pANTLR3_BASE_TREE key = (pANTLR3_BASE_TREE)assignment->getChild(assignment, 0);\r
 297                                                                 pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)assignment->getChild(assignment, 1);\r
 298 \r
 299                                                                 std::string strKey((char*)key->getText(key)->chars);\r
 300                                                                 std::string strValue((char*)value->getText(value)->chars);\r
 301 \r
 302                                                                 strKey = removeQuotes(strKey);\r
 303                                                                 strValue = removeQuotes(strValue);\r
 304 \r
 305                                                                 Value* keyValue = parseValues(key, mapType->getKeyType(), indent + 1);\r
 306                                                                 Value* valueValue = parseValues(value, mapType->getValueType(), indent + 1);\r
 307 \r
 308                                                                 if(keyValue != NULL && valueValue != NULL)\r
 309                                                                 {\r
 310                                                                         mapValue->put(keyValue, valueValue);\r
 311                                                                 }\r
 312                                                         }\r
 313                                                 }\r
 314                                         }\r
 315                                 }\r
 316 \r
 317                                 return mapValue;\r
 318                         }\r
 319                         else if(dynamic_cast<Databoard::Type::ArrayType*>(dataBoard) != NULL)\r
 320                         {\r
 321                                 Databoard::Type::ArrayType* arrayType = (Databoard::Type::ArrayType*)dataBoard;\r
 322 \r
 323                                 ArrayValue* arrayValue = new ArrayValue(arrayType);\r
 324 \r
 325                                 int childCount = tree->getChildCount(tree);\r
 326 \r
 327                                 if(childCount > 0)\r
 328                                 {\r
 329                                         for(int i = 0; i < childCount; ++i)\r
 330                                         {\r
 331                                                 pANTLR3_BASE_TREE assignment = (pANTLR3_BASE_TREE)tree->getChild(tree, i);\r
 332 \r
 333                                                 Databoard::Type::DataType* dataType = arrayType->getComponentType();\r
 334 \r
 335                                                 Value* value = parseValues(assignment, dataType, indent + 1);\r
 336 \r
 337                                                 arrayValue->add(value);\r
 338 \r
 339 \r
 340                                                 //Value* keyValue = parseValues(key, dataType, indent + 1);\r
 341 \r
 342 \r
 343                                                 //      if(assignment->getType(assignment) == ASSIGNMENT)\r
 344                                                 //      {\r
 345                                                 //              if(assignment->getChildCount(assignment) == 2)\r
 346                                                 //              {\r
 347                                                 //                      pANTLR3_BASE_TREE key = (pANTLR3_BASE_TREE)assignment->getChild(assignment, 0);\r
 348                                                 //                      pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)assignment->getChild(assignment, 1);\r
 349 \r
 350                                                 //                      std::string strKey((char*)key->getText(key)->chars);\r
 351                                                 //                      std::string strValue((char*)value->getText(value)->chars);\r
 352 \r
 353                                                 //                      strKey = removeQuotes(strKey);\r
 354                                                 //                      strValue = removeQuotes(strValue);\r
 355 \r
 356                                                 //                      Value* keyValue = parseValues(key, mapType->getKeyType(), indent + 1);\r
 357                                                 //                      Value* valueValue = parseValues(value, mapType->getValueType(), indent + 1);\r
 358 \r
 359                                                 //                      if(keyValue != NULL && valueValue != NULL)\r
 360                                                 //                      {\r
 361                                                 //                              mapValue->put(keyValue, valueValue);\r
 362                                                 //                      }\r
 363                                                 //              }\r
 364                                                 //      }\r
 365                                         }\r
 366                                 }\r
 367 \r
 368                                 return arrayValue;\r
 369                         }\r
 370                         else if(dynamic_cast<Databoard::Type::BooleanType*>(dataBoard) != NULL)\r
 371                         {\r
 372                                 Databoard::Type::BooleanType* booleanType = (Databoard::Type::BooleanType*)dataBoard;\r
 373 \r
 374                                 BooleanValue* booleanValue = new BooleanValue(dataBoard);\r
 375 \r
 376                                 std::string value((char*)tree->getText(tree)->chars);\r
 377 \r
 378                                 if(value == STR_TRUE)\r
 379                                 {\r
 380                                         booleanValue->setValue(true);\r
 381                                 }\r
 382                                 else\r
 383                                 {\r
 384                                         booleanValue->setValue(false);\r
 385                                 }\r
 386 \r
 387                                 return booleanValue;\r
 388                         }\r
 389                         else if(dynamic_cast<Databoard::Type::UnionType*>(dataBoard) != NULL)\r
 390                         {\r
 391                                 if(tree->getChildCount(tree) == 2)\r
 392                                 {\r
 393                                         pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);\r
 394                                         pANTLR3_BASE_TREE type = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);\r
 395 \r
 396                                         Databoard::Type::UnionType* unionType = (Databoard::Type::UnionType*)dataBoard;\r
 397 \r
 398                                         UnionValue* unionValue = new UnionValue(dataBoard);\r
 399                                         \r
 400 \r
 401                                         std::string strId((char*)id->getText(id)->chars);\r
 402 \r
 403                                         int tag = unionType->getComponentIndex(strId);\r
 404 \r
 405                                         Databoard::Type::Component* component = unionType->getComponent(tag);\r
 406 \r
 407                                         if(component != NULL)\r
 408                                         {\r
 409                                                 Databoard::Type::DataType* dataType = component->getDataBoard();\r
 410 \r
 411                                                 if(dataType != NULL)\r
 412                                                 {\r
 413                                                         Databoard::Value::Value* value = parseValues(type, dataType, indent);\r
 414 \r
 415                                                         unionValue->setValue(tag, value);\r
 416                                                 }\r
 417                                         }\r
 418 \r
 419                                         return unionValue;\r
 420                                 }\r
 421                         }\r
 422                         else if(dynamic_cast<Databoard::Type::VariantType*>(dataBoard) != NULL)\r
 423                         {\r
 424                                 if(tree->getChildCount(tree) == 0)\r
 425                                 {\r
 426                                         std::string valueId((char*)tree->getText(tree)->chars);\r
 427 \r
 428                                         // check the string\r
 429                                         if(valueId.length() >= 2)\r
 430                                         {\r
 431                                                 if(valueId.at(0) == '"' && valueId.at(valueId.length()-1) == '"')\r
 432                                                 {\r
 433                                                         valueId = removeQuotes(valueId);\r
 434 \r
 435                                                         Databoard::Type::StringType* stringType = new Databoard::Type::StringType();\r
 436                                                         stringType->setNotBuiltIn();\r
 437 \r
 438                                                         Databoard::Value::StringValue* stringValue = new Databoard::Value::StringValue(stringType);\r
 439 \r
 440                                                         stringValue->setValue(valueId);\r
 441 \r
 442                                                         Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);\r
 443                                                         variantValue->setValue(stringValue);\r
 444 \r
 445                                                         return variantValue;\r
 446                                                 }\r
 447                                         }\r
 448 \r
 449                                         if(strEquals((char*)tree->getText(tree)->chars, STR_TRUE) == true)\r
 450                                         {\r
 451                                                 Databoard::Type::BooleanType* booleanType = new Databoard::Type::BooleanType();\r
 452                                                 booleanType->setNotBuiltIn();\r
 453 \r
 454                                                 Databoard::Value::BooleanValue* booleanValue = new Databoard::Value::BooleanValue(booleanType);\r
 455 \r
 456                                                 booleanValue->setValue(true);\r
 457 \r
 458                                                 Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);\r
 459                                                 variantValue->setValue(booleanValue);\r
 460 \r
 461                                                 return variantValue;\r
 462                                         }\r
 463                                         else if(strEquals((char*)tree->getText(tree)->chars, STR_FALSE) == true)\r
 464                                         {\r
 465                                                 Databoard::Type::BooleanType* booleanType = new Databoard::Type::BooleanType();\r
 466                                                 booleanType->setNotBuiltIn();\r
 467 \r
 468                                                 Databoard::Value::BooleanValue* booleanValue = new Databoard::Value::BooleanValue(booleanType);\r
 469 \r
 470                                                 booleanValue->setValue(false);\r
 471 \r
 472                                                 Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);\r
 473                                                 variantValue->setValue(booleanValue);\r
 474 \r
 475                                                 return variantValue;\r
 476                                         }\r
 477 \r
 478                                         return NULL;\r
 479                                 }\r
 480                                 else if(tree->getChildCount(tree) == 2)\r
 481                                 {\r
 482                                         pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);\r
 483                                         pANTLR3_BASE_TREE type = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);\r
 484 \r
 485                                         Databoard::Type::VariantType* variantType = (Databoard::Type::VariantType*)dataBoard;\r
 486 \r
 487                                         Databoard::Type::temporaryname a(NULL);\r
 488 \r
 489                                         Databoard::Type::DataType* dataType = a.parse(id);\r
 490 \r
 491                                         \r
 492                                         Databoard::Value::Value* value = parseValues(type, dataType, indent);\r
 493 \r
 494                                         Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);\r
 495                                         variantValue->setValue(value);\r
 496 \r
 497                                         return variantValue;\r
 498                                 }\r
 499                         }\r
 500                         else\r
 501                         {\r
 502                                 std::cout << "unknown: " << tree->getType(tree) << std::endl;\r
 503                         }\r
 504 \r
 505                         return NULL;\r
 506                 }\r
 507 \r
 508                 Value* DataValueRepository::parse(pANTLR3_BASE_TREE tree, Value* parent, int indent)\r
 509                 {\r
 510                         switch(tree->getType(tree)) {\r
 511                                 case VALUE_DEFINITIONS:\r
 512                                         {\r
 513                                                 for(int i=0;i<(int)tree->getChildCount(tree);++i)\r
 514                                                 {\r
 515                                                         Value* value = parse((pANTLR3_BASE_TREE)tree->getChild(tree, i), parent, indent + 1);\r
 516                                                 }\r
 517                                         }\r
 518                                         break;\r
 519                                 case VALUE_DEFINITION:\r
 520                                         {\r
 521                                                 if(tree->getChildCount(tree) == 3)\r
 522                                                 {\r
 523                                                         pANTLR3_BASE_TREE id = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);\r
 524                                                         pANTLR3_BASE_TREE type = (pANTLR3_BASE_TREE)tree->getChild(tree, 1);\r
 525                                                         pANTLR3_BASE_TREE values = (pANTLR3_BASE_TREE)tree->getChild(tree, 2);\r
 526 \r
 527                                                         //std::cout << id->getText(id)->chars << " : " << id->getType(id) << std::endl;\r
 528                                                         //std::cout << type->getText(type)->chars << " : " << type->getType(type) << std::endl;\r
 529                                                         //std::cout << values->getText(values)->chars << " : " << values->getType(values) << std::endl;\r
 530 \r
 531                                                         const Databoard::Type::strTypeDefinition* dataBoard = parseTypeReference(type);\r
 532 \r
 533                                                         Value* dataValue = parseValues(values, dataBoard->dataBoard, indent+1);\r
 534 \r
 535                                                         std::string valueId((char*)id->getText(id)->chars);\r
 536 \r
 537                                                         addDataValue(valueId, dataBoard->name, dataValue);\r
 538 \r
 539                                                         //std::cout << "." << std::endl;\r
 540                                                 }\r
 541                                         }\r
 542                                         break;\r
 543                                 default:\r
 544                                         break;\r
 545                         }\r
 546 \r
 547                         return NULL;\r
 548                 }\r
 549 \r
 550                 bool DataValueRepository::open(std::string fileName, Databoard::Type::DataBoardRepository* dataBoardRepository)\r
 551                 {\r
 552                         pANTLR3_INPUT_STREAM input = antlr3AsciiFileStreamNew((pANTLR3_UINT8)fileName.c_str());\r
 553 \r
 554                         if ( input == NULL )\r
 555                         {\r
 556                                 ANTLR3_FPRINTF(stderr, "string: %s\n", fileName.c_str());\r
 557                         }\r
 558 \r
 559                         pSimanticsDataLexer lexer = SimanticsDataLexerNew(input);\r
 560 \r
 561                         if ( lexer == NULL )\r
 562                         {\r
 563                                 ANTLR3_FPRINTF(stderr, "Unable to create the lexer due to malloc() failure1\n");\r
 564                                 exit(ANTLR3_ERR_NOMEM);\r
 565                         }\r
 566 \r
 567                         pANTLR3_COMMON_TOKEN_STREAM tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));//->pLexer->tokSource);\r
 568 \r
 569                         if (tstream == NULL)\r
 570                         {\r
 571                                 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate token stream\n");\r
 572                                 exit(ANTLR3_ERR_NOMEM);\r
 573                         }\r
 574 \r
 575                         pSimanticsDataParser parser = SimanticsDataParserNew(tstream); // CParserNew is generated by ANTLR3\r
 576 \r
 577                         if (parser == NULL)\r
 578                         {\r
 579                                 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate parser\n");\r
 580                                 exit(ANTLR3_ERR_NOMEM);\r
 581                         }\r
 582 \r
 583                         SimanticsDataParser_valueDefinitions_return astValue = parser->valueDefinitions(parser);\r
 584 \r
 585                         this->dataBoardRepository = dataBoardRepository;\r
 586 \r
 587                         bool retValue = true;\r
 588 \r
 589                         if(lexer->pLexer->rec->state->errorCount == 0)\r
 590                         {\r
 591                                 parse(astValue.tree);\r
 592 \r
 593                                 //print(astValue.tree);\r
 594                         }\r
 595                         else\r
 596                         {\r
 597                                 retValue = false;\r
 598                         }\r
 599 \r
 600                         parser->free(parser);\r
 601                         tstream->free(tstream);\r
 602                         lexer->free(lexer);\r
 603                         input->free(input);\r
 604 \r
 605                         return retValue;\r
 606                 }\r
 607 \r
 608                 Value* DataValueRepository::open(std::string fileName, Databoard::Type::DataType* dataType)\r
 609                 {\r
 610                         pANTLR3_INPUT_STREAM input = antlr3AsciiFileStreamNew((pANTLR3_UINT8)fileName.c_str());\r
 611 \r
 612                         if ( input == NULL )\r
 613                         {\r
 614                                 ANTLR3_FPRINTF(stderr, "string: %s\n", fileName.c_str());\r
 615                         }\r
 616 \r
 617                         pSimanticsDataLexer lexer = SimanticsDataLexerNew(input);\r
 618 \r
 619                         if ( lexer == NULL )\r
 620                         {\r
 621                                 ANTLR3_FPRINTF(stderr, "Unable to create the lexer due to malloc() failure1\n");\r
 622                                 exit(ANTLR3_ERR_NOMEM);\r
 623                         }\r
 624 \r
 625                         pANTLR3_COMMON_TOKEN_STREAM tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));//->pLexer->tokSource);\r
 626 \r
 627                         if (tstream == NULL)\r
 628                         {\r
 629                                 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate token stream\n");\r
 630                                 exit(ANTLR3_ERR_NOMEM);\r
 631                         }\r
 632 \r
 633                         pSimanticsDataParser parser = SimanticsDataParserNew(tstream); // CParserNew is generated by ANTLR3\r
 634 \r
 635                         if (parser == NULL)\r
 636                         {\r
 637                                 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate parser\n");\r
 638                                 exit(ANTLR3_ERR_NOMEM);\r
 639                         }\r
 640 \r
 641                         SimanticsDataParser_value_return astValue = parser->value(parser);\r
 642 \r
 643                         Value* retValue = NULL;\r
 644 \r
 645                         dataBoardRepository = NULL;\r
 646 \r
 647                         if(lexer->pLexer->rec->state->errorCount == 0)\r
 648                         {\r
 649                                 retValue = parseValues(astValue.tree, dataType, 0);\r
 650 \r
 651                                 //print(astValue.tree);\r
 652                         }\r
 653                         else\r
 654                         {\r
 655                                 retValue = false;\r
 656                         }\r
 657 \r
 658                         parser->free(parser);\r
 659                         tstream->free(tstream);\r
 660                         lexer->free(lexer);\r
 661                         input->free(input);\r
 662 \r
 663                         return retValue;\r
 664                 }\r
 665 \r
 666                 void DataValueRepository::print(pANTLR3_BASE_TREE tree, int indent)\r
 667                 {\r
 668                         for(int i=0;i<indent;++i)\r
 669                                 std::cout << "  ";\r
 670 \r
 671                         std::cout << tree->getText(tree)->chars << " " << \r
 672                                 tree->getType(tree) << std::endl;\r
 673 \r
 674                         for(int i=0;i<(int)tree->getChildCount(tree);++i)\r
 675                         {\r
 676                                 print((pANTLR3_BASE_TREE)tree->getChild(tree, i), indent + 1);\r
 677                         }\r
 678                 }\r
 679 \r
 680                 int DataValueRepository::count()\r
 681                 {\r
 682                         return (int)values.size();\r
 683                 }\r
 684 \r
 685                 const strDataValueDefinition* DataValueRepository::getDataValue(int i)\r
 686                 {\r
 687                         if(i >= 0 && i < (int)values.size())\r
 688                         {\r
 689                                 return &(values.at(i));\r
 690                         }\r
 691                         else\r
 692                         {\r
 693                                 return NULL;\r
 694                         }\r
 695                 }\r
 696 \r
 697                 const strDataValueDefinition* DataValueRepository::getDataValue(std::string name)\r
 698                 {\r
 699                         for(int i = 0; i < (int)values.size(); ++i)\r
 700                         {\r
 701                                 if(values.at(i).name == name)\r
 702                                 {\r
 703                                         return &(values.at(i));\r
 704                                 }\r
 705                         }\r
 706 \r
 707                         return NULL;\r
 708                 }\r
 709         }\r
 710 }\r