DecimalInputSymbolRef::DecimalInputSymbolRef(InputSource& input, Array<Action*>& actions, ErrorHandler& errorHandler, OptionParameters& optionParameters, Symbols& symbols, unsigned long& timeOfOptionExecution, unsigned long& timeOfStateExecution) : symbol(0), parameters(0) { char buf[100]; input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating a reference to decimal input symbol \"%s\"",buf)); if (!symbols.decimalInputSymbols.exists(buf)) { errorHandler.error("XabslDecimalInputSymbolRef::DecimalInputSymbolRef(): decimal input symbol \"%s\" was not registered",buf); return; } symbol = symbols.decimalInputSymbols[buf]; parameters = new ParameterAssignment(&symbol->parameters, errorHandler); parameters->create(input, optionParameters, symbols, timeOfOptionExecution, timeOfStateExecution, actions); }
EnumeratedInputSymbolRef::EnumeratedInputSymbolRef(const Enumeration* enumeration, InputSource& input, ErrorHandler& errorHandler, Symbols& symbols, Option& option, State& state) : symbol(0), parameters(0) { char buf[100]; input.readString(buf, 99); XABSL_DEBUG_INIT(errorHandler.message("creating reference to enumerated input symbol \"%s\"", buf)); if(!symbols.enumeratedInputSymbols.exists(buf)) { errorHandler.error("XabslEnumeratedInputSymbolRef::XabslEnumeratedInputSymbolRef(): enumerated input symbol \"%s\" was not registered at the engine", buf); return; } symbol = symbols.enumeratedInputSymbols[buf]; this->enumeration = symbol->enumeration; if(enumeration != NULL && enumeration != this->enumeration) { errorHandler.error("XabslEnumeratedInputSymbolRef::XabslEnumeratedInputSymbolRef(): enumeration input symbol \"%s\" does not match enumeration type \"%s\"", buf, enumeration->n); } parameters = new ParameterAssignment(&symbol->parameters, errorHandler); parameters->create(input, symbols, option, state); }
BooleanValue::BooleanValue(InputSource& input, ErrorHandler& XABSL_DEBUG_INIT(errorHandler)) { char buf[6]; input.readString(buf,5); value = (strcmp("true",buf) == 0); XABSL_DEBUG_INIT(errorHandler.message("created boolean value: \"%s\"",value?"true":"false")); }
void State::create(InputSource& input, Array<Option*>& options, Array<BasicBehavior*>& basicBehaviors, Array<State*>& states, OptionParameters& parameters, Symbols& symbols, unsigned& timeOfOptionExecution) { XABSL_DEBUG_INIT(errorHandler.message("creating state \"%s\"",n)); char c[100]; int i; // target state or not input.readString(c,1); if (*c == '1') { targetState = true; } // subsequent option, basic behaviors and output symbol assignments int numberOfActions = (int)input.readValue(); subsequentOption = 0; for(i = 0; i< numberOfActions; i++) { Action* action = Action::create(input, options, basicBehaviors, parameters, symbols, timeOfOptionExecution, timeOfStateExecution, actions, errorHandler, pTimeFunction); if (errorHandler.errorsOccurred) { errorHandler.error("XabslState::create(): could not create action for state \"%s\"",n); return; } if (subsequentOption == 0) if (ActionOption* actionOption = dynamic_cast<ActionOption*>(action)) subsequentOption = actionOption->option; actions.append("", action); } // transition to state or if / else block decisionTree = Statement::createStatement(input,actions,errorHandler, states,parameters, symbols, timeOfOptionExecution,timeOfStateExecution); if (errorHandler.errorsOccurred) errorHandler.error("XabslState::create(): could not create decision tree for state \"%s\"",n); }
TransitionToState::TransitionToState(InputSource& input, ErrorHandler& errorHandler, Array<State*>& states) { char buf[100]; input.readString(buf,99); nextState = states[buf]; XABSL_DEBUG_INIT(errorHandler.message("creating a transition to state \"%s\"",nextState->n)); }
BooleanOutputSymbolRef::BooleanOutputSymbolRef(InputSource& input, ErrorHandler& errorHandler, Symbols& symbols) { char buf[100]; input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating a reference to a boolean output symbol \"%s\"",buf)); if (!symbols.booleanOutputSymbols.exists(buf)) { errorHandler.error("XabslBooleanOutputSymbolRef::BooleanOutputSymbolRef(): boolean output symbol \"%s\" was not registered",buf); return; } symbol = symbols.booleanOutputSymbols[buf]; }
BooleanOptionParameterRef::BooleanOptionParameterRef(InputSource& input, ErrorHandler& errorHandler, Option& option) { char buf[100]; input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating a reference to boolean option parameter \"%s\"",buf)); if (!option.parameters->boolean.exists(buf)) { errorHandler.error("XabslBooleanOptionParameterRef::BooleanOptionParameterRef(): boolean option parameter \"%s\" does not exist",buf); return; } parameter = option.parameters->boolean.getPElement(buf)->e; }
DecimalOptionParameterRef::DecimalOptionParameterRef(InputSource& input, ErrorHandler& errorHandler, OptionParameters& parameters) { char buf[100]; input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating a reference to decimal option parameter \"%s\"",buf)); if (!parameters.decimal.exists(buf)) { errorHandler.error("XabslDecimalOptionParameterRef::DecimalOptionParameterRef(): decimal option parameter \"%s\" does not exist",buf); return; } parameter = parameters.decimal.getPElement(buf)->e; }
EnumeratedValue::EnumeratedValue(const Enumeration* enumeration, InputSource& input, ErrorHandler& errorHandler) { char buf[100]; input.readString(buf, 99); if(enumeration == NULL) { errorHandler.error("XabslEnumeratedValue::EnumeratedValue(): enumerated value can not be created without specifying enumeration"); return; } if(!enumeration->enumElements.exists(buf)) { errorHandler.error("XabslEnumeratedValue::EnumeratedValue(): enum element \"%s\" of enumeration \"%s\" was not registered", buf, enumeration->n); return; } value = enumeration->enumElements[buf]->v; this->enumeration = enumeration; }
EnumeratedOptionParameterRef::EnumeratedOptionParameterRef(const Enumeration* enumeration, InputSource& input, ErrorHandler& errorHandler, Option& option) { char buf[100]; input.readString(buf, 99); XABSL_DEBUG_INIT(errorHandler.message("creating a reference to enumerated option parameter \"%s\"", buf)); if(!option.parameters->enumerated.exists(buf)) { errorHandler.error("XabslEnumeratedOptionParameterRef::EnumeratedOptionParameterRef(): enumerated option parameter \"%s\" does not exist", buf); return; } parameter = option.parameters->enumerated.getPElement(buf)->e; this->enumeration = option.parameters->enumerations[buf]; if(enumeration != NULL && enumeration != this->enumeration) { errorHandler.error("XabslEnumeratedOptionParameterRef::EnumeratedOptionParameterRef(): enumeration input symbol \"%s\" does not match enumeration type \"%s\"", buf, enumeration->n); } }
BooleanInputSymbolRef::BooleanInputSymbolRef(InputSource& input, ErrorHandler& errorHandler, Symbols& symbols, Option& option, State& state) : symbol(0), parameters(0) { char buf[100]; input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating reference to boolean input symbol \"%s\"",buf)); if (!symbols.booleanInputSymbols.exists(buf)) { errorHandler.error("XabslBooleanInputSymbolRef::XabslBooleanInputSymbolRef(): boolean input symbol \"%s\" was not registered at the engine",buf); return; } symbol = symbols.booleanInputSymbols[buf]; parameters = new ParameterAssignment(&symbol->parameters, errorHandler); parameters->create(input, symbols, option, state); }
EnumeratedOutputSymbolRef::EnumeratedOutputSymbolRef(const Enumeration* enumeration, InputSource& input, ErrorHandler& errorHandler, Symbols& symbols) { char buf[100]; input.readString(buf, 99); XABSL_DEBUG_INIT(errorHandler.message("creating a reference to an enumerated output symbol \"%s\"", buf)); if(!symbols.enumeratedOutputSymbols.exists(buf)) { errorHandler.error("XabslEnumeratedOutputSymbolRef::EnumeratedOutputSymbolRef(): enumerated output symbol \"%s\" was not registered", buf); return; } symbol = symbols.enumeratedOutputSymbols[buf]; this->enumeration = symbol->enumeration; if(enumeration != NULL && enumeration != this->enumeration) { errorHandler.error("XabslEnumeratedInputSymbolRef::XabslEnumeratedInputSymbolRef(): enumeration input symbol \"%s\" does not match enumeration type \"%s\"", buf, enumeration->n); } }
void ParameterAssignment::create( InputSource& input, Symbols& symbols, Option& option, State& state) { int i; // read the parameters int numberOfParameters = (int)input.readValue(); for (i = 0; i<numberOfParameters; i++) { char c[2]; char buf[100]; input.readString(c,1); switch(c[0]) { case 'd': { input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating expession for set decimal parameter \"%s\"",buf)); const DecimalExpression* exp = DecimalExpression::create(input,errorHandler,symbols,option,state); if (errorHandler.errorsOccurred) { errorHandler.error("XabslParameterAssignment::create(): could not create decimal expression for parameter \"%s\"",buf); return; } if (!setDecimalParameter(buf, exp)) return; } break; case 'b': { input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating expession for set boolean parameter \"%s\"",buf)); const BooleanExpression* exp = BooleanExpression::create(input,errorHandler,symbols,option,state); if (errorHandler.errorsOccurred) { errorHandler.error("XabslParameterAssignment::create(): could not create boolean expression for parameter \"%s\"",buf); return; } if (!setBooleanParameter(buf, exp)) return; } break; case 'e': { input.readString(buf,99); if(!symbols.enumerations.exists(buf)) { errorHandler.error("XabslParameterAssignment::create(): enumeration \"%s\" was not registered",buf); return; } const Enumeration* enumeration = symbols.enumerations[buf]; input.readString(buf,99); XABSL_DEBUG_INIT(errorHandler.message("creating expession for set enumerated parameter \"%s\"",buf)); const EnumeratedExpression* exp = EnumeratedExpression::create(enumeration,input,errorHandler,symbols,option,state); if (errorHandler.errorsOccurred) { errorHandler.error("XabslParameterAssignment::create(): could not create enumerated expression for parameter \"%s\"",buf); return; } if (!setEnumeratedParameter(buf, exp)) return; } break; } } }
void Engine::createOptionGraph(InputSource& input) { int i; char buf1[100],buf2[100]; if (initialized) { errorHandler.error("createOptionGraph(): Don't call this function twice"); return; } if (!input.open()) { errorHandler.error("createOptionGraph(): Can't open input source"); return; } // create internal enumerations int numberOfInternalEnumerations = (int)input.readValue(); for (i=0; i < numberOfInternalEnumerations; i++) { input.readString(buf1, 99); int numberOfElements = (int)input.readValue(); for (int j=0; j < numberOfElements; j++) { input.readString(buf2, 99); registerEnumElement(buf1, buf2, j); if (errorHandler.errorsOccurred) { errorHandler.error("XabslEngine::createOptionGraph(): could not register internal enumeration \"%s\"",buf1); return; } } } // create internal symbols int numberOfInternalSymbols = (int)input.readValue(); for (i=0; i < numberOfInternalSymbols; i++) { char c[2]; input.readString(c,1); switch (c[0]) { case 'd': input.readString(buf1,99); internalDecimalSymbols.append(buf1, 0); registerDecimalOutputSymbol(buf1, &(internalDecimalSymbols.getElement(internalDecimalSymbols.getSize() - 1))); if (errorHandler.errorsOccurred) { errorHandler.error("XabslEngine::createOptionGraph(): could not register internal decimal symbol \"%s\"",buf1); return; } break; case 'b': input.readString(buf1,99); internalBooleanSymbols.append(buf1, false); registerBooleanOutputSymbol(buf1, &(internalBooleanSymbols.getElement(internalBooleanSymbols.getSize() - 1))); if (errorHandler.errorsOccurred) { errorHandler.error("XabslEngine::createOptionGraph(): could not register internal boolean symbol \"%s\"",buf1); return; } break; case 'e': input.readString(buf1,99); if (!enumerations.exists(buf1)) { errorHandler.error("XabslEngine::createOptionGraph(): enumeration \"%s\" was not registered",buf1); return; } const Enumeration* enumeration = enumerations[buf1]; if (enumeration->enumElements.getSize() == 0) { errorHandler.error("XabslEngine::createOptionGraph(): no enumeration elements for \"%s\" were registered",buf1); return; } input.readString(buf2,99); internalEnumeratedSymbols.append(buf2, enumeration->enumElements[0]->v); registerEnumeratedOutputSymbol(buf2, buf1, &(internalEnumeratedSymbols.getElement(internalEnumeratedSymbols.getSize() - 1))); if (errorHandler.errorsOccurred) { errorHandler.error("XabslEngine::createOptionGraph(): could not register internal enumerated symbol \"%s\"",buf2); return; } break; } } // the total number of options in the intermediate code int numberOfOptions = (int)input.readValue(); // create empty options for (i=0; i< numberOfOptions; i++) { input.readString(buf1,99); options.append(buf1,new Option(buf1,input,errorHandler,*this,pTimeFunction,i)); if (errorHandler.errorsOccurred) { errorHandler.error("XabslEngine::createOptionGraph(): could not create option \"%s\"",options[i]->n); return; } } XABSL_DEBUG_INIT(errorHandler.message("registered %i options",numberOfOptions)); // create the options and its states for (i=0; i< numberOfOptions; i++) { XABSL_DEBUG_INIT(errorHandler.message("creating option \"%s\"",options[i]->n)); options[i]->create(input,options,basicBehaviors,*this,agentPriority,synchronizationTicks); if (errorHandler.errorsOccurred) { errorHandler.error("XabslEngine::createOptionGraph(): could not create option \"%s\"",options[i]->n); return; } } // create the agents int numberOfAgents = (int)input.readValue(); for (i=0; i< numberOfAgents; i++) { input.readString(buf1,99); input.readString(buf2,99); agents.append(buf1,new Agent(buf1,options[buf2],errorHandler, i)); } // check for loops in the option graph for (i=0;i<agents.getSize();i++) { if (Option* option = dynamic_cast<Option*>(agents[i]->getRootOption())) { Option* currentOptionPath[1000]; currentOptionPath[0] = option; // call recursively the checkForLoops function if (checkForLoops(currentOptionPath,0)) { errorHandler.error("createOptionGraph(): The created option graph contains loops"); }; } } // create array of cooperating states for (i=0;i<options.getSize();i++) for (int j=0;j<options[i]->states.getSize();j++) if (CoopState* state = dynamic_cast<CoopState*>(options[i]->states[j])) coopStates.append(state); selectedAgent = agents[0]; setRootAction(); XABSL_DEBUG_INIT(errorHandler.message("selected agent: \"%s\"",selectedAgent->n)); input.close(); initialized = true; }