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;
}
