3 #include "DataValueRepository.h"
\r
5 #include "DataBoardRepository.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
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
34 #include "Constants.h"
\r
40 namespace Databoard {
\r
43 std::string strDataValueDefinition::writeOut() const
\r
47 r += name + " : " + type + " = ";
\r
51 r += value->writeOut();
\r
57 DataValueRepository::DataValueRepository()
\r
61 DataValueRepository::~DataValueRepository()
\r
63 for(int i=0;i<(int)values.size();++i)
\r
65 delete values.at(i).value;
\r
71 void DataValueRepository::addDataValue(std::string name, std::string type, Value* dataValue)
\r
73 strDataValueDefinition value_;
\r
77 value_.value = dataValue;
\r
79 values.push_back(value_);
\r
82 const Databoard::Type::strTypeDefinition* DataValueRepository::parseTypeReference(pANTLR3_BASE_TREE tree)
\r
84 switch(tree->getType(tree)) {
\r
85 case TYPE_REFERENCE:
\r
87 if(tree->getChildCount(tree) == 1)
\r
89 pANTLR3_BASE_TREE referenceName = (pANTLR3_BASE_TREE)tree->getChild(tree, 0);
\r
91 std::string id((char*)referenceName->getText(referenceName)->chars);
\r
93 const Databoard::Type::strTypeDefinition* dataBoard = dataBoardRepository->get(id);
\r
106 Value* DataValueRepository::parseValues(pANTLR3_BASE_TREE tree, Databoard::Type::DataType* dataBoard, int indent)
\r
108 if(dynamic_cast<Databoard::Type::OptionalType*>(dataBoard) != NULL)
\r
110 Databoard::Type::OptionalType* optionalType = (Databoard::Type::OptionalType*)dataBoard;
\r
112 Value* value = parseValues(tree, optionalType->getComponentType(), indent + 1);
\r
114 OptionalValue* optionalValue = new OptionalValue(optionalType);
\r
116 optionalValue->setValue(value);
\r
118 return optionalValue;
\r
120 else if(dynamic_cast<Databoard::Type::StringType*>(dataBoard) != NULL)
\r
122 Databoard::Type::StringType* stringType = (Databoard::Type::StringType*)dataBoard;
\r
124 StringValue* stringValue = new StringValue(dataBoard);
\r
126 std::string value((char*)tree->getText(tree)->chars);
\r
128 value = removeQuotes(value);
\r
130 stringValue->setValue(value);
\r
132 return stringValue;
\r
134 else if(dynamic_cast<Databoard::Type::IntegerType*>(dataBoard) != NULL)
\r
136 Databoard::Type::IntegerType* integerType = (Databoard::Type::IntegerType*)dataBoard;
\r
138 IntegerValue* integerValue = new IntegerValue(dataBoard);
\r
140 std::istringstream iss((char*)tree->getText(tree)->chars);
\r
146 integerValue->setValue(value);
\r
148 return integerValue;
\r
150 else if(dynamic_cast<Databoard::Type::LongType*>(dataBoard) != NULL)
\r
152 Databoard::Type::LongType* longType = (Databoard::Type::LongType*)dataBoard;
\r
154 LongValue* longValue = new LongValue(dataBoard);
\r
156 std::istringstream iss((char*)tree->getText(tree)->chars);
\r
162 longValue->setValue(value);
\r
166 else if(dynamic_cast<Databoard::Type::FloatType*>(dataBoard) != NULL)
\r
168 Databoard::Type::FloatType* floatType = (Databoard::Type::FloatType*)dataBoard;
\r
170 FloatValue* floatValue = new FloatValue(dataBoard);
\r
172 std::istringstream iss((char*)tree->getText(tree)->chars);
\r
178 floatValue->setValue(value);
\r
182 else if(dynamic_cast<Databoard::Type::DoubleType*>(dataBoard) != NULL)
\r
184 Databoard::Type::DoubleType* doubleType = (Databoard::Type::DoubleType*)dataBoard;
\r
186 DoubleValue* doubleValue = new DoubleValue(dataBoard);
\r
188 std::istringstream iss((char*)tree->getText(tree)->chars);
\r
194 doubleValue->setValue(value);
\r
196 return doubleValue;
\r
198 else if(dynamic_cast<Databoard::Type::RecordType*>(dataBoard) != NULL)
\r
200 if(tree->getType(tree) == TUPLE)
\r
202 Databoard::Type::RecordType* recordType = (Databoard::Type::RecordType*)dataBoard;
\r
204 RecordValue* recordValue = new RecordValue(recordType);
\r
206 int i2 = (int)tree->getChildCount(tree);
\r
207 int i3 = recordType->count();
\r
209 if((int)tree->getChildCount(tree) == recordType->count())
\r
211 for(int i=0;i<(int)tree->getChildCount(tree);++i)
\r
213 pANTLR3_BASE_TREE value = (pANTLR3_BASE_TREE)tree->getChild(tree, i);
\r
215 std::string strId((char*)value->getText(value)->chars);
\r
217 Databoard::Type::Component* component = recordType->getComponent(i);
\r
219 if(component != NULL)
\r
221 Databoard::Type::DataType* dataBoardType = component->getDataBoard();
\r
223 Value* childValue = parseValues(value, dataBoardType, indent + 1);
\r
225 recordValue->setField(i, childValue);
\r
229 return recordValue;
\r
233 std::cout << "mismatch in tuple count: " << (int)tree->getChildCount(tree) << " != " << recordType->count() << std::endl;
\r
237 else if(tree->getType(tree) == RECORD)
\r
239 Databoard::Type::RecordType* recordType = (Databoard::Type::RecordType*)dataBoard;
\r
241 RecordValue* recordValue = new RecordValue(recordType);
\r
243 for(int i=0;i<(int)tree->getChildCount(tree);++i)
\r
245 pANTLR3_BASE_TREE assignment = (pANTLR3_BASE_TREE)tree->getChild(tree, i);
\r
247 if(assignment->getType(assignment) == ASSIGNMENT)
\r
249 if(assignment->getChildCount(assignment) == 2)
\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
254 std::string strId((char*)id->getText(id)->chars);
\r
256 Databoard::Type::Component* component = recordType->getComponent(strId);
\r
258 if(component != NULL)
\r
260 Databoard::Type::DataType* dataBoardType = component->getDataBoard();
\r
262 if(dataBoardType != NULL)
\r
264 Value* childValue = parseValues(value, dataBoardType, indent + 1);
\r
266 int index = recordType->getComponentIndex(strId);
\r
268 recordValue->setField(index, childValue);
\r
275 return recordValue;
\r
278 else if(dynamic_cast<Databoard::Type::MapType*>(dataBoard) != NULL)
\r
280 Databoard::Type::MapType* mapType = (Databoard::Type::MapType*)dataBoard;
\r
282 MapValue* mapValue = new MapValue(mapType);
\r
284 int childCount = tree->getChildCount(tree);
\r
288 for(int i = 0; i < childCount; ++i)
\r
290 pANTLR3_BASE_TREE assignment = (pANTLR3_BASE_TREE)tree->getChild(tree, i);
\r
292 if(assignment->getType(assignment) == ASSIGNMENT)
\r
294 if(assignment->getChildCount(assignment) == 2)
\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
299 std::string strKey((char*)key->getText(key)->chars);
\r
300 std::string strValue((char*)value->getText(value)->chars);
\r
302 strKey = removeQuotes(strKey);
\r
303 strValue = removeQuotes(strValue);
\r
305 Value* keyValue = parseValues(key, mapType->getKeyType(), indent + 1);
\r
306 Value* valueValue = parseValues(value, mapType->getValueType(), indent + 1);
\r
308 if(keyValue != NULL && valueValue != NULL)
\r
310 mapValue->put(keyValue, valueValue);
\r
319 else if(dynamic_cast<Databoard::Type::ArrayType*>(dataBoard) != NULL)
\r
321 Databoard::Type::ArrayType* arrayType = (Databoard::Type::ArrayType*)dataBoard;
\r
323 ArrayValue* arrayValue = new ArrayValue(arrayType);
\r
325 int childCount = tree->getChildCount(tree);
\r
329 for(int i = 0; i < childCount; ++i)
\r
331 pANTLR3_BASE_TREE assignment = (pANTLR3_BASE_TREE)tree->getChild(tree, i);
\r
333 Databoard::Type::DataType* dataType = arrayType->getComponentType();
\r
335 Value* value = parseValues(assignment, dataType, indent + 1);
\r
337 arrayValue->add(value);
\r
340 //Value* keyValue = parseValues(key, dataType, indent + 1);
\r
343 // if(assignment->getType(assignment) == ASSIGNMENT)
\r
345 // if(assignment->getChildCount(assignment) == 2)
\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
350 // std::string strKey((char*)key->getText(key)->chars);
\r
351 // std::string strValue((char*)value->getText(value)->chars);
\r
353 // strKey = removeQuotes(strKey);
\r
354 // strValue = removeQuotes(strValue);
\r
356 // Value* keyValue = parseValues(key, mapType->getKeyType(), indent + 1);
\r
357 // Value* valueValue = parseValues(value, mapType->getValueType(), indent + 1);
\r
359 // if(keyValue != NULL && valueValue != NULL)
\r
361 // mapValue->put(keyValue, valueValue);
\r
370 else if(dynamic_cast<Databoard::Type::BooleanType*>(dataBoard) != NULL)
\r
372 Databoard::Type::BooleanType* booleanType = (Databoard::Type::BooleanType*)dataBoard;
\r
374 BooleanValue* booleanValue = new BooleanValue(dataBoard);
\r
376 std::string value((char*)tree->getText(tree)->chars);
\r
378 if(value == STR_TRUE)
\r
380 booleanValue->setValue(true);
\r
384 booleanValue->setValue(false);
\r
387 return booleanValue;
\r
389 else if(dynamic_cast<Databoard::Type::UnionType*>(dataBoard) != NULL)
\r
391 if(tree->getChildCount(tree) == 2)
\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
396 Databoard::Type::UnionType* unionType = (Databoard::Type::UnionType*)dataBoard;
\r
398 UnionValue* unionValue = new UnionValue(dataBoard);
\r
401 std::string strId((char*)id->getText(id)->chars);
\r
403 int tag = unionType->getComponentIndex(strId);
\r
405 Databoard::Type::Component* component = unionType->getComponent(tag);
\r
407 if(component != NULL)
\r
409 Databoard::Type::DataType* dataType = component->getDataBoard();
\r
411 if(dataType != NULL)
\r
413 Databoard::Value::Value* value = parseValues(type, dataType, indent);
\r
415 unionValue->setValue(tag, value);
\r
422 else if(dynamic_cast<Databoard::Type::VariantType*>(dataBoard) != NULL)
\r
424 if(tree->getChildCount(tree) == 0)
\r
426 std::string valueId((char*)tree->getText(tree)->chars);
\r
428 // check the string
\r
429 if(valueId.length() >= 2)
\r
431 if(valueId.at(0) == '"' && valueId.at(valueId.length()-1) == '"')
\r
433 valueId = removeQuotes(valueId);
\r
435 Databoard::Type::StringType* stringType = new Databoard::Type::StringType();
\r
436 stringType->setNotBuiltIn();
\r
438 Databoard::Value::StringValue* stringValue = new Databoard::Value::StringValue(stringType);
\r
440 stringValue->setValue(valueId);
\r
442 Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);
\r
443 variantValue->setValue(stringValue);
\r
445 return variantValue;
\r
449 if(strEquals((char*)tree->getText(tree)->chars, STR_TRUE) == true)
\r
451 Databoard::Type::BooleanType* booleanType = new Databoard::Type::BooleanType();
\r
452 booleanType->setNotBuiltIn();
\r
454 Databoard::Value::BooleanValue* booleanValue = new Databoard::Value::BooleanValue(booleanType);
\r
456 booleanValue->setValue(true);
\r
458 Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);
\r
459 variantValue->setValue(booleanValue);
\r
461 return variantValue;
\r
463 else if(strEquals((char*)tree->getText(tree)->chars, STR_FALSE) == true)
\r
465 Databoard::Type::BooleanType* booleanType = new Databoard::Type::BooleanType();
\r
466 booleanType->setNotBuiltIn();
\r
468 Databoard::Value::BooleanValue* booleanValue = new Databoard::Value::BooleanValue(booleanType);
\r
470 booleanValue->setValue(false);
\r
472 Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);
\r
473 variantValue->setValue(booleanValue);
\r
475 return variantValue;
\r
480 else if(tree->getChildCount(tree) == 2)
\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
485 Databoard::Type::VariantType* variantType = (Databoard::Type::VariantType*)dataBoard;
\r
487 Databoard::Type::temporaryname a(NULL);
\r
489 Databoard::Type::DataType* dataType = a.parse(id);
\r
492 Databoard::Value::Value* value = parseValues(type, dataType, indent);
\r
494 Databoard::Value::VariantValue* variantValue = new VariantValue(dataBoard);
\r
495 variantValue->setValue(value);
\r
497 return variantValue;
\r
502 std::cout << "unknown: " << tree->getType(tree) << std::endl;
\r
508 Value* DataValueRepository::parse(pANTLR3_BASE_TREE tree, Value* parent, int indent)
\r
510 switch(tree->getType(tree)) {
\r
511 case VALUE_DEFINITIONS:
\r
513 for(int i=0;i<(int)tree->getChildCount(tree);++i)
\r
515 Value* value = parse((pANTLR3_BASE_TREE)tree->getChild(tree, i), parent, indent + 1);
\r
519 case VALUE_DEFINITION:
\r
521 if(tree->getChildCount(tree) == 3)
\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
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
531 const Databoard::Type::strTypeDefinition* dataBoard = parseTypeReference(type);
\r
533 Value* dataValue = parseValues(values, dataBoard->dataBoard, indent+1);
\r
535 std::string valueId((char*)id->getText(id)->chars);
\r
537 addDataValue(valueId, dataBoard->name, dataValue);
\r
539 //std::cout << "." << std::endl;
\r
550 bool DataValueRepository::open(std::string fileName, Databoard::Type::DataBoardRepository* dataBoardRepository)
\r
552 pANTLR3_INPUT_STREAM input = antlr3AsciiFileStreamNew((pANTLR3_UINT8)fileName.c_str());
\r
554 if ( input == NULL )
\r
556 ANTLR3_FPRINTF(stderr, "string: %s\n", fileName.c_str());
\r
559 pSimanticsDataLexer lexer = SimanticsDataLexerNew(input);
\r
561 if ( lexer == NULL )
\r
563 ANTLR3_FPRINTF(stderr, "Unable to create the lexer due to malloc() failure1\n");
\r
564 exit(ANTLR3_ERR_NOMEM);
\r
567 pANTLR3_COMMON_TOKEN_STREAM tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));//->pLexer->tokSource);
\r
569 if (tstream == NULL)
\r
571 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate token stream\n");
\r
572 exit(ANTLR3_ERR_NOMEM);
\r
575 pSimanticsDataParser parser = SimanticsDataParserNew(tstream); // CParserNew is generated by ANTLR3
\r
577 if (parser == NULL)
\r
579 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate parser\n");
\r
580 exit(ANTLR3_ERR_NOMEM);
\r
583 SimanticsDataParser_valueDefinitions_return astValue = parser->valueDefinitions(parser);
\r
585 this->dataBoardRepository = dataBoardRepository;
\r
587 bool retValue = true;
\r
589 if(lexer->pLexer->rec->state->errorCount == 0)
\r
591 parse(astValue.tree);
\r
593 //print(astValue.tree);
\r
600 parser->free(parser);
\r
601 tstream->free(tstream);
\r
602 lexer->free(lexer);
\r
603 input->free(input);
\r
608 Value* DataValueRepository::open(std::string fileName, Databoard::Type::DataType* dataType)
\r
610 pANTLR3_INPUT_STREAM input = antlr3AsciiFileStreamNew((pANTLR3_UINT8)fileName.c_str());
\r
612 if ( input == NULL )
\r
614 ANTLR3_FPRINTF(stderr, "string: %s\n", fileName.c_str());
\r
617 pSimanticsDataLexer lexer = SimanticsDataLexerNew(input);
\r
619 if ( lexer == NULL )
\r
621 ANTLR3_FPRINTF(stderr, "Unable to create the lexer due to malloc() failure1\n");
\r
622 exit(ANTLR3_ERR_NOMEM);
\r
625 pANTLR3_COMMON_TOKEN_STREAM tstream = antlr3CommonTokenStreamSourceNew(ANTLR3_SIZE_HINT, TOKENSOURCE(lexer));//->pLexer->tokSource);
\r
627 if (tstream == NULL)
\r
629 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate token stream\n");
\r
630 exit(ANTLR3_ERR_NOMEM);
\r
633 pSimanticsDataParser parser = SimanticsDataParserNew(tstream); // CParserNew is generated by ANTLR3
\r
635 if (parser == NULL)
\r
637 ANTLR3_FPRINTF(stderr, "Out of memory trying to allocate parser\n");
\r
638 exit(ANTLR3_ERR_NOMEM);
\r
641 SimanticsDataParser_value_return astValue = parser->value(parser);
\r
643 Value* retValue = NULL;
\r
645 dataBoardRepository = NULL;
\r
647 if(lexer->pLexer->rec->state->errorCount == 0)
\r
649 retValue = parseValues(astValue.tree, dataType, 0);
\r
651 //print(astValue.tree);
\r
658 parser->free(parser);
\r
659 tstream->free(tstream);
\r
660 lexer->free(lexer);
\r
661 input->free(input);
\r
666 void DataValueRepository::print(pANTLR3_BASE_TREE tree, int indent)
\r
668 for(int i=0;i<indent;++i)
\r
671 std::cout << tree->getText(tree)->chars << " " <<
\r
672 tree->getType(tree) << std::endl;
\r
674 for(int i=0;i<(int)tree->getChildCount(tree);++i)
\r
676 print((pANTLR3_BASE_TREE)tree->getChild(tree, i), indent + 1);
\r
680 int DataValueRepository::count()
\r
682 return (int)values.size();
\r
685 const strDataValueDefinition* DataValueRepository::getDataValue(int i)
\r
687 if(i >= 0 && i < (int)values.size())
\r
689 return &(values.at(i));
\r
697 const strDataValueDefinition* DataValueRepository::getDataValue(std::string name)
\r
699 for(int i = 0; i < (int)values.size(); ++i)
\r
701 if(values.at(i).name == name)
\r
703 return &(values.at(i));
\r