ButtonConfigPtr createButtonConfig(const std::string& path, SystemManagerPtr systemManager) {
std::ifstream file;
file.open(path);
std::string builder;
std::string line;
while (std::getline(file, line)) {
builder.append(line);
}
file.close();
rapidjson::Document doc;
doc.Parse(builder.c_str());
const rapidjson::Value& parsedButton = doc["button"];
std::string image = parsedButton["image"].GetString();
GraphicsSystemPtr graphicsSystem = static_pointer_cast<GraphicsSystem>(systemManager->systems.at(SystemType::GRAPHICS));
graphicsSystem->addTexture(image, image);
ButtonConfig* buttonConfig = new ButtonConfig();
buttonConfig->sectionWidth = parsedButton["section_width"].GetInt();
buttonConfig->sectionHeight = parsedButton["section_height"].GetInt();
parseState(image, parsedButton["button_up"], buttonConfig->buttonUp);
parseState(image, parsedButton["button_over"], buttonConfig->buttonOver);
parseState(image, parsedButton["button_down"], buttonConfig->buttonDown);
return ButtonConfigPtr(buttonConfig);
}
PanelConfigPtr createPanelConfig(const std::string& path, SystemManagerPtr systemManager) {
std::ifstream file;
file.open(path);
std::string builder;
std::string line;
while (std::getline(file, line)) {
builder.append(line);
}
file.close();
rapidjson::Document doc;
doc.Parse(builder.c_str());
const rapidjson::Value& parsedPanel = doc["panel"];
std::string image = parsedPanel["image"].GetString();
GraphicsSystemPtr graphicsSystem = static_pointer_cast<GraphicsSystem>(systemManager->systems.at(SystemType::GRAPHICS));
graphicsSystem->addTexture(image, image);
PanelConfig* panelConfig = new PanelConfig();
panelConfig->sectionWidth = parsedPanel["section_width"].GetInt();
panelConfig->sectionHeight = parsedPanel["section_height"].GetInt();
parseState(image, parsedPanel["sections"], panelConfig->panelSections);
return PanelConfigPtr(panelConfig);
}
void
pktgen_process_enable_disable(port_info_t * info, char * str)
{
if ( parseState(str) == ENABLE_STATE )
pktgen_set_port_flags(info, PROCESS_INPUT_PKTS);
else
pktgen_clr_port_flags(info, PROCESS_INPUT_PKTS);
}
void
pktgen_theme_state(const char * state)
{
if ( parseState(state) == DISABLE_STATE )
scrn->theme = THEME_OFF;
else
scrn->theme = THEME_ON;
cmdline_set_prompt(pktgen.cl, pktgen_get_prompt());
}
void
pktgen_blink_enable_disable(port_info_t * info, char * str)
{
if ( parseState(str) == ENABLE_STATE ) {
pktgen.blinklist |= (1 << info->pid);
} else {
pktgen.blinklist &= ~(1 << info->pid);
rte_eth_led_on(info->pid);
}
}
int HeadSetDetect::detect()
{
char buffer[1024];
int state =-1;
int count = socketNextEvent(buffer,sizeof(buffer));
if(count != 0)
{
state = parseState(buffer,count);
}
return state;
}
void
pktgen_range_enable_disable(port_info_t * info, char * str)
{
if ( parseState(str) == ENABLE_STATE ) {
pktgen_clr_port_flags(info, SEND_SEQ_PKTS);
pktgen_clr_port_flags(info, SEND_PCAP_PKTS);
pktgen_set_port_flags(info, SEND_RANGE_PKTS);
} else
pktgen_clr_port_flags(info, SEND_RANGE_PKTS);
pktgen_packet_rate(info);
}
prvreader::PrvEvent* prvreader::PrvParser::parseLine()
{
string line;
PrvEvent* prvEvent;
if (prvStream){
if(getline(*prvStream,line)){
lineNumber++;
if (lineNumber%10000==0){
Message::Debug(to_string(lineNumber)+ " lines processed");
}
replace(line.begin(), line.end(), '\t', ' ');
std::size_t found = line.find_first_of("(");
if ((found!=std::string::npos)&&(found+1<line.length())){
found = line.find_first_of("a", found+1);
}
if ((found!=std::string::npos)&&(line[found+1]=='t')&&(found+5<line.length())&&(line[found+5]==PRV_HEADER_SEP_MAIN_CHAR)){
line[found+5]='*';
}
replace(line.begin(), line.end(), PRV_HEADER_QUOTE_IN_CHAR, GENERIC_SEP_CHAR);
replace(line.begin(), line.end(), PRV_HEADER_QUOTE_OUT_CHAR, GENERIC_SEP_CHAR);
trim_all(line);
if (!line.empty()){
escaped_list_separator<char> sep(GENERIC_ESCAPE_CHAR, PRV_HEADER_SEP_MAIN_CHAR, GENERIC_QUOTE_CHAR);
tokenizer<escaped_list_separator<char> > *tokens = new tokenizer<escaped_list_separator<char> >(line, sep);
tokenizer<escaped_list_separator<char> >::iterator tokensIterator=tokens->begin();
if (mode==Header){
prvEvent=parseHeader(tokens);
mode=Body;
}else{
string eventType=*tokensIterator;
tokensIterator++;
//communicator
if (eventType.compare(PRV_BODY_COMMUNICATOR)==0){
prvEvent= new PrvOther(lineNumber, prveventtype::Skip);
//communications
}else if (eventType.compare(PRV_BODY_COMMUNICATION)==0){
prvEvent=parseCommunications(tokens, lineNumber);
}else if (eventType.compare(PRV_BODY_EVENTS)==0){
prvEvent=parseEvents(tokens, lineNumber);
}else if (eventType.compare(PRV_BODY_STATE)==0){
prvEvent=parseState(tokens, lineNumber);
}else{
prvEvent= new PrvOther(lineNumber, prveventtype::Skip);
}
}
delete tokens;
}
}else{
prvEvent=new PrvOther(lineNumber, prveventtype::End);
}
}
return prvEvent;
}
void
pktgen_pcap_enable_disable(port_info_t * info, char * str)
{
if ( (info->pcap != NULL) && (info->pcap->pkt_count != 0) ) {
if ( parseState(str) == ENABLE_STATE ) {
pktgen_clr_port_flags(info, SEND_RANGE_PKTS);
pktgen_clr_port_flags(info, SEND_SEQ_PKTS);
pktgen_set_port_flags(info, SEND_PCAP_PKTS);
} else
pktgen_clr_port_flags(info, SEND_PCAP_PKTS);
pktgen_packet_rate(info);
}
}
bool NavigationDataReceiver::parse(MemoryLibrary::Buffer& buffer)
{
int offset = 0;
int header = buffer.MakeValueFromOffset<int32_t>(offset);
if(header != 0x55667788)
{
std::cout << "NavigationDataReceiver::Parse FAIL, header != 0x55667788\n";
return false;
}
offset += 4;
int state = buffer.MakeValueFromOffset<int32_t>(offset);
parseState(state);
offset += 4;
myNavData.sequence = buffer.MakeValueFromOffset<int32_t>(offset);
offset += 4;
myNavData.visionFlag = buffer.MakeValueFromOffset<int32_t>(offset);
offset += 4;
while(offset < buffer.Size())
{
int option_tag = (int)buffer.MakeValueFromOffset<unsigned short>(offset);
offset += 2;
int option_len = (int)buffer.MakeValueFromOffset<unsigned short>(offset);
offset += 2;
if(option_len == 0)
{
std::cout << "NavigationDataReceiver::Parse FAIL, option_len == 0\n";
return false;
}
switch(option_tag)
{
case NAVDATA_DEMO_TAG:
parseNavigation(buffer, offset);
break;
case NAVDATA_CKS_TAG: break;
case NAVDATA_VISION_DETECT_TAG:
parseVision(buffer, offset);
break;
}
offset = offset + option_len - 4;
} //while
return true;
}
U_CAPI void U_EXPORT2
ucm_addState(UCMStates *states, const char *s) {
const char *error;
if(states->countStates==MBCS_MAX_STATE_COUNT) {
fprintf(stderr, "ucm error: too many states (maximum %u)\n", MBCS_MAX_STATE_COUNT);
exit(U_INVALID_TABLE_FORMAT);
}
error=parseState(s, states->stateTable[states->countStates],
&states->stateFlags[states->countStates]);
if(error!=NULL) {
fprintf(stderr, "ucm error: parse error in state definition at '%s'\n", error);
exit(U_INVALID_TABLE_FORMAT);
}
++states->countStates;
}
void
pktgen_screen(const char * onOff)
{
if ( parseState(onOff) == DISABLE_STATE ) {
if ( !scrn_is_paused() ) {
scrn_pause();
scrn_cls();
scrn_setw(1);
scrn_pos(scrn->nrows, 1);
}
} else {
scrn_cls();
scrn_pos(scrn->nrows,1);
scrn_setw(pktgen.last_row+1);
scrn_resume();
pktgen_redisplay(1);
}
}
bool XMLEngine::parseStates(QXmlStreamReader * reader, StateList * states, TransitionList * transitions)
{
if (reader->readNextStartElement() && compare(reader->name(), "states"))
{
while (reader->readNextStartElement() && compare(reader->name(), "state"))
{
QString name = reader->attributes().value("name").toString();
QString id = reader->attributes().value("id").toString();
QString type = reader->attributes().value("type").toString();
State * state = Factory::create(name, id, type);
parseState(reader, state, transitions);
states->append(state);
}
}
return !reader->hasError();
}
void Parser::Private::parseStatus()
{
Status s;
while (notAtEnd()) {
blockingReadNext();
if (reader.isEndElement())
break;
if (reader.isStartElement()) {
const QStringRef name = reader.name();
if (name == QLatin1String("state"))
s.setState(parseState(blockingReadElementText()));
else if (name == QLatin1String("time"))
s.setTime(blockingReadElementText());
else if (reader.isStartElement())
reader.skipCurrentElement();
}
}
emit q->status(s);
}
bool FSMDescrip::loadFromXML(const std::string& xmlName, bool verbose) {
logger << Logger::INFO_MSG << "Loading behavior from xml: " << xmlName;
TiXmlDocument xml(xmlName);
bool loadOkay = xml.LoadFile();
if (!loadOkay) {
logger << Logger::ERR_MSG << "Could not load behavior configuration xml (";
logger << xmlName << ") due to xml syntax errors.\n";
logger << "\t" << xml.ErrorDesc();
return false;
}
TiXmlElement* popNode = xml.RootElement();
if (!popNode) {
logger << Logger::ERR_MSG << "Root element does not exist.";
return false;
}
if (popNode->ValueStr() != "BFSM") {
logger << Logger::ERR_MSG << "Root element value should be \"BFSM\".";
return false;
}
std::string absPath;
os::path::absPath(xmlName, absPath);
std::string junk;
os::path::split(absPath, _behaviorFldr, junk);
logger << Logger::INFO_MSG << "Behavior root: " << _behaviorFldr;
TiXmlElement* child;
for (child = popNode->FirstChildElement(); child; child = child->NextSiblingElement()) {
if (child->ValueStr() == "GoalSet") {
int i;
if (!child->Attribute("id", &i)) {
logger << Logger::ERR_MSG << "GoalSet requires an \"id\" property.";
return false;
}
size_t setID = static_cast<size_t>(i);
// confirm that the id doesn't already exist
if (_goalSets.find(setID) != _goalSets.end()) {
logger << Logger::WARN_MSG << "Found multiple GoalSets with the same id: ";
logger << setID << ".\n\tGoal definitions will be merged!";
} else {
_goalSets[setID] = new GoalSet();
}
TiXmlElement* goalNode;
for (goalNode = child->FirstChildElement(); goalNode;
goalNode = goalNode->NextSiblingElement()) {
if (goalNode->ValueStr() == "Goal") {
Goal* goal = parseGoal(goalNode, _behaviorFldr);
if (goal == 0x0) {
logger << Logger::ERR_MSG << "Error parsing a goal description.";
return false;
}
// Make sure that this goal doesn't duplicate previous goal ids
if (!_goalSets[setID]->addGoal(goal->getID(), goal)) {
logger << Logger::ERR_MSG << "GoalSet " << setID;
logger << " has two goals with the identifier: " << goal->getID();
logger << " (second appears on line " << goalNode->Row() << ").";
return false;
}
} else {
logger << Logger::WARN_MSG
<< "Found a child tag of the GoalSet that "
"is not a \"Goal\" tag on line "
<< goalNode->Row()
<< ". "
"It will be ignored.";
}
}
} else if (child->ValueStr() == "State") {
if (!parseState(child, _behaviorFldr, _states)) {
return false;
}
} else if (child->ValueStr() == "Transition") {
std::string from;
Transition* trans = parseTransition(child, _behaviorFldr, from);
if (trans == 0x0) {
return false;
}
addTransition(from, trans);
} else if (child->ValueStr() == "VelModifier") {
VelModifier* vel = parseVelModifier(child, _behaviorFldr);
if (vel == 0x0) {
return false;
} else {
_velModifiers.push_back(vel);
}
} else if (child->ValueStr() == "Task") {
Task* task = parseTask(child, _behaviorFldr);
if (task == 0x0) {
logger << Logger::WARN_MSG << "User-specified Task on line ";
logger << child->Row()
<< " couldn't be instantiated. "
"It is being ignored.";
} else {
_tasks.push_back(task);
}
} else if (child->ValueStr() == "EventSystem") {
if (!EVENT_SYSTEM->parseEvents(child, _behaviorFldr)) {
return false;
}
} else {
logger << Logger::ERR_MSG << "Unrecognized tag as child of <Population>: <";
logger << child->ValueStr() << ">.";
return false;
}
}
return true;
}
int
parseConfigLine(char *line, char *filename, int lineno, int set)
{
int x0, x1;
int i, from, to;
AtomPtr name, value;
ConfigVariablePtr var;
int iv;
float fv;
AtomPtr av;
AtomListPtr alv;
IntListPtr ilv;
i = skipWhitespace(line, 0);
if(line[i] == '\n' || line[i] == '\0' || line[i] == '#')
return 0;
x0 = i;
while(letter(line[i]) || digit(line[i]))
i++;
x1 = i;
i = skipWhitespace(line, i);
if(line[i] != '=') {
goto syntax;
}
i++;
i = skipWhitespace(line, i);
name = internAtomN(line + x0, x1 - x0);
var = findConfigVariable(name);
releaseAtom(name);
if(set && var->setter == NULL)
return -2;
if(var == NULL) {
if(!set) {
do_log(L_ERROR, "%s:%d: unknown config variable ",
filename, lineno);
do_log_n(L_ERROR, line + x0, x1 - x0);
do_log(L_ERROR, "\n");
}
return -1;
}
i = skipWhitespace(line, i);
switch(var->type) {
case CONFIG_INT: case CONFIG_OCTAL: case CONFIG_HEX:
i = parseInt(line, i, &iv);
if(i < 0) goto syntax;
if(set)
var->setter(var, &iv);
else
*var->value.i = iv;
break;
case CONFIG_TIME:
i = parseTime(line, i, &iv);
if(i < 0) goto syntax;
i = skipWhitespace(line, i);
if(line[i] != '\n' && line[i] != '\0' && line[i] != '#')
goto syntax;
if(set)
var->setter(var, &iv);
else
*var->value.i = iv;
break;
case CONFIG_BOOLEAN:
case CONFIG_TRISTATE:
case CONFIG_TETRASTATE:
case CONFIG_PENTASTATE:
iv = parseState(line, i, var->type);
if(iv < 0)
goto syntax;
if(set)
var->setter(var, &iv);
else
*var->value.i = iv;
break;
case CONFIG_FLOAT:
if(!digit(line[i]) && line[i] != '.')
goto syntax;
fv = atof(line + i);
if(set)
var->setter(var, &fv);
else
*var->value.f = fv;
break;
case CONFIG_ATOM: case CONFIG_ATOM_LOWER: case CONFIG_PASSWORD:
i = parseAtom(line, i, &av, (var->type == CONFIG_ATOM_LOWER));
if(i < 0) goto syntax;
if(!av) {
if(!set)
do_log(L_ERROR, "%s:%d: couldn't allocate atom.\n",
filename, lineno);
return -1;
}
i = skipWhitespace(line, i);
if(line[i] != '\n' && line[i] != '\0' && line[i] != '#') {
releaseAtom(av);
goto syntax;
}
if(set)
var->setter(var, &av);
else {
if(*var->value.a) releaseAtom(*var->value.a);
*var->value.a = av;
}
break;
case CONFIG_INT_LIST:
ilv = makeIntList(0);
if(ilv == NULL) {
if(!set)
do_log(L_ERROR, "%s:%d: couldn't allocate int list.\n",
filename, lineno);
return -1;
}
while(1) {
i = parseInt(line, i, &from);
if(i < 0) goto syntax;
to = from;
i = skipWhitespace(line, i);
if(line[i] == '-') {
i = skipWhitespace(line, i + 1);
i = parseInt(line, i, &to);
if(i < 0) {
destroyIntList(ilv);
goto syntax;
}
i = skipWhitespace(line, i);
}
intListCons(from, to, ilv);
if(line[i] == '\n' || line[i] == '\0' || line[i] == '#')
break;
if(line[i] != ',') {
destroyIntList(ilv);
goto syntax;
}
i = skipWhitespace(line, i + 1);
}
if(set)
var->setter(var, &ilv);
else {
if(*var->value.il) destroyIntList(*var->value.il);
*var->value.il = ilv;
}
break;
case CONFIG_ATOM_LIST: case CONFIG_ATOM_LIST_LOWER:
alv = makeAtomList(NULL, 0);
if(alv == NULL) {
if(!set)
do_log(L_ERROR, "%s:%d: couldn't allocate atom list.\n",
filename, lineno);
return -1;
}
while(1) {
i = parseAtom(line, i, &value,
(var->type == CONFIG_ATOM_LIST_LOWER));
if(i < 0) goto syntax;
if(!value) {
if(!set)
do_log(L_ERROR, "%s:%d: couldn't allocate atom.\n",
filename, lineno);
return -1;
}
atomListCons(value, alv);
i = skipWhitespace(line, i);
if(line[i] == '\n' || line[i] == '\0' || line[i] == '#')
break;
if(line[i] != ',') {
destroyAtomList(alv);
goto syntax;
}
i = skipWhitespace(line, i + 1);
}
if(set)
var->setter(var, &alv);
else {
if(*var->value.al) destroyAtomList(*var->value.al);
*var->value.al = alv;
}
break;
default: abort();
}
return 1;
syntax:
if(!set)
do_log(L_ERROR, "%s:%d: parse error.\n", filename, lineno);
return -1;
}
