>xabsl   The Extensible Agent Behavior Specification Language
   start  | team  | language reference  | tools  | xabsl engine  | download  | licence 

XabslEngine Class Library Reference

 
Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members

XabslEnumeratedExpression.cpp

Go to the documentation of this file.
00001 /** 
00002 * @file XabslEnumeratedExpression.cpp
00003 *
00004 * Implementation of EnumeratedExpression and derivates
00005 * 
00006 * @author <a href="http://www.sim.informatik.tu-darmstadt.de/pers/card/risler.html">Max Risler</a>
00007 */
00008 
00009 #include "XabslEnumeratedExpression.h"
00010 #include "XabslOption.h"
00011 
00012 namespace xabsl 
00013 {
00014   
00015 EnumeratedExpression::~EnumeratedExpression()
00016 {
00017 }
00018 
00019 EnumeratedExpression* EnumeratedExpression::create(const Enumeration* enumeration,
00020                                                          InputSource& input, 
00021                                                          ErrorHandler& errorHandler,
00022                                                          Symbols& symbols,
00023                                                          Option& option,
00024                                                          State& state)
00025 {
00026   char c[2];
00027   input.readString(c,1);
00028   
00029   switch (*c)
00030   {
00031   case 'v':
00032     return new EnumeratedValue(enumeration, input,errorHandler);
00033   case 'p':
00034     return new EnumeratedOptionParameterRef(enumeration, input,errorHandler,option);
00035   case 'i':
00036     return new EnumeratedInputSymbolRef(enumeration, input,errorHandler,symbols,option,state);
00037   case 'o':
00038     return new EnumeratedOutputSymbolRef(enumeration, input,errorHandler,symbols);
00039   case 'q':
00040     return new ConditionalEnumeratedExpression(enumeration, input,errorHandler,symbols,option,state);
00041   default:
00042     errorHandler.error("XabslEnumeratedExpression::create(): unknown expression type \"%c\"",*c);
00043   }
00044   return 0;
00045 }
00046 
00047 bool EnumeratedExpression::createOperand(const EnumeratedExpression*& operand,
00048                                             const Enumeration* enumeration,
00049                                             InputSource& input, 
00050                                             ErrorHandler& errorHandler,
00051                                             Symbols& symbols,
00052                                             Option& option,
00053                                             State& state)
00054 {
00055   operand = EnumeratedExpression::create(enumeration,input,errorHandler,symbols,option,state);
00056   
00057   if (operand == 0) 
00058   {
00059     errorHandler.error("XabslEnumeratedExpression::createOperand(): created operand is 0");
00060     return false;
00061   }
00062   
00063   if (errorHandler.errorsOccurred)
00064   {
00065     errorHandler.error("XabslEnumeratedExpression::createOperand(): could not create operand");
00066     if (operand != 0) delete operand;
00067     return false;
00068   }
00069   
00070   return true;
00071 }
00072 
00073 EnumeratedValue::EnumeratedValue(const Enumeration* enumeration,
00074                                        InputSource& input, 
00075                                        ErrorHandler& errorHandler)
00076 {
00077   char buf[100];
00078   input.readString(buf,99);
00079 
00080   if (enumeration == NULL)
00081   {
00082     errorHandler.error("XabslEnumeratedValue::EnumeratedValue(): enumerated value can not be created without specifying enumeration");
00083     return;
00084   }
00085 
00086   if (!enumeration->enumElements.exists(buf))
00087   {
00088     errorHandler.error("XabslEnumeratedValue::EnumeratedValue(): enum element \"%s\" of enumeration \"%s\" was not registered", buf, enumeration->n);
00089     return;
00090   }
00091   
00092   value = enumeration->enumElements[buf]->v;
00093   this->enumeration = enumeration;
00094 }
00095 
00096 int EnumeratedValue::getValue() const
00097 {
00098   return value;
00099 }
00100 
00101 EnumeratedOptionParameterRef::EnumeratedOptionParameterRef(const Enumeration* enumeration,
00102                                                    InputSource& input, 
00103                                                    ErrorHandler& errorHandler,
00104                                                    Option& option)
00105 {
00106   char buf[100];
00107   input.readString(buf,99);
00108   
00109   XABSL_DEBUG_INIT(errorHandler.message("creating a reference to enumerated option parameter \"%s\"",buf));
00110   
00111   if (!option.parameters->enumerated.exists(buf))
00112   {
00113     errorHandler.error("XabslEnumeratedOptionParameterRef::EnumeratedOptionParameterRef(): enumerated option parameter \"%s\" does not exist",buf);
00114     return;
00115   }
00116   
00117   parameter = option.parameters->enumerated.getPElement(buf)->e;
00118   this->enumeration = option.parameters->enumerations[buf];
00119   if (enumeration != NULL && enumeration != this->enumeration)
00120   {
00121     errorHandler.error("XabslEnumeratedOptionParameterRef::EnumeratedOptionParameterRef(): enumeration input symbol \"%s\" does not match enumeration type \"%s\"", buf, enumeration->n);
00122   }
00123 }
00124 
00125 int EnumeratedOptionParameterRef::getValue() const
00126 {
00127   return *parameter;
00128 }
00129 
00130 EnumeratedInputSymbolRef::EnumeratedInputSymbolRef(const Enumeration* enumeration,
00131                                                                InputSource& input, 
00132                                                                ErrorHandler& errorHandler,
00133                                                                Symbols& symbols,
00134                                                                Option& option,
00135                                                                State& state) :
00136   symbol(0), parameters(0)
00137 {
00138   char buf[100];
00139   input.readString(buf,99);
00140   
00141   XABSL_DEBUG_INIT(errorHandler.message("creating reference to enumerated input symbol \"%s\"",buf));
00142   
00143   if (!symbols.enumeratedInputSymbols.exists(buf))
00144   {
00145     errorHandler.error("XabslEnumeratedInputSymbolRef::XabslEnumeratedInputSymbolRef(): enumerated input symbol \"%s\" was not registered at the engine",buf);
00146     return;
00147   }
00148   
00149   symbol = symbols.enumeratedInputSymbols[buf];
00150   this->enumeration = symbol->enumeration;
00151 
00152   if (enumeration != NULL && enumeration != this->enumeration)
00153   {
00154     errorHandler.error("XabslEnumeratedInputSymbolRef::XabslEnumeratedInputSymbolRef(): enumeration input symbol \"%s\" does not match enumeration type \"%s\"", buf, enumeration->n);
00155   }
00156 
00157   parameters = new ParameterAssignment(&symbol->parameters, errorHandler);
00158 
00159   parameters->create(input, symbols, option, state);
00160 }
00161   
00162 EnumeratedInputSymbolRef::~EnumeratedInputSymbolRef()
00163 {
00164   if (parameters != 0)
00165     delete parameters;
00166 }
00167 
00168 int EnumeratedInputSymbolRef::getValue() const
00169 {
00170   // set the symbol parameters
00171   if (parameters->set())
00172     symbol->parametersChanged();
00173 
00174   return symbol->getValue();
00175 }
00176 
00177 EnumeratedOutputSymbolRef::EnumeratedOutputSymbolRef(const Enumeration* enumeration,
00178                                                                InputSource& input, 
00179                                                                ErrorHandler& errorHandler,
00180                                                                Symbols& symbols)
00181 {
00182   char buf[100];
00183   input.readString(buf,99);
00184   
00185   XABSL_DEBUG_INIT(errorHandler.message("creating a reference to an enumerated output symbol \"%s\"",buf));
00186   
00187   if (!symbols.enumeratedOutputSymbols.exists(buf))
00188   {
00189     errorHandler.error("XabslEnumeratedOutputSymbolRef::EnumeratedOutputSymbolRef(): enumerated output symbol \"%s\" was not registered",buf);
00190     return;
00191   }
00192   
00193   symbol = symbols.enumeratedOutputSymbols[buf];
00194   this->enumeration = symbol->enumeration;
00195 
00196   if (enumeration != NULL && enumeration != this->enumeration)
00197   {
00198     errorHandler.error("XabslEnumeratedInputSymbolRef::XabslEnumeratedInputSymbolRef(): enumeration input symbol \"%s\" does not match enumeration type \"%s\"", buf, enumeration->n);
00199   }
00200 }
00201 
00202 int EnumeratedOutputSymbolRef::getValue() const
00203 {
00204   return symbol->getValue();
00205 }
00206 
00207 ConditionalEnumeratedExpression::ConditionalEnumeratedExpression(const Enumeration* enumeration,
00208     InputSource& input, 
00209     ErrorHandler& errorHandler,
00210     Symbols& symbols,
00211     Option& option,
00212     State& state)
00213 {
00214   XABSL_DEBUG_INIT(errorHandler.message("creating a question mark operator"));
00215 
00216   condition = BooleanExpression::create(input,errorHandler,symbols,option,state);
00217 
00218   if (condition == 0) 
00219   {
00220     errorHandler.error("XabslQuestionMarkOperator::QuestionMarkOperator(): created condition is 0");
00221     return;
00222   }
00223   else if (errorHandler.errorsOccurred)
00224   {
00225     errorHandler.error("XabslQuestionMarkOperator::QuestionMarkOperator(): could not create condition");
00226     delete condition;
00227     return;
00228   }
00229 
00230   if (!EnumeratedExpression::createOperand(expression1,enumeration,input,errorHandler,symbols,option,state))
00231   {
00232     errorHandler.error("XabslQuestionMarkOperator::QuestionMarkOperator(): could not create decimal expression1");
00233     return;
00234   }
00235   
00236   if (!EnumeratedExpression::createOperand(expression2,enumeration,input,errorHandler,symbols,option,state))
00237   {
00238     errorHandler.error("XabslQuestionMarkOperator::QuestionMarkOperator(): could not create decimal expression2");
00239     return;
00240   }
00241   this->enumeration = enumeration;
00242 }
00243 
00244 ConditionalEnumeratedExpression::~ConditionalEnumeratedExpression()
00245 {
00246   if (condition!=0) delete condition;
00247   if (expression1!=0) delete expression1;
00248   if (expression2!=0) delete expression2;
00249 }
00250 
00251 int ConditionalEnumeratedExpression::getValue() const
00252 {
00253   if (condition->getValue())
00254   {
00255     return expression1->getValue();
00256   }
00257   else
00258   {
00259     return expression2->getValue();
00260   }
00261 }
00262 
00263 } // namespace
00264

Up | Main Page | Generated at Wed Aug 19 17:32:29 2009.

 
Copyright 2002 - 2009 by the XABSL developer team. See the licence for details.