Andy Lustig / Mbed 2 deprecated perturbRoom

perturb room

Dependencies:   SMARTWAV mbed

Fork of stateScript by Mattias Karlsson

behave.cpp@5:4d6575e3a07e, 2015-05-18 (annotated)

Committer:
alustig3
Date:
Mon May 18 01:17:58 2015 +0000
Revision:
5:4d6575e3a07e
Parent:
4:34aca2142df9 
perturb room

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mkarlsso 2:298679fff37c 1 #include "behave.h"
mkarlsso 2:298679fff37c 2 #include <ctype.h>
mkarlsso 2:298679fff37c 3 #include <sstream>
mkarlsso 2:298679fff37c 4
mkarlsso 2:298679fff37c 5 // These external symbols are maintained by the linker to indicate the
mkarlsso 2:298679fff37c 6 // location of various regions in the device's memory. They will be used by
mkarlsso 2:298679fff37c 7 // DisplayRAMBanks() to dump the size of each RAM bank to stdout.
mkarlsso 2:298679fff37c 8 extern unsigned int Image$$RW_IRAM1$$Base;
mkarlsso 2:298679fff37c 9 extern unsigned int Image$$RW_IRAM1$$ZI$$Limit;
mkarlsso 2:298679fff37c 10 extern unsigned int Image$$RW_IRAM2$$Base;
mkarlsso 2:298679fff37c 11 extern unsigned int Image$$RW_IRAM2$$ZI$$Limit;
mkarlsso 2:298679fff37c 12 extern unsigned int Image$$RW_IRAM3$$Base;
mkarlsso 2:298679fff37c 13 extern unsigned int Image$$RW_IRAM3$$ZI$$Limit;
mkarlsso 2:298679fff37c 14
mkarlsso 2:298679fff37c 15 uint32_t* globalTimeKeeperPtr; //this is a pointer to the slave timer (do not change this directly)
mkarlsso 2:298679fff37c 16 extern eventQueue mainQueue;
mkarlsso 2:298679fff37c 17 extern digitalPort* portVector[];
mkarlsso 2:298679fff37c 18
mkarlsso 2:298679fff37c 19 extern Serial pc;
alustig3 5:4d6575e3a07e 20 extern Serial device; //ANDY
mkarlsso 2:298679fff37c 21 extern bool resetTimer;
mkarlsso 2:298679fff37c 22 extern bool clockSlave;
mkarlsso 2:298679fff37c 23 extern bool changeToSlave;
mkarlsso 2:298679fff37c 24 extern bool changeToStandAlone;
mkarlsso 2:298679fff37c 25 extern outputStream textDisplay;
mkarlsso 2:298679fff37c 26 extern int currentDIOstate[2];
mkarlsso 2:298679fff37c 27 extern bool broadCastStateChanges;
mkarlsso 2:298679fff37c 28 extern bool textStreaming;
mkarlsso 2:298679fff37c 29
mkarlsso 2:298679fff37c 30
mkarlsso 2:298679fff37c 31 //static pools of memory for each object type
mkarlsso 2:298679fff37c 32 extern event eventBlock[NUMEVENTS];
mkarlsso 2:298679fff37c 33 extern condition conditionBlock[NUMCONDITIONS];
mkarlsso 2:298679fff37c 34 extern intCompare intCompareBlock[NUMINTCOMPARE];
mkarlsso 2:298679fff37c 35 extern action actionBlock[NUMACTIONS];
mkarlsso 2:298679fff37c 36 extern portMessage portMessageBlock[NUMPORTMESSAGES];
mkarlsso 2:298679fff37c 37 extern intOperation intOperationBlock[NUMINTOPERATIONS];
mkarlsso 2:298679fff37c 38 extern displayAction displayActionBlock[NUMDISPLAYACTIONS];
mkarlsso 2:298679fff37c 39
mkarlsso 2:298679fff37c 40 //used to find the first available object in the staticly defined pools of memory
mkarlsso 2:298679fff37c 41 template<class T> T* findFirstUnUsed(T a[], const int arrayLength) {
mkarlsso 2:298679fff37c 42
mkarlsso 2:298679fff37c 43 T* returnPtr = NULL;
mkarlsso 2:298679fff37c 44 for (int i = 0; i < arrayLength; i++) {
mkarlsso 2:298679fff37c 45 if (!a[i].isUsed) {
mkarlsso 2:298679fff37c 46 returnPtr = &a[i];
mkarlsso 2:298679fff37c 47 break;
mkarlsso 2:298679fff37c 48 }
mkarlsso 2:298679fff37c 49 }
mkarlsso 2:298679fff37c 50 return returnPtr;
mkarlsso 2:298679fff37c 51 }
mkarlsso 2:298679fff37c 52
mkarlsso 2:298679fff37c 53 //used to count the number of available objects in the memory pool
mkarlsso 2:298679fff37c 54 template<class T> int countUnUsed(T a[], const int arrayLength) {
mkarlsso 2:298679fff37c 55
mkarlsso 2:298679fff37c 56 int count = 0;
mkarlsso 2:298679fff37c 57 for (int i = 0; i < arrayLength; i++) {
mkarlsso 2:298679fff37c 58 if (!a[i].isUsed) {
mkarlsso 2:298679fff37c 59 count++;
mkarlsso 2:298679fff37c 60 }
mkarlsso 2:298679fff37c 61 }
mkarlsso 2:298679fff37c 62 return count;
mkarlsso 2:298679fff37c 63 }
mkarlsso 2:298679fff37c 64
mkarlsso 2:298679fff37c 65
mkarlsso 2:298679fff37c 66 void displayMemoryLeft(void) {
mkarlsso 2:298679fff37c 67 pc.printf("Available slots left in memory\r\n");
mkarlsso 2:298679fff37c 68 pc.printf(" Blocks: %d\r\n", countUnUsed(eventBlock, NUMEVENTS));
mkarlsso 2:298679fff37c 69 pc.printf(" Condition containers: %d\r\n", countUnUsed(conditionBlock, NUMCONDITIONS));
mkarlsso 2:298679fff37c 70 pc.printf(" Int compare conditions: %d\r\n", countUnUsed(intCompareBlock, NUMINTCOMPARE));
mkarlsso 2:298679fff37c 71 pc.printf(" Command containers: %d\r\n", countUnUsed(actionBlock, NUMACTIONS));
mkarlsso 2:298679fff37c 72 pc.printf(" Port commands: %d\r\n", countUnUsed(portMessageBlock, NUMPORTMESSAGES));
mkarlsso 2:298679fff37c 73 pc.printf(" Integer operater commands: %d\r\n", countUnUsed(intOperationBlock, NUMINTOPERATIONS));
mkarlsso 2:298679fff37c 74 pc.printf(" Text display commands: %d\r\n", countUnUsed(displayActionBlock, NUMDISPLAYACTIONS));
mkarlsso 2:298679fff37c 75 }
mkarlsso 2:298679fff37c 76
mkarlsso 2:298679fff37c 77 // Displays the size of static allocations for each RAM bank as indicated by
mkarlsso 2:298679fff37c 78 // ARM linker to stdout.
mkarlsso 2:298679fff37c 79 static void DisplayRAMBanks(void) {
mkarlsso 2:298679fff37c 80
mkarlsso 2:298679fff37c 81 pc.printf("Static RAM bank allocations\r\n");
mkarlsso 2:298679fff37c 82 pc.printf(" Main RAM = %u\r\n", (unsigned int)&Image$$RW_IRAM1$$ZI$$Limit -
mkarlsso 2:298679fff37c 83 (unsigned int)&Image$$RW_IRAM1$$Base);
mkarlsso 2:298679fff37c 84 pc.printf(" RAM0 = %u\r\n", (unsigned int)&Image$$RW_IRAM2$$ZI$$Limit -
mkarlsso 2:298679fff37c 85 (unsigned int)&Image$$RW_IRAM2$$Base);
mkarlsso 2:298679fff37c 86 pc.printf(" RAM1 = %u\r\n", (unsigned int)&Image$$RW_IRAM3$$ZI$$Limit -
mkarlsso 2:298679fff37c 87 (unsigned int)&Image$$RW_IRAM3$$Base);
mkarlsso 2:298679fff37c 88 }
mkarlsso 2:298679fff37c 89
mkarlsso 2:298679fff37c 90
mkarlsso 2:298679fff37c 91 bool isNumber(const std::string& s) {
mkarlsso 2:298679fff37c 92 std::string::const_iterator it = s.begin();
mkarlsso 2:298679fff37c 93 while (it != s.end() && isdigit(*it)) ++it;
mkarlsso 2:298679fff37c 94 return !s.empty() && it == s.end();
mkarlsso 2:298679fff37c 95 }
mkarlsso 2:298679fff37c 96
mkarlsso 2:298679fff37c 97 void tokenize(const string& str,
mkarlsso 2:298679fff37c 98 vector<string>& tokens,
mkarlsso 2:298679fff37c 99 const string& delimiters = " ")
mkarlsso 2:298679fff37c 100 {
mkarlsso 2:298679fff37c 101 // Skip delimiters at beginning.
mkarlsso 2:298679fff37c 102 string::size_type lastPos = str.find_first_not_of(delimiters, 0);
mkarlsso 2:298679fff37c 103 // Find first "non-delimiter".
mkarlsso 2:298679fff37c 104 string::size_type pos = str.find_first_of(delimiters, lastPos);
mkarlsso 2:298679fff37c 105
mkarlsso 2:298679fff37c 106 while (string::npos != pos || string::npos != lastPos)
mkarlsso 2:298679fff37c 107 {
mkarlsso 2:298679fff37c 108 // Found a token, add it to the vector.
mkarlsso 2:298679fff37c 109 tokens.push_back(str.substr(lastPos, pos - lastPos));
mkarlsso 2:298679fff37c 110 // Skip delimiters. Note the "not_of"
mkarlsso 2:298679fff37c 111 lastPos = str.find_first_not_of(delimiters, pos);
mkarlsso 2:298679fff37c 112 // Find next "non-delimiter"
mkarlsso 2:298679fff37c 113 pos = str.find_first_of(delimiters, lastPos);
mkarlsso 2:298679fff37c 114 }
mkarlsso 2:298679fff37c 115 }
mkarlsso 2:298679fff37c 116
mkarlsso 2:298679fff37c 117
mkarlsso 2:298679fff37c 118 digitalPort::digitalPort(DigitalOut* DOP, DigitalIn* DIP):
mkarlsso 2:298679fff37c 119 outPin(DOP),
mkarlsso 2:298679fff37c 120 inPin(DIP),
mkarlsso 2:298679fff37c 121 outState(0){
mkarlsso 2:298679fff37c 122
mkarlsso 2:298679fff37c 123 lastInState = getDigitalIn();
mkarlsso 2:298679fff37c 124 inState = getDigitalIn();
mkarlsso 2:298679fff37c 125 lastChangeTime = 0;
mkarlsso 2:298679fff37c 126 lastOutChangeTime = 0;
mkarlsso 2:298679fff37c 127 lastChangeInterval = 0;
mkarlsso 2:298679fff37c 128 lastDownEvent.triggered = false;
mkarlsso 2:298679fff37c 129 lastUpEvent.triggered = false;
mkarlsso 2:298679fff37c 130 triggerUpEventPtr = NULL;
mkarlsso 2:298679fff37c 131 triggerDownEventPtr = NULL;
mkarlsso 2:298679fff37c 132 outStateChanged = false;
mkarlsso 2:298679fff37c 133 }
alustig3 5:4d6575e3a07e 134 digitalPort::digitalPort(DigitalOut* DOP): //added by me
alustig3 5:4d6575e3a07e 135 outPin(DOP),
alustig3 5:4d6575e3a07e 136 outState(0){
alustig3 5:4d6575e3a07e 137
alustig3 5:4d6575e3a07e 138 lastChangeTime = 0;
alustig3 5:4d6575e3a07e 139 lastOutChangeTime = 0;
alustig3 5:4d6575e3a07e 140 lastChangeInterval = 0;
alustig3 5:4d6575e3a07e 141 lastDownEvent.triggered = false;
alustig3 5:4d6575e3a07e 142 lastUpEvent.triggered = false;
alustig3 5:4d6575e3a07e 143 triggerUpEventPtr = NULL;
alustig3 5:4d6575e3a07e 144 triggerDownEventPtr = NULL;
alustig3 5:4d6575e3a07e 145 outStateChanged = false;
alustig3 5:4d6575e3a07e 146 }
mkarlsso 2:298679fff37c 147
mkarlsso 2:298679fff37c 148 void digitalPort::setTriggerUpEvent(event* eventInput) {
mkarlsso 2:298679fff37c 149 if (triggerUpEventPtr != NULL) {
mkarlsso 2:298679fff37c 150 //delete triggerUpEventPtr;
mkarlsso 2:298679fff37c 151 triggerUpEventPtr->release();
mkarlsso 2:298679fff37c 152 }
mkarlsso 2:298679fff37c 153 triggerUpEventPtr = eventInput;
mkarlsso 2:298679fff37c 154 }
mkarlsso 2:298679fff37c 155
mkarlsso 2:298679fff37c 156 void digitalPort::setTriggerDownEvent(event* eventInput) {
mkarlsso 2:298679fff37c 157 if (triggerDownEventPtr != NULL) {
mkarlsso 2:298679fff37c 158 //delete triggerDownEventPtr;
mkarlsso 2:298679fff37c 159 triggerDownEventPtr->release();
mkarlsso 2:298679fff37c 160
mkarlsso 2:298679fff37c 161 }
mkarlsso 2:298679fff37c 162 triggerDownEventPtr = eventInput;
mkarlsso 2:298679fff37c 163 }
mkarlsso 2:298679fff37c 164
mkarlsso 2:298679fff37c 165
mkarlsso 2:298679fff37c 166 int digitalPort::getDigitalIn() {
mkarlsso 2:298679fff37c 167 return inPin->read();
mkarlsso 2:298679fff37c 168 }
mkarlsso 2:298679fff37c 169
mkarlsso 2:298679fff37c 170
mkarlsso 2:298679fff37c 171 void digitalPort::setDigitalOut(int outVal) {
mkarlsso 2:298679fff37c 172 if (outVal == -1) {
mkarlsso 2:298679fff37c 173 outVal = 1-outState;
mkarlsso 2:298679fff37c 174 }
mkarlsso 2:298679fff37c 175 outPin->write(outVal);
mkarlsso 2:298679fff37c 176 if (outState != outVal) {
mkarlsso 2:298679fff37c 177 outStateChanged = true;
mkarlsso 2:298679fff37c 178 lastOutChangeTime = *globalTimeKeeperPtr;
mkarlsso 2:298679fff37c 179 }
mkarlsso 2:298679fff37c 180 outState = outVal;
mkarlsso 2:298679fff37c 181 }
mkarlsso 2:298679fff37c 182
mkarlsso 2:298679fff37c 183 //called when a digital in gets triggered
mkarlsso 2:298679fff37c 184 void digitalPort::addStateChange(int newState, uint32_t timeStamp) {
mkarlsso 2:298679fff37c 185
mkarlsso 2:298679fff37c 186 if ((newState == 0) && (!lastDownEvent.triggered)){
mkarlsso 2:298679fff37c 187 lastDownEvent.timeStamp = timeStamp;
mkarlsso 2:298679fff37c 188 lastDownEvent.triggered = true;
mkarlsso 2:298679fff37c 189 } else if ((newState == 1) && (!lastUpEvent.triggered)) {
mkarlsso 2:298679fff37c 190 lastUpEvent.timeStamp = timeStamp;
mkarlsso 2:298679fff37c 191 lastUpEvent.triggered = true;
mkarlsso 2:298679fff37c 192 }
mkarlsso 2:298679fff37c 193 }
mkarlsso 2:298679fff37c 194
mkarlsso 2:298679fff37c 195 bool digitalPort::update() {
mkarlsso 2:298679fff37c 196
mkarlsso 2:298679fff37c 197 bool changed = false;
mkarlsso 2:298679fff37c 198 if ((*globalTimeKeeperPtr - lastChangeTime) > 1) { //prevents flutter triggers when button is pressed
mkarlsso 2:298679fff37c 199 inState = getDigitalIn();
mkarlsso 2:298679fff37c 200 changed = (lastInState != inState);
mkarlsso 2:298679fff37c 201 if (changed) {
mkarlsso 2:298679fff37c 202 if (inState == 1) {
mkarlsso 2:298679fff37c 203 if (lastUpEvent.triggered) {
mkarlsso 2:298679fff37c 204 //there were hardware triggered since the last main loop. We use that time
mkarlsso 2:298679fff37c 205 lastChangeInterval = lastUpEvent.timeStamp - lastChangeTime;
mkarlsso 2:298679fff37c 206 lastChangeTime = lastUpEvent.timeStamp;
mkarlsso 2:298679fff37c 207 } else {
mkarlsso 2:298679fff37c 208 //otherwise we use the current time
mkarlsso 2:298679fff37c 209 lastChangeInterval = *globalTimeKeeperPtr - lastChangeTime;
mkarlsso 2:298679fff37c 210 lastChangeTime = *globalTimeKeeperPtr;
mkarlsso 2:298679fff37c 211 }
mkarlsso 2:298679fff37c 212 if (triggerUpEventPtr != NULL) {triggerUpEventPtr->execute();}
mkarlsso 2:298679fff37c 213 } else if (inState == 0) {
mkarlsso 2:298679fff37c 214 if (lastDownEvent.triggered) {
mkarlsso 2:298679fff37c 215 lastChangeInterval = lastDownEvent.timeStamp - lastChangeTime;
mkarlsso 2:298679fff37c 216 lastChangeTime = lastDownEvent.timeStamp;
mkarlsso 2:298679fff37c 217 } else {
mkarlsso 2:298679fff37c 218 lastChangeInterval = *globalTimeKeeperPtr - lastChangeTime;
mkarlsso 2:298679fff37c 219 lastChangeTime = *globalTimeKeeperPtr;
mkarlsso 2:298679fff37c 220 }
mkarlsso 2:298679fff37c 221 if (triggerDownEventPtr != NULL) {triggerDownEventPtr->execute();}
mkarlsso 2:298679fff37c 222 }
mkarlsso 2:298679fff37c 223
mkarlsso 2:298679fff37c 224 }
mkarlsso 2:298679fff37c 225
mkarlsso 2:298679fff37c 226 lastInState = inState;
mkarlsso 2:298679fff37c 227
mkarlsso 2:298679fff37c 228 }
mkarlsso 2:298679fff37c 229 lastUpEvent.triggered = false;
mkarlsso 2:298679fff37c 230 lastDownEvent.triggered = false;
mkarlsso 2:298679fff37c 231 return changed;
mkarlsso 2:298679fff37c 232 }
mkarlsso 2:298679fff37c 233
mkarlsso 2:298679fff37c 234 int digitalPort::getLastChangeState() {
mkarlsso 2:298679fff37c 235 return lastInState;
mkarlsso 2:298679fff37c 236 }
mkarlsso 2:298679fff37c 237 uint32_t digitalPort::getTimeSinceLastChange() {
mkarlsso 2:298679fff37c 238 return lastChangeInterval;
mkarlsso 2:298679fff37c 239
mkarlsso 2:298679fff37c 240 }
mkarlsso 2:298679fff37c 241
mkarlsso 2:298679fff37c 242 intVariable::intVariable():
mkarlsso 2:298679fff37c 243 value(0),
mkarlsso 2:298679fff37c 244 tag(string("--------------------")) {
mkarlsso 2:298679fff37c 245 isUsed = false;
mkarlsso 2:298679fff37c 246 }
mkarlsso 2:298679fff37c 247
mkarlsso 2:298679fff37c 248 intVariable::intVariable(string tagInput, int initialValue):
mkarlsso 2:298679fff37c 249 value(initialValue),
mkarlsso 2:298679fff37c 250 tag(string(tagInput)) {
mkarlsso 2:298679fff37c 251 isUsed = true;
mkarlsso 2:298679fff37c 252 }
mkarlsso 2:298679fff37c 253
mkarlsso 2:298679fff37c 254 void intVariable::set(string tagInput, int initialValue) {
mkarlsso 2:298679fff37c 255 value = initialValue;
mkarlsso 2:298679fff37c 256 tag = string(tagInput);
mkarlsso 2:298679fff37c 257 isUsed = true;
mkarlsso 2:298679fff37c 258 }
mkarlsso 2:298679fff37c 259
mkarlsso 2:298679fff37c 260 displayAction::displayAction():
mkarlsso 2:298679fff37c 261 dText(string("--------------------------------------------------")),
mkarlsso 2:298679fff37c 262 pcPtr(NULL) {
mkarlsso 2:298679fff37c 263 dVariable = NULL;
mkarlsso 2:298679fff37c 264 isUsed = false;
mkarlsso 2:298679fff37c 265 }
mkarlsso 2:298679fff37c 266
mkarlsso 2:298679fff37c 267 void displayAction::release() {
mkarlsso 2:298679fff37c 268 dText = "--------------------------------------------------";
mkarlsso 2:298679fff37c 269 pcPtr = NULL;
mkarlsso 2:298679fff37c 270 dVariable = NULL;
mkarlsso 2:298679fff37c 271 isUsed = false;
mkarlsso 2:298679fff37c 272 }
mkarlsso 2:298679fff37c 273
mkarlsso 2:298679fff37c 274 displayAction::displayAction(int* variable, string varNameInput, Serial* pcPtrInput):
mkarlsso 2:298679fff37c 275 dVariable(variable),
mkarlsso 2:298679fff37c 276 dText(varNameInput),
mkarlsso 2:298679fff37c 277 pcPtr(pcPtrInput) {
mkarlsso 2:298679fff37c 278 isUsed = true;
mkarlsso 2:298679fff37c 279
mkarlsso 2:298679fff37c 280 }
mkarlsso 2:298679fff37c 281
mkarlsso 2:298679fff37c 282 displayAction::displayAction(string text, Serial* pcPtrInput):
mkarlsso 2:298679fff37c 283 dText(text),
mkarlsso 2:298679fff37c 284 pcPtr(pcPtrInput) {
mkarlsso 2:298679fff37c 285 dVariable = NULL;
mkarlsso 2:298679fff37c 286 isUsed = true;
mkarlsso 2:298679fff37c 287 }
mkarlsso 2:298679fff37c 288
mkarlsso 2:298679fff37c 289 void displayAction::set(int* variable, string varNameInput, Serial* pcPtrInput) {
mkarlsso 2:298679fff37c 290 dVariable = variable;
mkarlsso 2:298679fff37c 291 dText = varNameInput;
mkarlsso 2:298679fff37c 292 pcPtr = pcPtrInput;
mkarlsso 2:298679fff37c 293 isUsed = true;
mkarlsso 2:298679fff37c 294
mkarlsso 2:298679fff37c 295 }
mkarlsso 2:298679fff37c 296
mkarlsso 2:298679fff37c 297 void displayAction::set(string text, Serial* pcPtrInput) {
mkarlsso 2:298679fff37c 298 dText = text;
mkarlsso 2:298679fff37c 299 pcPtr = pcPtrInput;
mkarlsso 2:298679fff37c 300 dVariable = NULL;
mkarlsso 2:298679fff37c 301 isUsed = true;
mkarlsso 2:298679fff37c 302 }
mkarlsso 2:298679fff37c 303
mkarlsso 2:298679fff37c 304 void displayAction::execute() {
mkarlsso 2:298679fff37c 305
mkarlsso 2:298679fff37c 306 ostringstream convert; // stream used for the conversion
mkarlsso 2:298679fff37c 307 convert << *globalTimeKeeperPtr; // insert the textual representation of 'Number' in the characters in the stream
mkarlsso 2:298679fff37c 308
mkarlsso 2:298679fff37c 309 if (dVariable != NULL) {
mkarlsso 2:298679fff37c 310 ostringstream varConvert;
mkarlsso 2:298679fff37c 311 varConvert << *dVariable;
mkarlsso 2:298679fff37c 312 //pcPtr->printf("%d %s = %d\r\n",*globalTimeKeeperPtr, dText.data(),*dVariable);
mkarlsso 2:298679fff37c 313 textDisplay.send(convert.str() + " " + dText + " = " + varConvert.str() + "\r\n");
mkarlsso 2:298679fff37c 314 } else {
mkarlsso 2:298679fff37c 315 //pcPtr->printf("%d %s\r\n",*globalTimeKeeperPtr, dText.data());
mkarlsso 2:298679fff37c 316 textDisplay.send(convert.str() + " " + dText + "\r\n");
mkarlsso 2:298679fff37c 317
mkarlsso 2:298679fff37c 318 }
mkarlsso 2:298679fff37c 319 }
mkarlsso 2:298679fff37c 320
mkarlsso 2:298679fff37c 321 intCompare::intCompare():
mkarlsso 2:298679fff37c 322 port(NULL) {
mkarlsso 2:298679fff37c 323 cmpVal = NULL;
mkarlsso 2:298679fff37c 324 cmpValGlobal = false;
mkarlsso 2:298679fff37c 325 intVal = NULL;
mkarlsso 2:298679fff37c 326 intOp = NULL;
mkarlsso 2:298679fff37c 327 portValPtr = NULL;
mkarlsso 2:298679fff37c 328 isUsed = false;
mkarlsso 2:298679fff37c 329
mkarlsso 2:298679fff37c 330 }
mkarlsso 2:298679fff37c 331 intCompare::intCompare(digitalPort* portInput, const char* cmpString, int cmpValInput, int whichToUse):
mkarlsso 2:298679fff37c 332 port(portInput) {
mkarlsso 2:298679fff37c 333 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 334 cmpValGlobal = false;
mkarlsso 2:298679fff37c 335 intVal = NULL;
mkarlsso 2:298679fff37c 336 intOp = NULL;
mkarlsso 2:298679fff37c 337 setPointer(cmpString);
mkarlsso 2:298679fff37c 338 isUsed = true;
mkarlsso 2:298679fff37c 339 if (whichToUse == 1) {
mkarlsso 2:298679fff37c 340 portValPtr = &port->inState;
mkarlsso 2:298679fff37c 341 } else {
mkarlsso 2:298679fff37c 342 portValPtr = &port->outState;
mkarlsso 2:298679fff37c 343 }
mkarlsso 2:298679fff37c 344 }
mkarlsso 2:298679fff37c 345
mkarlsso 2:298679fff37c 346 intCompare::intCompare(digitalPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse):
mkarlsso 2:298679fff37c 347 port(portInput),
mkarlsso 2:298679fff37c 348 cmpVal(cmpIntVarInput) {
mkarlsso 2:298679fff37c 349 cmpValGlobal = true;
mkarlsso 2:298679fff37c 350 intVal = NULL;
mkarlsso 2:298679fff37c 351 intOp = NULL;
mkarlsso 2:298679fff37c 352 setPointer(cmpString);
mkarlsso 2:298679fff37c 353 isUsed = true;
mkarlsso 2:298679fff37c 354 if (whichToUse == 1) {
mkarlsso 2:298679fff37c 355 portValPtr = &port->inState;
mkarlsso 2:298679fff37c 356 } else {
mkarlsso 2:298679fff37c 357 portValPtr = &port->outState;
mkarlsso 2:298679fff37c 358 }
mkarlsso 2:298679fff37c 359 }
mkarlsso 2:298679fff37c 360
mkarlsso 2:298679fff37c 361 intCompare::intCompare(int* intVarInput, const char* cmpString, int* cmpIntVarInput):
mkarlsso 2:298679fff37c 362 cmpVal(cmpIntVarInput),
mkarlsso 2:298679fff37c 363 intVal(intVarInput) {
mkarlsso 2:298679fff37c 364 cmpValGlobal = true;
mkarlsso 2:298679fff37c 365 port = NULL;
mkarlsso 2:298679fff37c 366 intOp = NULL;
mkarlsso 2:298679fff37c 367 portValPtr = NULL;
mkarlsso 2:298679fff37c 368 isUsed = true;
mkarlsso 2:298679fff37c 369 setPointer(cmpString);
mkarlsso 2:298679fff37c 370 }
mkarlsso 2:298679fff37c 371
mkarlsso 2:298679fff37c 372 intCompare::intCompare(int* intVarInput, const char* cmpString, int cmpValInput):
mkarlsso 2:298679fff37c 373 intVal(intVarInput){
mkarlsso 2:298679fff37c 374 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 375 cmpValGlobal = false;
mkarlsso 2:298679fff37c 376 port = NULL;
mkarlsso 2:298679fff37c 377 intOp = NULL;
mkarlsso 2:298679fff37c 378 portValPtr = NULL;
mkarlsso 2:298679fff37c 379 isUsed = true;
mkarlsso 2:298679fff37c 380 setPointer(cmpString);
mkarlsso 2:298679fff37c 381 }
mkarlsso 2:298679fff37c 382
mkarlsso 2:298679fff37c 383 intCompare::intCompare(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput):
mkarlsso 2:298679fff37c 384 intVal(intVarInput) {
mkarlsso 2:298679fff37c 385 cmpVal = NULL;
mkarlsso 2:298679fff37c 386 port = NULL;
mkarlsso 2:298679fff37c 387 portValPtr = NULL;
mkarlsso 2:298679fff37c 388 cmpValGlobal = true;
mkarlsso 2:298679fff37c 389 intOp = cmpIntOpInput;
mkarlsso 2:298679fff37c 390 isUsed = true;
mkarlsso 2:298679fff37c 391 setPointer_operation(cmpString);
mkarlsso 2:298679fff37c 392 }
mkarlsso 2:298679fff37c 393
mkarlsso 2:298679fff37c 394 intCompare::intCompare(digitalPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse):
mkarlsso 2:298679fff37c 395 port(portInput) {
mkarlsso 2:298679fff37c 396 cmpVal = NULL;
mkarlsso 2:298679fff37c 397 intVal = NULL;
mkarlsso 2:298679fff37c 398 cmpValGlobal = true;
mkarlsso 2:298679fff37c 399 intOp = cmpIntOpInput;
mkarlsso 2:298679fff37c 400 setPointer_operation(cmpString);
mkarlsso 2:298679fff37c 401 isUsed = true;
mkarlsso 2:298679fff37c 402 if (whichToUse == 1) {
mkarlsso 2:298679fff37c 403 portValPtr = &port->inState;
mkarlsso 2:298679fff37c 404 } else {
mkarlsso 2:298679fff37c 405 portValPtr = &port->outState;
mkarlsso 2:298679fff37c 406 }
mkarlsso 2:298679fff37c 407 }
mkarlsso 2:298679fff37c 408
mkarlsso 2:298679fff37c 409
mkarlsso 2:298679fff37c 410
mkarlsso 2:298679fff37c 411 void intCompare::set(digitalPort* portInput, const char* cmpString, int cmpValInput, int whichToUse) {
mkarlsso 2:298679fff37c 412 port = portInput;
mkarlsso 2:298679fff37c 413 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 414 cmpValGlobal = false;
mkarlsso 2:298679fff37c 415 intVal = NULL;
mkarlsso 2:298679fff37c 416 intOp = NULL;
mkarlsso 2:298679fff37c 417 setPointer(cmpString);
mkarlsso 2:298679fff37c 418 isUsed = true;
mkarlsso 2:298679fff37c 419 if (whichToUse == 1) {
mkarlsso 2:298679fff37c 420 portValPtr = &port->inState;
mkarlsso 2:298679fff37c 421 } else {
mkarlsso 2:298679fff37c 422 portValPtr = &port->outState;
mkarlsso 2:298679fff37c 423 }
mkarlsso 2:298679fff37c 424 }
mkarlsso 2:298679fff37c 425
mkarlsso 2:298679fff37c 426 void intCompare::set(digitalPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse) {
mkarlsso 2:298679fff37c 427 port = portInput;
mkarlsso 2:298679fff37c 428 cmpVal = cmpIntVarInput;
mkarlsso 2:298679fff37c 429 cmpValGlobal = true;
mkarlsso 2:298679fff37c 430 intVal = NULL;
mkarlsso 2:298679fff37c 431 intOp = NULL;
mkarlsso 2:298679fff37c 432 setPointer(cmpString);
mkarlsso 2:298679fff37c 433 isUsed = true;
mkarlsso 2:298679fff37c 434 if (whichToUse == 1) {
mkarlsso 2:298679fff37c 435 portValPtr = &port->inState;
mkarlsso 2:298679fff37c 436 } else {
mkarlsso 2:298679fff37c 437 portValPtr = &port->outState;
mkarlsso 2:298679fff37c 438 }
mkarlsso 2:298679fff37c 439 }
mkarlsso 2:298679fff37c 440
mkarlsso 2:298679fff37c 441 void intCompare::set(int* intVarInput, const char* cmpString, int* cmpIntVarInput) {
mkarlsso 2:298679fff37c 442 cmpVal = cmpIntVarInput;
mkarlsso 2:298679fff37c 443 intVal = intVarInput;
mkarlsso 2:298679fff37c 444 cmpValGlobal = true;
mkarlsso 2:298679fff37c 445 port = NULL;
mkarlsso 2:298679fff37c 446 intOp = NULL;
mkarlsso 2:298679fff37c 447 portValPtr = NULL;
mkarlsso 2:298679fff37c 448 setPointer(cmpString);
mkarlsso 2:298679fff37c 449 isUsed = true;
mkarlsso 2:298679fff37c 450 }
mkarlsso 2:298679fff37c 451
mkarlsso 2:298679fff37c 452 void intCompare::set(int* intVarInput, const char* cmpString, int cmpValInput) {
mkarlsso 2:298679fff37c 453 intVal = intVarInput;
mkarlsso 2:298679fff37c 454 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 455 cmpValGlobal = false;
mkarlsso 2:298679fff37c 456 port = NULL;
mkarlsso 2:298679fff37c 457 intOp = NULL;
mkarlsso 2:298679fff37c 458 portValPtr = NULL;
mkarlsso 2:298679fff37c 459 setPointer(cmpString);
mkarlsso 2:298679fff37c 460 isUsed = true;
mkarlsso 2:298679fff37c 461 }
mkarlsso 2:298679fff37c 462
mkarlsso 2:298679fff37c 463 void intCompare::set(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput) {
mkarlsso 2:298679fff37c 464 intVal = intVarInput;
mkarlsso 2:298679fff37c 465 cmpVal = NULL;
mkarlsso 2:298679fff37c 466 port = NULL;
mkarlsso 2:298679fff37c 467 portValPtr = NULL;
mkarlsso 2:298679fff37c 468 cmpValGlobal = true;
mkarlsso 2:298679fff37c 469 intOp = cmpIntOpInput;
mkarlsso 2:298679fff37c 470 setPointer_operation(cmpString);
mkarlsso 2:298679fff37c 471 isUsed = true;
mkarlsso 2:298679fff37c 472 }
mkarlsso 2:298679fff37c 473
mkarlsso 2:298679fff37c 474 void intCompare::set(digitalPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse) {
mkarlsso 2:298679fff37c 475 port = portInput;
mkarlsso 2:298679fff37c 476 cmpVal = NULL;
mkarlsso 2:298679fff37c 477 intVal = NULL;
mkarlsso 2:298679fff37c 478 cmpValGlobal = true;
mkarlsso 2:298679fff37c 479 intOp = cmpIntOpInput;
mkarlsso 2:298679fff37c 480 setPointer_operation(cmpString);
mkarlsso 2:298679fff37c 481 isUsed = true;
mkarlsso 2:298679fff37c 482 if (whichToUse == 1) {
mkarlsso 2:298679fff37c 483 portValPtr = &port->inState;
mkarlsso 2:298679fff37c 484 } else {
mkarlsso 2:298679fff37c 485 portValPtr = &port->outState;
mkarlsso 2:298679fff37c 486 }
mkarlsso 2:298679fff37c 487 }
mkarlsso 2:298679fff37c 488
mkarlsso 2:298679fff37c 489
mkarlsso 2:298679fff37c 490
mkarlsso 2:298679fff37c 491 intCompare::~intCompare() {
mkarlsso 2:298679fff37c 492 if (!cmpValGlobal) delete cmpVal; //we only delete the intCompare object if it was created locally
mkarlsso 2:298679fff37c 493 delete intOp;
mkarlsso 2:298679fff37c 494 }
mkarlsso 2:298679fff37c 495
mkarlsso 2:298679fff37c 496 void intCompare::release() {
mkarlsso 2:298679fff37c 497 if (!cmpValGlobal) delete cmpVal; //we only delete the intCompare object if it was created locally
mkarlsso 2:298679fff37c 498 if (intOp != NULL) {
mkarlsso 2:298679fff37c 499 intOp->release();
mkarlsso 2:298679fff37c 500 }
mkarlsso 2:298679fff37c 501 port = NULL;
mkarlsso 2:298679fff37c 502 cmpVal = NULL;
mkarlsso 2:298679fff37c 503 cmpValGlobal = false;
mkarlsso 2:298679fff37c 504 intVal = NULL;
mkarlsso 2:298679fff37c 505 intOp = NULL;
mkarlsso 2:298679fff37c 506 portValPtr = NULL;
mkarlsso 2:298679fff37c 507 isUsed = false;
mkarlsso 2:298679fff37c 508 }
mkarlsso 2:298679fff37c 509
mkarlsso 2:298679fff37c 510
mkarlsso 2:298679fff37c 511 void intCompare::setPointer(const char* cmpString) {
mkarlsso 2:298679fff37c 512 if (strcmp(cmpString, ">") == 0) {
mkarlsso 2:298679fff37c 513 isTruePtr = &intCompare::greaterThan;
mkarlsso 2:298679fff37c 514 }else if (strcmp(cmpString, ">=") == 0) {
mkarlsso 2:298679fff37c 515 isTruePtr = &intCompare::greaterOrEqual;
mkarlsso 2:298679fff37c 516 }else if (strcmp(cmpString, "<") == 0) {
mkarlsso 2:298679fff37c 517 isTruePtr = &intCompare::lessThan;
mkarlsso 2:298679fff37c 518 }else if (strcmp(cmpString, "<=") == 0) {
mkarlsso 2:298679fff37c 519 isTruePtr = &intCompare::lessOrEqual;
mkarlsso 2:298679fff37c 520 }else if (strcmp(cmpString, "==") == 0) {
mkarlsso 2:298679fff37c 521 isTruePtr = &intCompare::equal;
mkarlsso 2:298679fff37c 522 }else if (strcmp(cmpString, "!=") == 0) {
mkarlsso 2:298679fff37c 523 isTruePtr = &intCompare::notEqual;
mkarlsso 2:298679fff37c 524 }
mkarlsso 2:298679fff37c 525 }
mkarlsso 2:298679fff37c 526
mkarlsso 2:298679fff37c 527 void intCompare::setPointer_operation(const char* cmpString) {
mkarlsso 2:298679fff37c 528 if (strcmp(cmpString, ">") == 0) {
mkarlsso 2:298679fff37c 529 isTruePtr = &intCompare::greaterThan_op;
mkarlsso 2:298679fff37c 530 }else if (strcmp(cmpString, ">=") == 0) {
mkarlsso 2:298679fff37c 531 isTruePtr = &intCompare::greaterOrEqual_op;
mkarlsso 2:298679fff37c 532 }else if (strcmp(cmpString, "<") == 0) {
mkarlsso 2:298679fff37c 533 isTruePtr = &intCompare::lessThan_op;
mkarlsso 2:298679fff37c 534 }else if (strcmp(cmpString, "<=") == 0) {
mkarlsso 2:298679fff37c 535 isTruePtr = &intCompare::lessOrEqual_op;
mkarlsso 2:298679fff37c 536 }else if (strcmp(cmpString, "==") == 0) {
mkarlsso 2:298679fff37c 537 isTruePtr = &intCompare::equal_op;
mkarlsso 2:298679fff37c 538 }else if (strcmp(cmpString, "!=") == 0) {
mkarlsso 2:298679fff37c 539 isTruePtr = &intCompare::notEqual_op;
mkarlsso 2:298679fff37c 540 }
mkarlsso 2:298679fff37c 541 }
mkarlsso 2:298679fff37c 542
mkarlsso 2:298679fff37c 543 bool intCompare::isTrue() {
mkarlsso 2:298679fff37c 544 return (this->*isTruePtr)();
mkarlsso 2:298679fff37c 545
mkarlsso 2:298679fff37c 546 }
mkarlsso 2:298679fff37c 547
mkarlsso 2:298679fff37c 548 bool intCompare::notEqual() {
mkarlsso 2:298679fff37c 549 if (intVal != NULL) {
mkarlsso 2:298679fff37c 550 return (*intVal != *cmpVal);
mkarlsso 2:298679fff37c 551 } else {
mkarlsso 2:298679fff37c 552 return (*portValPtr != *cmpVal);
mkarlsso 2:298679fff37c 553 }
mkarlsso 2:298679fff37c 554 }
mkarlsso 2:298679fff37c 555
mkarlsso 2:298679fff37c 556 bool intCompare::greaterThan() {
mkarlsso 2:298679fff37c 557 if (intVal != NULL) {
mkarlsso 2:298679fff37c 558 return (*intVal > *cmpVal);
mkarlsso 2:298679fff37c 559 } else {
mkarlsso 2:298679fff37c 560 return (*portValPtr > *cmpVal);
mkarlsso 2:298679fff37c 561 }
mkarlsso 2:298679fff37c 562 }
mkarlsso 2:298679fff37c 563
mkarlsso 2:298679fff37c 564 bool intCompare::greaterOrEqual() {
mkarlsso 2:298679fff37c 565 if (intVal != NULL) {
mkarlsso 2:298679fff37c 566 return (*intVal >= *cmpVal);
mkarlsso 2:298679fff37c 567 } else {
mkarlsso 2:298679fff37c 568 return (*portValPtr >= *cmpVal);
mkarlsso 2:298679fff37c 569 }
mkarlsso 2:298679fff37c 570 }
mkarlsso 2:298679fff37c 571
mkarlsso 2:298679fff37c 572 bool intCompare::lessThan() {
mkarlsso 2:298679fff37c 573 if (intVal != NULL) {
mkarlsso 2:298679fff37c 574 return (*intVal < *cmpVal);
mkarlsso 2:298679fff37c 575 } else {
mkarlsso 2:298679fff37c 576 return (*portValPtr < *cmpVal);
mkarlsso 2:298679fff37c 577 }
mkarlsso 2:298679fff37c 578 }
mkarlsso 2:298679fff37c 579
mkarlsso 2:298679fff37c 580 bool intCompare::lessOrEqual() {
mkarlsso 2:298679fff37c 581 if (intVal != NULL) {
mkarlsso 2:298679fff37c 582 return (*intVal <= *cmpVal);
mkarlsso 2:298679fff37c 583 } else {
mkarlsso 2:298679fff37c 584 return (*portValPtr <= *cmpVal);
mkarlsso 2:298679fff37c 585 }
mkarlsso 2:298679fff37c 586 }
mkarlsso 2:298679fff37c 587
mkarlsso 2:298679fff37c 588 bool intCompare::equal() {
mkarlsso 2:298679fff37c 589 if (intVal != NULL) {
mkarlsso 2:298679fff37c 590 return (*intVal == *cmpVal);
mkarlsso 2:298679fff37c 591 } else {
mkarlsso 2:298679fff37c 592 return (*portValPtr == *cmpVal);
mkarlsso 2:298679fff37c 593 }
mkarlsso 2:298679fff37c 594 }
mkarlsso 2:298679fff37c 595
mkarlsso 2:298679fff37c 596 bool intCompare::notEqual_op() {
mkarlsso 2:298679fff37c 597 if (intVal != NULL) {
mkarlsso 2:298679fff37c 598 return (*intVal != intOp->execute());
mkarlsso 2:298679fff37c 599 } else {
mkarlsso 2:298679fff37c 600 return (*portValPtr != intOp->execute());
mkarlsso 2:298679fff37c 601 }
mkarlsso 2:298679fff37c 602 }
mkarlsso 2:298679fff37c 603
mkarlsso 2:298679fff37c 604 bool intCompare::greaterThan_op() {
mkarlsso 2:298679fff37c 605 if (intVal != NULL) {
mkarlsso 2:298679fff37c 606 return (*intVal > intOp->execute());
mkarlsso 2:298679fff37c 607 } else {
mkarlsso 2:298679fff37c 608 return (*portValPtr > intOp->execute());
mkarlsso 2:298679fff37c 609 }
mkarlsso 2:298679fff37c 610 }
mkarlsso 2:298679fff37c 611
mkarlsso 2:298679fff37c 612 bool intCompare::greaterOrEqual_op() {
mkarlsso 2:298679fff37c 613 if (intVal != NULL) {
mkarlsso 2:298679fff37c 614 return (*intVal >= intOp->execute());
mkarlsso 2:298679fff37c 615 } else {
mkarlsso 2:298679fff37c 616 return (*portValPtr >= intOp->execute());
mkarlsso 2:298679fff37c 617 }
mkarlsso 2:298679fff37c 618 }
mkarlsso 2:298679fff37c 619
mkarlsso 2:298679fff37c 620 bool intCompare::lessThan_op() {
mkarlsso 2:298679fff37c 621 if (intVal != NULL) {
mkarlsso 2:298679fff37c 622 return (*intVal < intOp->execute());
mkarlsso 2:298679fff37c 623 } else {
mkarlsso 2:298679fff37c 624 return (*portValPtr < intOp->execute());
mkarlsso 2:298679fff37c 625 }
mkarlsso 2:298679fff37c 626 }
mkarlsso 2:298679fff37c 627
mkarlsso 2:298679fff37c 628 bool intCompare::lessOrEqual_op() {
mkarlsso 2:298679fff37c 629 if (intVal != NULL) {
mkarlsso 2:298679fff37c 630 return (*intVal <= intOp->execute());
mkarlsso 2:298679fff37c 631 } else {
mkarlsso 2:298679fff37c 632 return (*portValPtr <= intOp->execute());
mkarlsso 2:298679fff37c 633 }
mkarlsso 2:298679fff37c 634 }
mkarlsso 2:298679fff37c 635
mkarlsso 2:298679fff37c 636 bool intCompare::equal_op() {
mkarlsso 2:298679fff37c 637 if (intVal != NULL) {
mkarlsso 2:298679fff37c 638 return (*intVal == intOp->execute());
mkarlsso 2:298679fff37c 639 } else {
mkarlsso 2:298679fff37c 640 return (*portValPtr == intOp->execute());
mkarlsso 2:298679fff37c 641 }
mkarlsso 2:298679fff37c 642 }
mkarlsso 2:298679fff37c 643
mkarlsso 2:298679fff37c 644 intOperation::intOperation():
mkarlsso 2:298679fff37c 645 randHigh(-1) {
mkarlsso 2:298679fff37c 646 cmpVal = NULL;
mkarlsso 2:298679fff37c 647 intVal = NULL;
mkarlsso 2:298679fff37c 648 opPtr = NULL;
mkarlsso 2:298679fff37c 649 executePtr = NULL;
mkarlsso 2:298679fff37c 650 cmpValGlobal = false;
mkarlsso 2:298679fff37c 651 isUsed = false;
mkarlsso 2:298679fff37c 652
mkarlsso 2:298679fff37c 653 }
mkarlsso 2:298679fff37c 654
mkarlsso 2:298679fff37c 655 intOperation::intOperation(int randParam, const char* cmpString, int cmpValInput):
mkarlsso 2:298679fff37c 656 randHigh(randParam) {
mkarlsso 2:298679fff37c 657 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 658 intVal = NULL;
mkarlsso 2:298679fff37c 659 opPtr = NULL;
mkarlsso 2:298679fff37c 660 cmpValGlobal = false;
mkarlsso 2:298679fff37c 661 isUsed = true;
mkarlsso 2:298679fff37c 662 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 663 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 664 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 665 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 666 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 667 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 668 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 669 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 670 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 671 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 672 }
mkarlsso 2:298679fff37c 673
mkarlsso 2:298679fff37c 674 }
mkarlsso 2:298679fff37c 675
mkarlsso 2:298679fff37c 676 intOperation::intOperation(int randParam, const char* cmpString, int* cmpIntVarInput):
mkarlsso 2:298679fff37c 677 randHigh(randParam),
mkarlsso 2:298679fff37c 678 cmpVal(cmpIntVarInput) {
mkarlsso 2:298679fff37c 679 intVal = NULL;
mkarlsso 2:298679fff37c 680 opPtr = NULL;
mkarlsso 2:298679fff37c 681 cmpValGlobal = true;
mkarlsso 2:298679fff37c 682 isUsed = true;
mkarlsso 2:298679fff37c 683 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 684 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 685 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 686 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 687 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 688 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 689 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 690 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 691 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 692 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 693 }
mkarlsso 2:298679fff37c 694 }
mkarlsso 2:298679fff37c 695
mkarlsso 2:298679fff37c 696 intOperation::intOperation(int* intVarInput, const char* cmpString, int cmpValInput):
mkarlsso 2:298679fff37c 697 intVal(intVarInput) {
mkarlsso 2:298679fff37c 698 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 699 randHigh = -1;
mkarlsso 2:298679fff37c 700 opPtr = NULL;
mkarlsso 2:298679fff37c 701 cmpValGlobal = false;
mkarlsso 2:298679fff37c 702 isUsed = true;
mkarlsso 2:298679fff37c 703 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 704 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 705 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 706 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 707 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 708 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 709 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 710 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 711 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 712 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 713 }
mkarlsso 2:298679fff37c 714 }
mkarlsso 2:298679fff37c 715
mkarlsso 2:298679fff37c 716 intOperation::intOperation(int* intVarInput, const char* cmpString, int* cmpIntVarInput):
mkarlsso 2:298679fff37c 717 cmpVal(cmpIntVarInput),
mkarlsso 2:298679fff37c 718 intVal(intVarInput) {
mkarlsso 2:298679fff37c 719 randHigh = -1;
mkarlsso 2:298679fff37c 720 opPtr = NULL;
mkarlsso 2:298679fff37c 721 cmpValGlobal = true;
mkarlsso 2:298679fff37c 722 isUsed = true;
mkarlsso 2:298679fff37c 723 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 724 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 725 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 726 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 727 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 728 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 729 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 730 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 731 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 732 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 733 }
mkarlsso 2:298679fff37c 734 }
mkarlsso 2:298679fff37c 735
mkarlsso 2:298679fff37c 736 intOperation::intOperation(int* intVarInput, intOperation* operationInput):
mkarlsso 2:298679fff37c 737 intVal(intVarInput) {
mkarlsso 2:298679fff37c 738 cmpVal = NULL;
mkarlsso 2:298679fff37c 739 randHigh = -1;
mkarlsso 2:298679fff37c 740 opPtr = operationInput;
mkarlsso 2:298679fff37c 741 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 742 isUsed = true;
mkarlsso 2:298679fff37c 743 }
mkarlsso 2:298679fff37c 744
mkarlsso 2:298679fff37c 745 void intOperation::set(int randParam, const char* cmpString, int cmpValInput) {
mkarlsso 2:298679fff37c 746 randHigh = randParam;
mkarlsso 2:298679fff37c 747 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 748 intVal = NULL;
mkarlsso 2:298679fff37c 749 opPtr = NULL;
mkarlsso 2:298679fff37c 750 cmpValGlobal = false;
mkarlsso 2:298679fff37c 751 isUsed = true;
mkarlsso 2:298679fff37c 752 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 753 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 754 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 755 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 756 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 757 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 758 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 759 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 760 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 761 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 762 }
mkarlsso 2:298679fff37c 763
mkarlsso 2:298679fff37c 764 }
mkarlsso 2:298679fff37c 765
mkarlsso 2:298679fff37c 766 void intOperation::set(int randParam, const char* cmpString, int* cmpIntVarInput) {
mkarlsso 2:298679fff37c 767 randHigh = randParam;
mkarlsso 2:298679fff37c 768 cmpVal = cmpIntVarInput;
mkarlsso 2:298679fff37c 769 intVal = NULL;
mkarlsso 2:298679fff37c 770 opPtr = NULL;
mkarlsso 2:298679fff37c 771 cmpValGlobal = true;
mkarlsso 2:298679fff37c 772 isUsed = true;
mkarlsso 2:298679fff37c 773 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 774 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 775 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 776 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 777 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 778 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 779 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 780 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 781 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 782 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 783 }
mkarlsso 2:298679fff37c 784 }
mkarlsso 2:298679fff37c 785
mkarlsso 2:298679fff37c 786 void intOperation::set(int* intVarInput, const char* cmpString, int cmpValInput) {
mkarlsso 3:ae33b7f5a7c1 787
mkarlsso 2:298679fff37c 788 intVal = intVarInput;
mkarlsso 2:298679fff37c 789 cmpVal = new int(cmpValInput);
mkarlsso 2:298679fff37c 790 randHigh = -1;
mkarlsso 2:298679fff37c 791 opPtr = NULL;
mkarlsso 2:298679fff37c 792 cmpValGlobal = false;
mkarlsso 2:298679fff37c 793 isUsed = true;
mkarlsso 2:298679fff37c 794 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 795 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 796 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 797 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 798 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 799 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 800 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 801 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 802 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 803 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 804 }
mkarlsso 2:298679fff37c 805 }
mkarlsso 2:298679fff37c 806
mkarlsso 2:298679fff37c 807 void intOperation::set(int* intVarInput, const char* cmpString, int* cmpIntVarInput) {
mkarlsso 2:298679fff37c 808 cmpVal = cmpIntVarInput;
mkarlsso 2:298679fff37c 809 intVal =intVarInput;
mkarlsso 2:298679fff37c 810 randHigh = -1;
mkarlsso 2:298679fff37c 811 opPtr = NULL;
mkarlsso 2:298679fff37c 812 cmpValGlobal = true;
mkarlsso 2:298679fff37c 813 isUsed = true;
mkarlsso 2:298679fff37c 814 if (strcmp(cmpString, "+") == 0) {
mkarlsso 2:298679fff37c 815 executePtr = &intOperation::add;
mkarlsso 2:298679fff37c 816 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 2:298679fff37c 817 executePtr = &intOperation::subtract;
mkarlsso 2:298679fff37c 818 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 2:298679fff37c 819 executePtr = &intOperation::addAndStore;
mkarlsso 2:298679fff37c 820 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 2:298679fff37c 821 executePtr = &intOperation::subtractAndStore;
mkarlsso 2:298679fff37c 822 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 2:298679fff37c 823 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 824 }
mkarlsso 2:298679fff37c 825 }
mkarlsso 2:298679fff37c 826
mkarlsso 2:298679fff37c 827 void intOperation::set(int* intVarInput, intOperation* operationInput) {
mkarlsso 3:ae33b7f5a7c1 828
mkarlsso 2:298679fff37c 829 intVal = intVarInput;
mkarlsso 2:298679fff37c 830 cmpVal = NULL;
mkarlsso 2:298679fff37c 831 randHigh = -1;
mkarlsso 2:298679fff37c 832 opPtr = operationInput;
mkarlsso 2:298679fff37c 833 executePtr = &intOperation::equals;
mkarlsso 2:298679fff37c 834 isUsed = true;
mkarlsso 2:298679fff37c 835
mkarlsso 2:298679fff37c 836 }
mkarlsso 2:298679fff37c 837
mkarlsso 2:298679fff37c 838
mkarlsso 2:298679fff37c 839 intOperation::~intOperation() {
mkarlsso 2:298679fff37c 840 if (!cmpValGlobal) delete cmpVal;
mkarlsso 2:298679fff37c 841 delete opPtr;
mkarlsso 2:298679fff37c 842 }
mkarlsso 2:298679fff37c 843
mkarlsso 2:298679fff37c 844 void intOperation::release() {
mkarlsso 2:298679fff37c 845 if (!cmpValGlobal) delete cmpVal;
mkarlsso 2:298679fff37c 846 if (opPtr != NULL) {
mkarlsso 2:298679fff37c 847 opPtr->release();
mkarlsso 2:298679fff37c 848 }
mkarlsso 2:298679fff37c 849 randHigh = -1;
mkarlsso 2:298679fff37c 850 cmpVal = NULL;
mkarlsso 2:298679fff37c 851 intVal = NULL;
mkarlsso 2:298679fff37c 852 opPtr = NULL;
mkarlsso 2:298679fff37c 853 executePtr = NULL;
mkarlsso 2:298679fff37c 854 cmpValGlobal = false;
mkarlsso 2:298679fff37c 855 isUsed = false;
mkarlsso 2:298679fff37c 856 }
mkarlsso 2:298679fff37c 857
mkarlsso 2:298679fff37c 858
mkarlsso 2:298679fff37c 859 int intOperation::execute() {
mkarlsso 3:ae33b7f5a7c1 860
mkarlsso 2:298679fff37c 861 return (this->*executePtr)();
mkarlsso 2:298679fff37c 862
mkarlsso 3:ae33b7f5a7c1 863
mkarlsso 2:298679fff37c 864 }
mkarlsso 2:298679fff37c 865
mkarlsso 2:298679fff37c 866 int intOperation::add() {
mkarlsso 3:ae33b7f5a7c1 867
mkarlsso 2:298679fff37c 868 if (intVal != NULL) {
mkarlsso 2:298679fff37c 869 return (*intVal + *cmpVal);
mkarlsso 2:298679fff37c 870 }
mkarlsso 2:298679fff37c 871 else {
mkarlsso 2:298679fff37c 872 //srand(time(NULL));
mkarlsso 2:298679fff37c 873 srand(*globalTimeKeeperPtr);
mkarlsso 2:298679fff37c 874 return (rand() % (randHigh+1)) + *cmpVal;
mkarlsso 2:298679fff37c 875 //return (port->getState() + *cmpVal);
mkarlsso 2:298679fff37c 876 }
mkarlsso 2:298679fff37c 877 }
mkarlsso 2:298679fff37c 878
mkarlsso 2:298679fff37c 879 int intOperation::subtract() {
mkarlsso 2:298679fff37c 880 if (intVal != NULL) {
mkarlsso 2:298679fff37c 881 return (*intVal - *cmpVal);
mkarlsso 2:298679fff37c 882 }
mkarlsso 2:298679fff37c 883 else {
mkarlsso 2:298679fff37c 884 srand(*globalTimeKeeperPtr);
mkarlsso 2:298679fff37c 885 return (rand() % (randHigh+1)) - *cmpVal;
mkarlsso 2:298679fff37c 886 //return (port->getState() - *cmpVal);
mkarlsso 2:298679fff37c 887 }
mkarlsso 2:298679fff37c 888 }
mkarlsso 2:298679fff37c 889
mkarlsso 2:298679fff37c 890 int intOperation::addAndStore() {
mkarlsso 2:298679fff37c 891 if (intVal != NULL) {
mkarlsso 2:298679fff37c 892 *intVal = *intVal + *cmpVal;
mkarlsso 2:298679fff37c 893 return *intVal;
mkarlsso 2:298679fff37c 894 }
mkarlsso 2:298679fff37c 895 else {
mkarlsso 2:298679fff37c 896
mkarlsso 2:298679fff37c 897 //Doesn't happen
mkarlsso 2:298679fff37c 898 return 0;
mkarlsso 2:298679fff37c 899 //port->setState(port->getState() + *cmpVal);
mkarlsso 2:298679fff37c 900 //return port->getState();
mkarlsso 2:298679fff37c 901 }
mkarlsso 2:298679fff37c 902
mkarlsso 2:298679fff37c 903 }
mkarlsso 2:298679fff37c 904
mkarlsso 2:298679fff37c 905 int intOperation::subtractAndStore() {
mkarlsso 2:298679fff37c 906 if (intVal != NULL) {
mkarlsso 2:298679fff37c 907 *intVal = *intVal - *cmpVal;
mkarlsso 2:298679fff37c 908 return *intVal;
mkarlsso 2:298679fff37c 909 } else {
mkarlsso 2:298679fff37c 910 //doesn't happen
mkarlsso 2:298679fff37c 911 return 0;
mkarlsso 2:298679fff37c 912 //port->setState(port->getState() - *cmpVal);
mkarlsso 2:298679fff37c 913 //return port->getState();
mkarlsso 2:298679fff37c 914 }
mkarlsso 2:298679fff37c 915 }
mkarlsso 2:298679fff37c 916
mkarlsso 2:298679fff37c 917 int intOperation::equals() {
mkarlsso 2:298679fff37c 918 if ((intVal != NULL) && (opPtr == NULL)) {
mkarlsso 2:298679fff37c 919 *intVal = *cmpVal;
mkarlsso 2:298679fff37c 920 return *intVal;
mkarlsso 2:298679fff37c 921 } else if ((intVal != NULL) && (opPtr != NULL)) {
mkarlsso 3:ae33b7f5a7c1 922
mkarlsso 2:298679fff37c 923 *intVal = opPtr->execute();
mkarlsso 2:298679fff37c 924 return *intVal;
mkarlsso 2:298679fff37c 925 } else if (cmpVal != NULL){
mkarlsso 2:298679fff37c 926
alustig3 5:4d6575e3a07e 927 srand(*globalTimeKeeperPtr);
mkarlsso 2:298679fff37c 928 *cmpVal = (rand() % (randHigh+1)); //this is how we assign a random number to variable
mkarlsso 2:298679fff37c 929 return *cmpVal;
mkarlsso 2:298679fff37c 930
mkarlsso 2:298679fff37c 931 }
mkarlsso 2:298679fff37c 932 return -1;
mkarlsso 2:298679fff37c 933 }
mkarlsso 2:298679fff37c 934
mkarlsso 2:298679fff37c 935 condition::condition() {
mkarlsso 2:298679fff37c 936 intCmp = NULL;
mkarlsso 2:298679fff37c 937 conditionPtrs[0] = NULL;
mkarlsso 2:298679fff37c 938 conditionPtrs[1] = NULL;
mkarlsso 2:298679fff37c 939 isUsed = false;
mkarlsso 2:298679fff37c 940 conditionType = ARITHMATIC_CONDITION;
mkarlsso 2:298679fff37c 941 }
mkarlsso 2:298679fff37c 942
mkarlsso 2:298679fff37c 943 condition::condition(intCompare* compareInput) {
mkarlsso 2:298679fff37c 944
mkarlsso 2:298679fff37c 945 intCmp = compareInput;
mkarlsso 2:298679fff37c 946 conditionPtrs[0] = NULL;
mkarlsso 2:298679fff37c 947 conditionPtrs[1] = NULL;
mkarlsso 2:298679fff37c 948
mkarlsso 2:298679fff37c 949 isUsed = true;
mkarlsso 2:298679fff37c 950 conditionType = ARITHMATIC_CONDITION;
mkarlsso 2:298679fff37c 951
mkarlsso 2:298679fff37c 952 }
mkarlsso 2:298679fff37c 953
mkarlsso 2:298679fff37c 954 condition::condition(condition* condition1, char condType, condition* condition2) {
mkarlsso 2:298679fff37c 955 intCmp = NULL;
mkarlsso 2:298679fff37c 956 conditionPtrs[0] = condition1;
mkarlsso 2:298679fff37c 957 conditionPtrs[1] = condition2;
mkarlsso 2:298679fff37c 958 isUsed = true;
mkarlsso 2:298679fff37c 959 conditionType = condType;
mkarlsso 2:298679fff37c 960 }
mkarlsso 2:298679fff37c 961
mkarlsso 2:298679fff37c 962 condition::~condition() {
mkarlsso 2:298679fff37c 963 if (intCmp != NULL) {
mkarlsso 2:298679fff37c 964 delete intCmp;
mkarlsso 2:298679fff37c 965 }
mkarlsso 2:298679fff37c 966 }
mkarlsso 2:298679fff37c 967
mkarlsso 2:298679fff37c 968 void condition::release() {
mkarlsso 2:298679fff37c 969 if (intCmp != NULL) {
mkarlsso 2:298679fff37c 970 intCmp->release();
mkarlsso 2:298679fff37c 971 intCmp=NULL;
mkarlsso 2:298679fff37c 972 }
mkarlsso 2:298679fff37c 973 if (conditionPtrs[0] != NULL) {
mkarlsso 2:298679fff37c 974 conditionPtrs[0]->release();
mkarlsso 2:298679fff37c 975 conditionPtrs[1]->release();
mkarlsso 2:298679fff37c 976 conditionPtrs[0]=NULL;
mkarlsso 2:298679fff37c 977 conditionPtrs[1]=NULL;
mkarlsso 2:298679fff37c 978 }
mkarlsso 2:298679fff37c 979 isUsed = false;
mkarlsso 2:298679fff37c 980 }
mkarlsso 2:298679fff37c 981
mkarlsso 2:298679fff37c 982 void condition::set(intCompare* compareInput) {
mkarlsso 2:298679fff37c 983 release();
mkarlsso 2:298679fff37c 984 intCmp = compareInput;
mkarlsso 2:298679fff37c 985 conditionPtrs[0] = NULL;
mkarlsso 2:298679fff37c 986 conditionPtrs[1] = NULL;
mkarlsso 2:298679fff37c 987 isUsed = true;
mkarlsso 2:298679fff37c 988 conditionType = ARITHMATIC_CONDITION;
mkarlsso 2:298679fff37c 989 }
mkarlsso 2:298679fff37c 990
mkarlsso 2:298679fff37c 991 void condition::set(condition* condition1, char condType, condition* condition2) {
mkarlsso 2:298679fff37c 992 release();
mkarlsso 2:298679fff37c 993 intCmp = NULL;
mkarlsso 2:298679fff37c 994 conditionPtrs[0] = condition1;
mkarlsso 2:298679fff37c 995 conditionPtrs[1] = condition2;
mkarlsso 2:298679fff37c 996 isUsed = true;
mkarlsso 2:298679fff37c 997 conditionType = condType;
mkarlsso 2:298679fff37c 998 }
mkarlsso 2:298679fff37c 999
mkarlsso 2:298679fff37c 1000 bool condition::isTrue() {
mkarlsso 2:298679fff37c 1001
mkarlsso 2:298679fff37c 1002
mkarlsso 2:298679fff37c 1003 bool result = true;
mkarlsso 2:298679fff37c 1004 if (conditionType == ARITHMATIC_CONDITION) {
mkarlsso 2:298679fff37c 1005 //pc.printf("Evauating arithmatic condition \r\n");
mkarlsso 2:298679fff37c 1006 result = (intCmp->isTrue)();
mkarlsso 2:298679fff37c 1007 } else if (conditionType == AND_CONDITION) {
mkarlsso 2:298679fff37c 1008 //pc.printf("Evauating AND condition \r\n");
mkarlsso 2:298679fff37c 1009 result = conditionPtrs[0]->isTrue() && conditionPtrs[1]->isTrue();
mkarlsso 2:298679fff37c 1010 } else if (conditionType == OR_CONDITION) {
mkarlsso 2:298679fff37c 1011 //pc.printf("Evauating OR condition \r\n");
mkarlsso 2:298679fff37c 1012 result = conditionPtrs[0]->isTrue() || conditionPtrs[1]->isTrue();
mkarlsso 2:298679fff37c 1013 }
mkarlsso 2:298679fff37c 1014 return result;
mkarlsso 2:298679fff37c 1015
mkarlsso 2:298679fff37c 1016 }
mkarlsso 2:298679fff37c 1017
mkarlsso 2:298679fff37c 1018 portMessage::portMessage():
mkarlsso 2:298679fff37c 1019 whichToSet(0),
mkarlsso 2:298679fff37c 1020 value(0),
mkarlsso 2:298679fff37c 1021 port(NULL) {
mkarlsso 2:298679fff37c 1022 isUsed = false;
mkarlsso 2:298679fff37c 1023 }
mkarlsso 2:298679fff37c 1024
mkarlsso 2:298679fff37c 1025 void portMessage::release() {
mkarlsso 2:298679fff37c 1026
mkarlsso 2:298679fff37c 1027 whichToSet = 0;
mkarlsso 2:298679fff37c 1028 value = 0;
mkarlsso 2:298679fff37c 1029 port = NULL;
mkarlsso 2:298679fff37c 1030 isUsed = false;
mkarlsso 2:298679fff37c 1031 }
mkarlsso 2:298679fff37c 1032
mkarlsso 2:298679fff37c 1033 /*
mkarlsso 2:298679fff37c 1034 portMessage::portMessage(digitalPort* portIn, int whichToSetIn, int valueIn):
mkarlsso 2:298679fff37c 1035 whichToSet(whichToSetIn),
mkarlsso 2:298679fff37c 1036 value(valueIn),
mkarlsso 2:298679fff37c 1037 port(portIn) {
mkarlsso 2:298679fff37c 1038 isUsed = true;
mkarlsso 2:298679fff37c 1039 }
mkarlsso 2:298679fff37c 1040
mkarlsso 2:298679fff37c 1041 void portMessage::setMessage(digitalPort* portIn, int whichToSetIn, int valueIn) {
mkarlsso 2:298679fff37c 1042 whichToSet = whichToSetIn;
mkarlsso 2:298679fff37c 1043 value = valueIn;
mkarlsso 2:298679fff37c 1044 port = portIn;
mkarlsso 2:298679fff37c 1045 isUsed = true;
mkarlsso 2:298679fff37c 1046 }*/
mkarlsso 2:298679fff37c 1047
mkarlsso 2:298679fff37c 1048 portMessage::portMessage(int* portIn, int whichToSetIn, int valueIn):
mkarlsso 2:298679fff37c 1049 whichToSet(whichToSetIn),
mkarlsso 2:298679fff37c 1050 value(valueIn),
mkarlsso 2:298679fff37c 1051 port(portIn) {
mkarlsso 2:298679fff37c 1052 isUsed = true;
mkarlsso 2:298679fff37c 1053 }
mkarlsso 2:298679fff37c 1054
mkarlsso 2:298679fff37c 1055 void portMessage::setMessage(int* portIn, int whichToSetIn, int valueIn) {
mkarlsso 2:298679fff37c 1056 whichToSet = whichToSetIn;
mkarlsso 2:298679fff37c 1057 value = valueIn;
mkarlsso 2:298679fff37c 1058 port = portIn;
mkarlsso 2:298679fff37c 1059 isUsed = true;
mkarlsso 2:298679fff37c 1060 }
mkarlsso 2:298679fff37c 1061
mkarlsso 2:298679fff37c 1062 void portMessage::execute() {
mkarlsso 2:298679fff37c 1063
mkarlsso 2:298679fff37c 1064 if (port != NULL) {
mkarlsso 2:298679fff37c 1065 if ((*port > 0) && (*port <= NUMPORTS)) {
mkarlsso 2:298679fff37c 1066 portVector[*port]->setDigitalOut(value);
mkarlsso 2:298679fff37c 1067 } else {
mkarlsso 2:298679fff37c 1068 pc.printf("Error: port index assigned by variable does not exist.");
mkarlsso 2:298679fff37c 1069 }
mkarlsso 2:298679fff37c 1070 } else {
mkarlsso 2:298679fff37c 1071 portVector[whichToSet]->setDigitalOut(value);
mkarlsso 2:298679fff37c 1072 }
mkarlsso 2:298679fff37c 1073
mkarlsso 2:298679fff37c 1074 /*
mkarlsso 2:298679fff37c 1075 if (whichToSet == 1) {
mkarlsso 2:298679fff37c 1076 port->setDigitalOut(value);
mkarlsso 2:298679fff37c 1077 } else if (whichToSet == 2) {
mkarlsso 2:298679fff37c 1078 //port->setState(value);
mkarlsso 2:298679fff37c 1079 }*/
mkarlsso 2:298679fff37c 1080 }
mkarlsso 2:298679fff37c 1081
mkarlsso 2:298679fff37c 1082 action::action():
mkarlsso 2:298679fff37c 1083 actionType(0) {
mkarlsso 2:298679fff37c 1084 op = NULL;
mkarlsso 2:298679fff37c 1085 message = NULL;
mkarlsso 2:298679fff37c 1086 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1087 displayActionPtr = NULL;
mkarlsso 2:298679fff37c 1088 //eventDelay = 0;
mkarlsso 2:298679fff37c 1089 sound = NULL;
mkarlsso 2:298679fff37c 1090 sysCommand = -1;
mkarlsso 2:298679fff37c 1091 isUsed = false;
mkarlsso 2:298679fff37c 1092
mkarlsso 2:298679fff37c 1093 }
mkarlsso 2:298679fff37c 1094
mkarlsso 2:298679fff37c 1095 action::~action() {
mkarlsso 2:298679fff37c 1096 if (eventToCreate != NULL) delete eventToCreate;
mkarlsso 2:298679fff37c 1097 if (op != NULL) delete op;
mkarlsso 2:298679fff37c 1098 if (message != NULL) delete message;
mkarlsso 2:298679fff37c 1099 delete displayActionPtr;
mkarlsso 2:298679fff37c 1100 delete sound;
mkarlsso 2:298679fff37c 1101 }
mkarlsso 2:298679fff37c 1102
mkarlsso 2:298679fff37c 1103 void action::release() {
mkarlsso 2:298679fff37c 1104 if (eventToCreate != NULL) eventToCreate->release();
mkarlsso 2:298679fff37c 1105 if (op != NULL) op->release();
mkarlsso 2:298679fff37c 1106 if (message != NULL) message->release();
mkarlsso 2:298679fff37c 1107 if (displayActionPtr != NULL) displayActionPtr->release();
mkarlsso 2:298679fff37c 1108 delete sound; //still need to make a static soundControl array
mkarlsso 2:298679fff37c 1109
mkarlsso 2:298679fff37c 1110 actionType = 0;
mkarlsso 2:298679fff37c 1111 op = NULL;
mkarlsso 2:298679fff37c 1112 message = NULL;
mkarlsso 2:298679fff37c 1113 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1114 displayActionPtr = NULL;
mkarlsso 2:298679fff37c 1115 //eventDelay = 0;
mkarlsso 2:298679fff37c 1116 sound = NULL;
mkarlsso 2:298679fff37c 1117 sysCommand = -1;
mkarlsso 2:298679fff37c 1118 isUsed = false;
mkarlsso 2:298679fff37c 1119 }
mkarlsso 2:298679fff37c 1120
mkarlsso 2:298679fff37c 1121 action::action(intOperation* opInput):
mkarlsso 2:298679fff37c 1122 actionType(1) {
mkarlsso 2:298679fff37c 1123 op = opInput;
mkarlsso 2:298679fff37c 1124 message = NULL;
mkarlsso 2:298679fff37c 1125 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1126 displayActionPtr= NULL;
mkarlsso 2:298679fff37c 1127 //eventDelay = 0;
mkarlsso 2:298679fff37c 1128 sound = NULL;
mkarlsso 2:298679fff37c 1129 sysCommand = -1;
mkarlsso 2:298679fff37c 1130 isUsed = true;
mkarlsso 2:298679fff37c 1131 }
mkarlsso 2:298679fff37c 1132
mkarlsso 2:298679fff37c 1133 action::action(portMessage* messageInput):
mkarlsso 2:298679fff37c 1134 actionType(2) {
mkarlsso 2:298679fff37c 1135 op = NULL;
mkarlsso 2:298679fff37c 1136 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1137 message = messageInput;
mkarlsso 2:298679fff37c 1138 displayActionPtr= NULL;
mkarlsso 2:298679fff37c 1139 //eventDelay = 0;
mkarlsso 2:298679fff37c 1140 sound = NULL;
mkarlsso 2:298679fff37c 1141 sysCommand = -1;
mkarlsso 2:298679fff37c 1142 isUsed = true;
mkarlsso 2:298679fff37c 1143
mkarlsso 2:298679fff37c 1144 }
mkarlsso 2:298679fff37c 1145
mkarlsso 2:298679fff37c 1146 action::action(event* eventInput):
mkarlsso 2:298679fff37c 1147 actionType(3) {
mkarlsso 2:298679fff37c 1148 op = NULL;
mkarlsso 2:298679fff37c 1149 message = NULL;
mkarlsso 2:298679fff37c 1150 eventToCreate = eventInput;
mkarlsso 2:298679fff37c 1151 displayActionPtr= NULL;
mkarlsso 2:298679fff37c 1152 sound = NULL;
mkarlsso 2:298679fff37c 1153
mkarlsso 2:298679fff37c 1154 //eventDelay = eventInput->timeLag;
mkarlsso 2:298679fff37c 1155
mkarlsso 2:298679fff37c 1156
mkarlsso 2:298679fff37c 1157 sysCommand = -1;
mkarlsso 2:298679fff37c 1158 isUsed = true;
mkarlsso 2:298679fff37c 1159 }
mkarlsso 2:298679fff37c 1160
mkarlsso 2:298679fff37c 1161 /*
mkarlsso 2:298679fff37c 1162 action::action(event* eventInput, uint32_t delay):
mkarlsso 2:298679fff37c 1163 actionType(3) {
mkarlsso 2:298679fff37c 1164 op = NULL;
mkarlsso 2:298679fff37c 1165 message = NULL;
mkarlsso 2:298679fff37c 1166 eventToCreate = eventInput;
mkarlsso 2:298679fff37c 1167 displayActionPtr= NULL;
mkarlsso 2:298679fff37c 1168 sound = NULL;
mkarlsso 2:298679fff37c 1169 eventDelay = delay;
mkarlsso 2:298679fff37c 1170 sysCommand = -1;
mkarlsso 2:298679fff37c 1171 isUsed = true;
mkarlsso 2:298679fff37c 1172
mkarlsso 2:298679fff37c 1173 }*/
mkarlsso 2:298679fff37c 1174
mkarlsso 2:298679fff37c 1175
mkarlsso 2:298679fff37c 1176
mkarlsso 2:298679fff37c 1177 action::action(displayAction* displayInput):
mkarlsso 2:298679fff37c 1178 actionType(4) {
mkarlsso 2:298679fff37c 1179 op = NULL;
mkarlsso 2:298679fff37c 1180 message = NULL;
mkarlsso 2:298679fff37c 1181 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1182 sound = NULL;
mkarlsso 2:298679fff37c 1183 displayActionPtr = displayInput;
mkarlsso 2:298679fff37c 1184 //eventDelay = 0;
mkarlsso 2:298679fff37c 1185 sysCommand = -1;
mkarlsso 2:298679fff37c 1186 isUsed = true;
mkarlsso 2:298679fff37c 1187 }
mkarlsso 2:298679fff37c 1188
mkarlsso 2:298679fff37c 1189 action::action(soundControl* soundInput):
mkarlsso 2:298679fff37c 1190 actionType(5) {
mkarlsso 2:298679fff37c 1191 op = NULL;
mkarlsso 2:298679fff37c 1192 message = NULL;
mkarlsso 2:298679fff37c 1193 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1194 sound = soundInput;
mkarlsso 2:298679fff37c 1195 displayActionPtr = NULL;
mkarlsso 2:298679fff37c 1196 //eventDelay = 0;
mkarlsso 2:298679fff37c 1197 sysCommand = -1;
mkarlsso 2:298679fff37c 1198 isUsed = true;
mkarlsso 2:298679fff37c 1199 }
mkarlsso 2:298679fff37c 1200
mkarlsso 2:298679fff37c 1201 action::action(int8_t sysCommandInput):
mkarlsso 2:298679fff37c 1202 actionType(6) {
mkarlsso 2:298679fff37c 1203 op = NULL;
mkarlsso 2:298679fff37c 1204 message = NULL;
mkarlsso 2:298679fff37c 1205 eventToCreate = NULL;
mkarlsso 2:298679fff37c 1206 sound = NULL;
mkarlsso 2:298679fff37c 1207 displayActionPtr = NULL;
mkarlsso 2:298679fff37c 1208 //eventDelay = 0;
mkarlsso 2:298679fff37c 1209 sysCommand = sysCommandInput;
mkarlsso 2:298679fff37c 1210 isUsed = true;
mkarlsso 2:298679fff37c 1211 }
mkarlsso 2:298679fff37c 1212
mkarlsso 2:298679fff37c 1213 void action::set(intOperation* opInput) {
mkarlsso 2:298679fff37c 1214 actionType = 1;
mkarlsso 2:298679fff37c 1215 op = opInput;
mkarlsso 2:298679fff37c 1216 //eventDelay = 0;
mkarlsso 2:298679fff37c 1217 isUsed = true;
mkarlsso 2:298679fff37c 1218
mkarlsso 2:298679fff37c 1219 }
mkarlsso 2:298679fff37c 1220
mkarlsso 2:298679fff37c 1221 void action::set(portMessage* messageInput) {
mkarlsso 2:298679fff37c 1222 actionType = 2;
mkarlsso 2:298679fff37c 1223 message = messageInput;
mkarlsso 2:298679fff37c 1224 //eventDelay = 0;
mkarlsso 2:298679fff37c 1225 isUsed = true;
mkarlsso 2:298679fff37c 1226
mkarlsso 2:298679fff37c 1227 }
mkarlsso 2:298679fff37c 1228
mkarlsso 2:298679fff37c 1229 void action::set(event* eventInput) {
mkarlsso 2:298679fff37c 1230 actionType = 3;
mkarlsso 2:298679fff37c 1231 eventToCreate = eventInput;
mkarlsso 2:298679fff37c 1232 //eventDelay = eventInput->timeLag;
mkarlsso 2:298679fff37c 1233
mkarlsso 2:298679fff37c 1234 isUsed = true;
mkarlsso 2:298679fff37c 1235
mkarlsso 2:298679fff37c 1236 }
mkarlsso 2:298679fff37c 1237
mkarlsso 2:298679fff37c 1238 /*
mkarlsso 2:298679fff37c 1239 void action::set(event* eventInput, uint32_t delay) {
mkarlsso 2:298679fff37c 1240 actionType = 3;
mkarlsso 2:298679fff37c 1241 eventToCreate = eventInput;
mkarlsso 2:298679fff37c 1242 eventDelay = delay;
mkarlsso 2:298679fff37c 1243 isUsed = true;
mkarlsso 2:298679fff37c 1244
mkarlsso 2:298679fff37c 1245 }*/
mkarlsso 2:298679fff37c 1246
mkarlsso 2:298679fff37c 1247
mkarlsso 2:298679fff37c 1248
mkarlsso 2:298679fff37c 1249 void action::set(displayAction* displayInput) {
mkarlsso 2:298679fff37c 1250 actionType = 4;
mkarlsso 2:298679fff37c 1251 displayActionPtr = displayInput;
mkarlsso 2:298679fff37c 1252 isUsed = true;
mkarlsso 2:298679fff37c 1253 }
mkarlsso 2:298679fff37c 1254
mkarlsso 2:298679fff37c 1255 void action::set(soundControl* soundInput) {
mkarlsso 2:298679fff37c 1256 actionType = 5;
mkarlsso 2:298679fff37c 1257 sound = soundInput;
mkarlsso 2:298679fff37c 1258 isUsed = true;
mkarlsso 2:298679fff37c 1259 }
mkarlsso 2:298679fff37c 1260
mkarlsso 2:298679fff37c 1261 void action::set(int8_t sysCommandInput) {
mkarlsso 2:298679fff37c 1262 actionType = 6;
mkarlsso 2:298679fff37c 1263 sysCommand = sysCommandInput;
mkarlsso 2:298679fff37c 1264 isUsed = true;
mkarlsso 2:298679fff37c 1265 }
mkarlsso 2:298679fff37c 1266
mkarlsso 2:298679fff37c 1267 void action::execute() {
mkarlsso 2:298679fff37c 1268
mkarlsso 2:298679fff37c 1269 if (actionType == 1) {
mkarlsso 2:298679fff37c 1270 op->execute();
mkarlsso 2:298679fff37c 1271 } else if (actionType == 2) {
mkarlsso 2:298679fff37c 1272 message->execute();
mkarlsso 2:298679fff37c 1273 } else if (actionType == 3) {
mkarlsso 2:298679fff37c 1274 this->execute(*globalTimeKeeperPtr); //route to the other overloaded method
mkarlsso 2:298679fff37c 1275 } else if (actionType == 4) {
mkarlsso 2:298679fff37c 1276 displayActionPtr->execute(); //send text via serial
mkarlsso 2:298679fff37c 1277 } else if (actionType == 5) {
mkarlsso 2:298679fff37c 1278 sound->execute(); //operate sound device
mkarlsso 2:298679fff37c 1279 } else if (actionType == 6) {
mkarlsso 2:298679fff37c 1280 switch(sysCommand) {
mkarlsso 2:298679fff37c 1281 case 0:
mkarlsso 2:298679fff37c 1282 mainQueue.eraseQueue();
mkarlsso 2:298679fff37c 1283 break;
mkarlsso 2:298679fff37c 1284 case 1:
mkarlsso 2:298679fff37c 1285 textStreaming = true;
mkarlsso 2:298679fff37c 1286 break;
mkarlsso 2:298679fff37c 1287 case 2:
mkarlsso 2:298679fff37c 1288 textStreaming = false;
mkarlsso 2:298679fff37c 1289 break;
mkarlsso 2:298679fff37c 1290 case 3:
mkarlsso 2:298679fff37c 1291 broadCastStateChanges = true;
mkarlsso 2:298679fff37c 1292 break;
mkarlsso 2:298679fff37c 1293 case 4:
mkarlsso 2:298679fff37c 1294 broadCastStateChanges = false;
mkarlsso 2:298679fff37c 1295 break;
mkarlsso 2:298679fff37c 1296 }
mkarlsso 2:298679fff37c 1297
mkarlsso 2:298679fff37c 1298 }
mkarlsso 2:298679fff37c 1299 }
mkarlsso 2:298679fff37c 1300
mkarlsso 2:298679fff37c 1301 void action::execute(uint32_t blockExecTime) {
mkarlsso 2:298679fff37c 1302
mkarlsso 2:298679fff37c 1303 if (actionType == 1) {
mkarlsso 2:298679fff37c 1304 op->execute();
mkarlsso 2:298679fff37c 1305 } else if (actionType == 2) {
mkarlsso 2:298679fff37c 1306 message->execute();
mkarlsso 2:298679fff37c 1307 } else if (actionType == 3) { //an event block
mkarlsso 2:298679fff37c 1308 //Because time will pass from the begining of the block, any defined delays should be updated
mkarlsso 2:298679fff37c 1309
mkarlsso 2:298679fff37c 1310 //int newDelay = eventDelay-(*globalTimeKeeperPtr-blockExecTime);
mkarlsso 2:298679fff37c 1311 int newDelay;
mkarlsso 2:298679fff37c 1312 if (eventToCreate->timeLagIsConstant) {
mkarlsso 2:298679fff37c 1313 newDelay = eventToCreate->timeLag - (*globalTimeKeeperPtr-blockExecTime);
mkarlsso 2:298679fff37c 1314 } else {
mkarlsso 2:298679fff37c 1315 newDelay = *eventToCreate->timeLagVar - (*globalTimeKeeperPtr-blockExecTime);
mkarlsso 2:298679fff37c 1316 }
mkarlsso 2:298679fff37c 1317 if (newDelay < 0) {newDelay = 0;}
mkarlsso 2:298679fff37c 1318 eventToCreate->addToQueue(newDelay); //add the event to the queue to be executed later
mkarlsso 2:298679fff37c 1319
mkarlsso 2:298679fff37c 1320 if (eventToCreate->hasWhileLoop) { //this is a while loop
mkarlsso 2:298679fff37c 1321 if (eventToCreate->isConditionTrue()) {
mkarlsso 2:298679fff37c 1322 //newDelay = (blockExecTime + eventToCreate->whileLoopPeriod) - *globalTimeKeeperPtr;
mkarlsso 2:298679fff37c 1323 int tmpPeriod;
mkarlsso 2:298679fff37c 1324 if (eventToCreate->whileLoopPeriodIsConstant) { //constant while loop period
mkarlsso 2:298679fff37c 1325 newDelay = (blockExecTime + eventToCreate->whileLoopPeriod);
mkarlsso 2:298679fff37c 1326 tmpPeriod = eventToCreate->whileLoopPeriod;
mkarlsso 2:298679fff37c 1327 } else {
mkarlsso 2:298679fff37c 1328 tmpPeriod = *eventToCreate->whileLoopPeriodVar;
mkarlsso 2:298679fff37c 1329 if (tmpPeriod < 0) {
mkarlsso 2:298679fff37c 1330 tmpPeriod = 0;
mkarlsso 2:298679fff37c 1331 }
mkarlsso 2:298679fff37c 1332 newDelay = (blockExecTime + tmpPeriod);
mkarlsso 2:298679fff37c 1333 }
mkarlsso 2:298679fff37c 1334 while ( (newDelay-*globalTimeKeeperPtr < 0) && (eventToCreate->isConditionTrue()) ) {
mkarlsso 2:298679fff37c 1335 eventToCreate->execute();
mkarlsso 2:298679fff37c 1336 newDelay = newDelay + tmpPeriod;
mkarlsso 2:298679fff37c 1337
mkarlsso 2:298679fff37c 1338 }
mkarlsso 2:298679fff37c 1339 newDelay = newDelay-*globalTimeKeeperPtr;
mkarlsso 2:298679fff37c 1340 if (newDelay > 0) {
mkarlsso 2:298679fff37c 1341 eventToCreate->addToQueue(newDelay);
mkarlsso 2:298679fff37c 1342 } else {
mkarlsso 2:298679fff37c 1343 eventToCreate->addToQueue(1);
mkarlsso 2:298679fff37c 1344 }
mkarlsso 2:298679fff37c 1345 } else if (eventToCreate->nextElseEventPtr != NULL) {
mkarlsso 2:298679fff37c 1346 eventToCreate->nextElseEventPtr->addToQueue();
mkarlsso 2:298679fff37c 1347
mkarlsso 2:298679fff37c 1348 }
mkarlsso 2:298679fff37c 1349 }
mkarlsso 2:298679fff37c 1350 } else if (actionType == 4) {
mkarlsso 2:298679fff37c 1351 displayActionPtr->execute(); //send text via serial
mkarlsso 2:298679fff37c 1352 } else if (actionType == 5) {
mkarlsso 2:298679fff37c 1353 sound->execute(); //operate sound device
mkarlsso 2:298679fff37c 1354 } else if (actionType == 6) {
mkarlsso 2:298679fff37c 1355 switch(sysCommand) {
mkarlsso 2:298679fff37c 1356 case 0:
mkarlsso 2:298679fff37c 1357 mainQueue.eraseQueue();
mkarlsso 2:298679fff37c 1358 break;
mkarlsso 2:298679fff37c 1359 case 1:
mkarlsso 2:298679fff37c 1360 textStreaming = true;
mkarlsso 2:298679fff37c 1361 break;
mkarlsso 2:298679fff37c 1362 case 2:
mkarlsso 2:298679fff37c 1363 textStreaming = false;
mkarlsso 2:298679fff37c 1364 break;
mkarlsso 2:298679fff37c 1365 case 3:
mkarlsso 2:298679fff37c 1366 broadCastStateChanges = true;
mkarlsso 2:298679fff37c 1367 break;
mkarlsso 2:298679fff37c 1368 case 4:
mkarlsso 2:298679fff37c 1369 broadCastStateChanges = false;
mkarlsso 2:298679fff37c 1370 break;
mkarlsso 2:298679fff37c 1371 }
mkarlsso 2:298679fff37c 1372 }
mkarlsso 2:298679fff37c 1373 }
mkarlsso 2:298679fff37c 1374
mkarlsso 2:298679fff37c 1375 eventQueue::eventQueue(digitalPort** portVectorInput, uint32_t* timeKeeperSlaveInput):
mkarlsso 2:298679fff37c 1376 portVector(portVectorInput),
mkarlsso 2:298679fff37c 1377 timeKeeperPtr(timeKeeperSlaveInput){
mkarlsso 2:298679fff37c 1378
mkarlsso 2:298679fff37c 1379 globalTimeKeeperPtr = timeKeeperPtr;
mkarlsso 2:298679fff37c 1380 queueItem blankEvent;
mkarlsso 2:298679fff37c 1381 blankEvent.timeToExecute = 0;
mkarlsso 2:298679fff37c 1382 blankEvent.eventPtr = NULL;
mkarlsso 2:298679fff37c 1383 queueSize = 100;
mkarlsso 2:298679fff37c 1384 events.resize(queueSize,blankEvent);
mkarlsso 2:298679fff37c 1385
mkarlsso 2:298679fff37c 1386
mkarlsso 2:298679fff37c 1387 }
mkarlsso 2:298679fff37c 1388
mkarlsso 2:298679fff37c 1389 void eventQueue::addEventToQueue(event* eventInput, uint32_t delay) {
mkarlsso 2:298679fff37c 1390 //*updateSlavePtr = false;
mkarlsso 2:298679fff37c 1391 uint32_t eventTime = *timeKeeperPtr + delay;
mkarlsso 2:298679fff37c 1392 //*updateSlavePtr = true;
mkarlsso 2:298679fff37c 1393 //std::vector<queueItem>::size_type sz = events.size();
mkarlsso 2:298679fff37c 1394 //Look for the first empty slot in the queue and place the event there.
mkarlsso 2:298679fff37c 1395 //This means that the events in the queue are out of order, but
mkarlsso 2:298679fff37c 1396 //it prevents us from having to push_pack and pop off all the time.
mkarlsso 2:298679fff37c 1397 for (unsigned i = 0; i < queueSize; i++) {
mkarlsso 2:298679fff37c 1398 if (events[i].eventPtr == NULL) {
mkarlsso 2:298679fff37c 1399 events[i].eventPtr = eventInput;
mkarlsso 2:298679fff37c 1400 events[i].timeToExecute = eventTime;
mkarlsso 2:298679fff37c 1401 break;
mkarlsso 2:298679fff37c 1402 }
mkarlsso 2:298679fff37c 1403 }
mkarlsso 2:298679fff37c 1404 }
mkarlsso 2:298679fff37c 1405
mkarlsso 2:298679fff37c 1406 void eventQueue::eraseQueue() {
mkarlsso 2:298679fff37c 1407 //Erase all events in the queue
mkarlsso 2:298679fff37c 1408 std::vector<queueItem>::size_type sz = events.size();
mkarlsso 2:298679fff37c 1409 for (unsigned i = 0; i < sz; i++) {
mkarlsso 2:298679fff37c 1410 events[i].eventPtr = NULL;
mkarlsso 2:298679fff37c 1411
mkarlsso 2:298679fff37c 1412 }
mkarlsso 2:298679fff37c 1413 }
mkarlsso 2:298679fff37c 1414
mkarlsso 2:298679fff37c 1415
mkarlsso 2:298679fff37c 1416 //check if any of the events in the queue are up for execution
mkarlsso 2:298679fff37c 1417 void eventQueue::check(void) {
mkarlsso 2:298679fff37c 1418
mkarlsso 2:298679fff37c 1419 //*updateSlavePtr = false;
mkarlsso 2:298679fff37c 1420 uint32_t currentTime = *timeKeeperPtr;
mkarlsso 2:298679fff37c 1421 //*updateSlavePtr = true;
mkarlsso 2:298679fff37c 1422 //std::vector<queueItem>::size_type sz = events.size();
mkarlsso 2:298679fff37c 1423 for (unsigned i = 0; i < queueSize; i++) {
mkarlsso 2:298679fff37c 1424 if (events[i].eventPtr != NULL) {
mkarlsso 2:298679fff37c 1425 if(events[i].timeToExecute <= currentTime) {
mkarlsso 2:298679fff37c 1426 if (!events[i].eventPtr->hasWhileLoop) {
mkarlsso 2:298679fff37c 1427 //this is not a while loop, so no need to check if the condition is still true
mkarlsso 2:298679fff37c 1428 events[i].eventPtr->execute();
mkarlsso 2:298679fff37c 1429 } else if (events[i].eventPtr->isConditionTrue()){
mkarlsso 2:298679fff37c 1430 //The event is part of a while loop, so recheck the condition before executing
mkarlsso 2:298679fff37c 1431 events[i].eventPtr->execute();
mkarlsso 2:298679fff37c 1432 //if (events[i].eventPtr->isConditionTrue()) { //is the condition still true?
mkarlsso 2:298679fff37c 1433 int nextTime;
mkarlsso 2:298679fff37c 1434 int tmpPeriod;
mkarlsso 2:298679fff37c 1435 if (events[i].eventPtr->whileLoopPeriodIsConstant) {
mkarlsso 2:298679fff37c 1436 nextTime = (events[i].timeToExecute + events[i].eventPtr->whileLoopPeriod);
mkarlsso 2:298679fff37c 1437 tmpPeriod = events[i].eventPtr->whileLoopPeriod;
mkarlsso 2:298679fff37c 1438 } else {
mkarlsso 2:298679fff37c 1439 tmpPeriod = *events[i].eventPtr->whileLoopPeriodVar;
mkarlsso 2:298679fff37c 1440 if (tmpPeriod < 0) {
mkarlsso 2:298679fff37c 1441 tmpPeriod = 0;
mkarlsso 2:298679fff37c 1442 }
mkarlsso 2:298679fff37c 1443 nextTime = (events[i].timeToExecute + tmpPeriod);
mkarlsso 2:298679fff37c 1444
mkarlsso 2:298679fff37c 1445 }
mkarlsso 2:298679fff37c 1446 //Just in case we are not keeping up, execute the event until we have cought up
mkarlsso 2:298679fff37c 1447 while ((nextTime-*timeKeeperPtr <= 0) && (events[i].eventPtr->isConditionTrue())) {
mkarlsso 2:298679fff37c 1448 events[i].eventPtr->execute();
mkarlsso 2:298679fff37c 1449 nextTime = nextTime+tmpPeriod;
mkarlsso 2:298679fff37c 1450
mkarlsso 2:298679fff37c 1451 }
mkarlsso 2:298679fff37c 1452 nextTime = nextTime - *timeKeeperPtr;
mkarlsso 2:298679fff37c 1453 if (nextTime > 0) {
mkarlsso 2:298679fff37c 1454 //we add the event to the queue (but the condition is rechecked first)
mkarlsso 2:298679fff37c 1455 //if the condition is false, the 'then' statement is added to the queue instead
mkarlsso 2:298679fff37c 1456 events[i].eventPtr->addToQueue(nextTime);
mkarlsso 2:298679fff37c 1457 } else {
mkarlsso 2:298679fff37c 1458 //if we are having trouble keeping up, just add the next event in 1 ms
mkarlsso 2:298679fff37c 1459 events[i].eventPtr->addToQueue(1);
mkarlsso 2:298679fff37c 1460 }
mkarlsso 2:298679fff37c 1461 /*
mkarlsso 2:298679fff37c 1462 } else {
mkarlsso 2:298679fff37c 1463 if (events[i].eventPtr->nextElseEventPtr != NULL) {
mkarlsso 2:298679fff37c 1464 events[i].eventPtr->nextElseEventPtr->addToQueue();
mkarlsso 2:298679fff37c 1465 }
mkarlsso 2:298679fff37c 1466 }*/
mkarlsso 2:298679fff37c 1467
mkarlsso 2:298679fff37c 1468 } else {
mkarlsso 2:298679fff37c 1469 if (events[i].eventPtr->nextElseEventPtr != NULL) {
mkarlsso 2:298679fff37c 1470 events[i].eventPtr->nextElseEventPtr->addToQueue();
mkarlsso 2:298679fff37c 1471 }
mkarlsso 2:298679fff37c 1472 }
mkarlsso 2:298679fff37c 1473 events[i].eventPtr = NULL;
mkarlsso 2:298679fff37c 1474 }
mkarlsso 2:298679fff37c 1475 }
mkarlsso 2:298679fff37c 1476 }
mkarlsso 2:298679fff37c 1477 }
mkarlsso 2:298679fff37c 1478
mkarlsso 2:298679fff37c 1479
mkarlsso 2:298679fff37c 1480 event::event():
mkarlsso 2:298679fff37c 1481 timeLag(0),
mkarlsso 2:298679fff37c 1482 queuePtr(&mainQueue) {
mkarlsso 2:298679fff37c 1483 nextElseEventPtr = NULL;
mkarlsso 2:298679fff37c 1484 conditionToCheck = NULL;
mkarlsso 2:298679fff37c 1485 blockType = 0;
mkarlsso 2:298679fff37c 1486 whileLoopPeriod = 0;
mkarlsso 2:298679fff37c 1487 numConditions = 0;
mkarlsso 2:298679fff37c 1488 numActions = 0;
mkarlsso 2:298679fff37c 1489 isUsed = false;
mkarlsso 2:298679fff37c 1490 timeLagVar = NULL;
mkarlsso 2:298679fff37c 1491 timeLagIsConstant = true;
mkarlsso 2:298679fff37c 1492 whileLoopPeriodIsConstant = true;
mkarlsso 2:298679fff37c 1493 hasWhileLoop = false;
mkarlsso 2:298679fff37c 1494 whileLoopPeriodVar = NULL;
mkarlsso 2:298679fff37c 1495
mkarlsso 2:298679fff37c 1496 }
mkarlsso 2:298679fff37c 1497
mkarlsso 2:298679fff37c 1498 event::event(eventQueue* queueInput):
mkarlsso 2:298679fff37c 1499 timeLag(0),
mkarlsso 2:298679fff37c 1500 queuePtr(&mainQueue) {
mkarlsso 2:298679fff37c 1501 nextElseEventPtr = NULL;
mkarlsso 2:298679fff37c 1502 conditionToCheck = NULL;
mkarlsso 2:298679fff37c 1503 blockType = 0;
mkarlsso 2:298679fff37c 1504 whileLoopPeriod = 0;
mkarlsso 2:298679fff37c 1505 numConditions = 0;
mkarlsso 2:298679fff37c 1506 numActions = 0;
mkarlsso 2:298679fff37c 1507 isUsed = true;
mkarlsso 2:298679fff37c 1508 timeLagVar = NULL;
mkarlsso 2:298679fff37c 1509 timeLagIsConstant = true;
mkarlsso 2:298679fff37c 1510 whileLoopPeriodIsConstant = true;
mkarlsso 2:298679fff37c 1511 hasWhileLoop = false;
mkarlsso 2:298679fff37c 1512 whileLoopPeriodVar = NULL;
mkarlsso 2:298679fff37c 1513
mkarlsso 2:298679fff37c 1514 }
mkarlsso 2:298679fff37c 1515
mkarlsso 2:298679fff37c 1516 event::~event() {
mkarlsso 2:298679fff37c 1517 /*
mkarlsso 2:298679fff37c 1518 while (!conditionArray.empty())
mkarlsso 2:298679fff37c 1519 {
mkarlsso 2:298679fff37c 1520 delete conditionArray.back();
mkarlsso 2:298679fff37c 1521 conditionArray.pop_back();
mkarlsso 2:298679fff37c 1522 }
mkarlsso 2:298679fff37c 1523
mkarlsso 2:298679fff37c 1524 while (!actionArray.empty())
mkarlsso 2:298679fff37c 1525 {
mkarlsso 2:298679fff37c 1526 delete actionArray.back();
mkarlsso 2:298679fff37c 1527 actionArray.pop_back();
mkarlsso 2:298679fff37c 1528 }
mkarlsso 2:298679fff37c 1529
mkarlsso 2:298679fff37c 1530 delete nextElseEventPtr;
mkarlsso 2:298679fff37c 1531 */
mkarlsso 2:298679fff37c 1532
mkarlsso 2:298679fff37c 1533 }
mkarlsso 2:298679fff37c 1534
mkarlsso 2:298679fff37c 1535 void event::release() {
mkarlsso 2:298679fff37c 1536
mkarlsso 2:298679fff37c 1537 for (int i = 0; i < numActions; i++) {
mkarlsso 2:298679fff37c 1538 actionArray[i]->release();
mkarlsso 2:298679fff37c 1539 }
mkarlsso 2:298679fff37c 1540
mkarlsso 2:298679fff37c 1541 if (conditionToCheck != NULL) {
mkarlsso 2:298679fff37c 1542 conditionToCheck->release();
mkarlsso 2:298679fff37c 1543 conditionToCheck = NULL;
mkarlsso 2:298679fff37c 1544 }
mkarlsso 2:298679fff37c 1545
mkarlsso 2:298679fff37c 1546 if (nextElseEventPtr != NULL) {
mkarlsso 2:298679fff37c 1547 nextElseEventPtr->release();
mkarlsso 2:298679fff37c 1548 }
mkarlsso 2:298679fff37c 1549 timeLag = 0;
mkarlsso 2:298679fff37c 1550 nextElseEventPtr = NULL;
mkarlsso 2:298679fff37c 1551 blockType = 0;
mkarlsso 2:298679fff37c 1552 whileLoopPeriod = 0;
mkarlsso 2:298679fff37c 1553 numConditions = 0;
mkarlsso 2:298679fff37c 1554 numActions = 0;
mkarlsso 2:298679fff37c 1555 isUsed = false;
mkarlsso 2:298679fff37c 1556 timeLagVar = NULL;
mkarlsso 2:298679fff37c 1557 timeLagIsConstant = true;
mkarlsso 2:298679fff37c 1558 whileLoopPeriodIsConstant = true;
mkarlsso 2:298679fff37c 1559 hasWhileLoop = false;
mkarlsso 2:298679fff37c 1560 whileLoopPeriodVar = NULL;
mkarlsso 2:298679fff37c 1561 }
mkarlsso 2:298679fff37c 1562
mkarlsso 2:298679fff37c 1563 void event::setTimeLag(uint32_t timeLagInput) {
mkarlsso 2:298679fff37c 1564 timeLag = timeLagInput;
mkarlsso 2:298679fff37c 1565 timeLagIsConstant = true;
mkarlsso 2:298679fff37c 1566 }
mkarlsso 2:298679fff37c 1567
mkarlsso 2:298679fff37c 1568 void event::setTimeLag(int* timeLagInput) {
mkarlsso 2:298679fff37c 1569 timeLagVar = timeLagInput;
mkarlsso 2:298679fff37c 1570 timeLagIsConstant = false; //time lag is not defined by a constant
mkarlsso 2:298679fff37c 1571 }
mkarlsso 2:298679fff37c 1572
mkarlsso 2:298679fff37c 1573 void event::setWhileLoopPeriod(uint32_t period) {
mkarlsso 2:298679fff37c 1574 whileLoopPeriodIsConstant = true;
mkarlsso 2:298679fff37c 1575 hasWhileLoop = true;
mkarlsso 2:298679fff37c 1576 whileLoopPeriod = period;
mkarlsso 2:298679fff37c 1577
mkarlsso 2:298679fff37c 1578 }
mkarlsso 2:298679fff37c 1579
mkarlsso 2:298679fff37c 1580 void event::setWhileLoopPeriod(int* period) {
mkarlsso 2:298679fff37c 1581 whileLoopPeriodIsConstant = false;
mkarlsso 2:298679fff37c 1582 hasWhileLoop = true;
mkarlsso 2:298679fff37c 1583 whileLoopPeriodVar = period;
mkarlsso 2:298679fff37c 1584
mkarlsso 2:298679fff37c 1585 }
mkarlsso 2:298679fff37c 1586
mkarlsso 2:298679fff37c 1587 void event::addCondition(condition* conditionInput) {
mkarlsso 2:298679fff37c 1588 if (conditionToCheck != NULL) {
mkarlsso 2:298679fff37c 1589 conditionToCheck->release();
mkarlsso 2:298679fff37c 1590 }
mkarlsso 2:298679fff37c 1591 conditionToCheck = conditionInput;
mkarlsso 2:298679fff37c 1592
mkarlsso 2:298679fff37c 1593 //conditionArray.push_back(conditionInput);
mkarlsso 2:298679fff37c 1594 }
mkarlsso 2:298679fff37c 1595
mkarlsso 2:298679fff37c 1596 void event::addAction(action* actionInput) {
mkarlsso 2:298679fff37c 1597 actionArray[numActions] = actionInput;
mkarlsso 2:298679fff37c 1598 numActions++;
mkarlsso 2:298679fff37c 1599 //actionArray.push_back(actionInput);
mkarlsso 2:298679fff37c 1600 }
mkarlsso 2:298679fff37c 1601
mkarlsso 2:298679fff37c 1602 bool event::isConditionTrue(void) {
mkarlsso 2:298679fff37c 1603 //if statement (can be left empty, which is interpreted as 'true')
mkarlsso 2:298679fff37c 1604 //queuePtr->pcPtr->printf("Checking condition...\r\n");
mkarlsso 2:298679fff37c 1605 bool result = true;
mkarlsso 2:298679fff37c 1606 /*
mkarlsso 2:298679fff37c 1607 std::vector<condition*>::size_type sz = conditionArray.size();
mkarlsso 2:298679fff37c 1608 for (unsigned i = 0; i < sz; i++) {
mkarlsso 2:298679fff37c 1609 if (!conditionArray[i]->isTrue()) {
mkarlsso 2:298679fff37c 1610 result = false;
mkarlsso 2:298679fff37c 1611 //queuePtr->pcPtr->printf("Consition false\r\n");
mkarlsso 2:298679fff37c 1612 } //else {queuePtr->pcPtr->printf("Consition true\r\n");}
mkarlsso 2:298679fff37c 1613 }
mkarlsso 2:298679fff37c 1614 */
mkarlsso 2:298679fff37c 1615
mkarlsso 2:298679fff37c 1616 if ((conditionToCheck!=NULL)&&(!conditionToCheck->isTrue())) {
mkarlsso 2:298679fff37c 1617 result = false;
mkarlsso 2:298679fff37c 1618 }
mkarlsso 2:298679fff37c 1619
mkarlsso 2:298679fff37c 1620 return result;
mkarlsso 2:298679fff37c 1621 }
mkarlsso 2:298679fff37c 1622
mkarlsso 2:298679fff37c 1623 void event::execute(void) {
mkarlsso 2:298679fff37c 1624 //called from the event queue. The condition is bypassed because it was already checked
mkarlsso 2:298679fff37c 1625
mkarlsso 2:298679fff37c 1626
mkarlsso 2:298679fff37c 1627 uint32_t timeAtStartExec = *globalTimeKeeperPtr;
mkarlsso 2:298679fff37c 1628 //std::vector<action*>::size_type sz = actionArray.size();
mkarlsso 2:298679fff37c 1629
mkarlsso 2:298679fff37c 1630 /*
mkarlsso 2:298679fff37c 1631 std::deque<action*>::size_type sz = actionArray.size();
mkarlsso 2:298679fff37c 1632
mkarlsso 2:298679fff37c 1633 for (unsigned i = 0; i < sz; i++) {
mkarlsso 2:298679fff37c 1634 actionArray[i]->execute(timeAtStartExec);
mkarlsso 2:298679fff37c 1635
mkarlsso 2:298679fff37c 1636 }
mkarlsso 2:298679fff37c 1637 */
mkarlsso 2:298679fff37c 1638 for (unsigned i = 0; i < numActions; i++) {
mkarlsso 2:298679fff37c 1639 actionArray[i]->execute(timeAtStartExec);
mkarlsso 2:298679fff37c 1640
mkarlsso 2:298679fff37c 1641 }
mkarlsso 2:298679fff37c 1642
mkarlsso 2:298679fff37c 1643 }
mkarlsso 2:298679fff37c 1644
mkarlsso 2:298679fff37c 1645 //Attach an 'else' statement to the event
mkarlsso 2:298679fff37c 1646 void event::setNextElseEvent(event* eventInput) {
mkarlsso 2:298679fff37c 1647 nextElseEventPtr = eventInput;
mkarlsso 2:298679fff37c 1648 }
mkarlsso 2:298679fff37c 1649
mkarlsso 2:298679fff37c 1650
mkarlsso 2:298679fff37c 1651 //When we we call addToQueue() the condition is checked. If true, the event is added
mkarlsso 2:298679fff37c 1652 //to the queue, otherwise we check if there was an 'else' statement attached to the event.
mkarlsso 2:298679fff37c 1653 void event::addToQueue(void) {
mkarlsso 2:298679fff37c 1654 if (isConditionTrue()) {
mkarlsso 2:298679fff37c 1655 if ((timeLagIsConstant)&&(timeLag == 0)) {
mkarlsso 2:298679fff37c 1656 execute();
mkarlsso 2:298679fff37c 1657
mkarlsso 2:298679fff37c 1658 } else if (timeLagIsConstant) {
mkarlsso 2:298679fff37c 1659 queuePtr->addEventToQueue(this, this->timeLag);
mkarlsso 2:298679fff37c 1660 } else if ((!timeLagIsConstant)&&(*timeLagVar <= 0)) {
mkarlsso 2:298679fff37c 1661 execute();
mkarlsso 2:298679fff37c 1662 } else {
mkarlsso 2:298679fff37c 1663 queuePtr->addEventToQueue(this, *timeLagVar);
mkarlsso 2:298679fff37c 1664 }
mkarlsso 2:298679fff37c 1665 } else if ((this->nextElseEventPtr != NULL)&&(whileLoopPeriod == 0)) {
mkarlsso 2:298679fff37c 1666 this->nextElseEventPtr->addToQueue();
mkarlsso 2:298679fff37c 1667 }
mkarlsso 2:298679fff37c 1668 }
mkarlsso 2:298679fff37c 1669
mkarlsso 2:298679fff37c 1670 //We can override the timeLag field and use another delay
mkarlsso 2:298679fff37c 1671 void event::addToQueue(uint32_t delay) {
mkarlsso 2:298679fff37c 1672 if (this->isConditionTrue()) {
mkarlsso 2:298679fff37c 1673 //if ((delay == 0) && (whileLoopPeriod == 0)) {
mkarlsso 2:298679fff37c 1674 if ((delay == 0)) {
mkarlsso 2:298679fff37c 1675 this->execute();
mkarlsso 2:298679fff37c 1676 } else {
mkarlsso 2:298679fff37c 1677 queuePtr->addEventToQueue(this, delay);
mkarlsso 2:298679fff37c 1678 }
mkarlsso 2:298679fff37c 1679 } else if ((this->nextElseEventPtr != NULL)) { //&&(!hasWhileLoop)) {
mkarlsso 2:298679fff37c 1680 this->nextElseEventPtr->addToQueue();
mkarlsso 2:298679fff37c 1681 }
mkarlsso 2:298679fff37c 1682 }
mkarlsso 2:298679fff37c 1683
mkarlsso 2:298679fff37c 1684
mkarlsso 2:298679fff37c 1685
mkarlsso 2:298679fff37c 1686 functionItem::functionItem(action* actionInput, string tagInput):
mkarlsso 2:298679fff37c 1687 tag(tagInput),
mkarlsso 2:298679fff37c 1688 actionPtr(actionInput) {
mkarlsso 2:298679fff37c 1689 }
mkarlsso 2:298679fff37c 1690
mkarlsso 2:298679fff37c 1691 functionItem::~functionItem() {
mkarlsso 2:298679fff37c 1692 delete actionPtr;
mkarlsso 2:298679fff37c 1693 }
mkarlsso 2:298679fff37c 1694
mkarlsso 2:298679fff37c 1695 scriptStream::scriptStream(Serial* serialInput, digitalPort** portVectorInput, int numPortsInput, eventQueue* queueInput):
mkarlsso 2:298679fff37c 1696 portVector(portVectorInput),
mkarlsso 2:298679fff37c 1697 numPorts(numPortsInput),
mkarlsso 2:298679fff37c 1698 pcPtr(serialInput),
mkarlsso 2:298679fff37c 1699 queuePtr(queueInput) {
mkarlsso 2:298679fff37c 1700
mkarlsso 2:298679fff37c 1701 currentPort = -1;
mkarlsso 2:298679fff37c 1702 currentTriggerPort = -1;
mkarlsso 2:298679fff37c 1703 currentTriggerDir = 1;
mkarlsso 2:298679fff37c 1704 currentFunction = -1;
alustig3 5:4d6575e3a07e 1705
alustig3 5:4d6575e3a07e 1706 lineError = false;
alustig3 5:4d6575e3a07e 1707 blockDepth = 0;
alustig3 5:4d6575e3a07e 1708 ifBlockInit = false;
alustig3 5:4d6575e3a07e 1709 whileBlockInit = false;
alustig3 5:4d6575e3a07e 1710 elseFlag = false;
alustig3 5:4d6575e3a07e 1711 currentDelay = 0;
mkarlsso 4:34aca2142df9 1712
alustig3 5:4d6575e3a07e 1713 }
alustig3 5:4d6575e3a07e 1714
alustig3 5:4d6575e3a07e 1715 void scriptStream::addLineToCurrentBlock(char* lineInput) {
mkarlsso 2:298679fff37c 1716
alustig3 5:4d6575e3a07e 1717 bool compile = false;
alustig3 5:4d6575e3a07e 1718 bool keep = false;
alustig3 5:4d6575e3a07e 1719 for (int i = 0; i < 128; i++) {
alustig3 5:4d6575e3a07e 1720 if (lineInput[i] == ';') {
alustig3 5:4d6575e3a07e 1721 compile = true;
alustig3 5:4d6575e3a07e 1722 } else if (lineInput[i] == ' ') {
alustig3 5:4d6575e3a07e 1723 continue;
alustig3 5:4d6575e3a07e 1724 } else if (lineInput[i] == '\0') {
alustig3 5:4d6575e3a07e 1725 break;
alustig3 5:4d6575e3a07e 1726 } else {
alustig3 5:4d6575e3a07e 1727 keep = true;
alustig3 5:4d6575e3a07e 1728 compile = false;
alustig3 5:4d6575e3a07e 1729 }
alustig3 5:4d6575e3a07e 1730 }
alustig3 5:4d6575e3a07e 1731 if (keep) currentBlock.insert(currentBlock.begin(),string(lineInput));
alustig3 5:4d6575e3a07e 1732 if (compile) parseBlock();
alustig3 5:4d6575e3a07e 1733
alustig3 5:4d6575e3a07e 1734 }
alustig3 5:4d6575e3a07e 1735
alustig3 5:4d6575e3a07e 1736
alustig3 5:4d6575e3a07e 1737 //SCRIPT PARSING - all script commands are defined here.
alustig3 5:4d6575e3a07e 1738 //-------------------------------------------------------
alustig3 5:4d6575e3a07e 1739 void scriptStream::parseBlock() {
alustig3 5:4d6575e3a07e 1740
mkarlsso 2:298679fff37c 1741 lineError = false;
mkarlsso 2:298679fff37c 1742 blockDepth = 0;
mkarlsso 2:298679fff37c 1743 ifBlockInit = false;
mkarlsso 2:298679fff37c 1744 whileBlockInit = false;
mkarlsso 2:298679fff37c 1745 elseFlag = false;
mkarlsso 4:34aca2142df9 1746 thenFlag = false;
mkarlsso 2:298679fff37c 1747 currentDelay = 0;
mkarlsso 2:298679fff37c 1748
mkarlsso 2:298679fff37c 1749 std::size_t stringInd = 0;
mkarlsso 2:298679fff37c 1750
mkarlsso 2:298679fff37c 1751 bool wholeLineEvaluated = false;
mkarlsso 2:298679fff37c 1752
mkarlsso 2:298679fff37c 1753 //pcPtr->printf("\r\n");
mkarlsso 2:298679fff37c 1754 while (!currentBlock.empty()) {
mkarlsso 2:298679fff37c 1755 wholeLineEvaluated = false;
alustig3 5:4d6575e3a07e 1756 tmpLine = currentBlock.back();
mkarlsso 2:298679fff37c 1757 lineError = false;
mkarlsso 2:298679fff37c 1758 //remove tabs
mkarlsso 2:298679fff37c 1759 std::size_t found = tmpLine.find_first_of(9); //tab
mkarlsso 2:298679fff37c 1760 while (found!=std::string::npos) {
mkarlsso 2:298679fff37c 1761 tmpLine[found]= ' ';
mkarlsso 2:298679fff37c 1762 found=tmpLine.find_first_of(9,found+1);
mkarlsso 2:298679fff37c 1763 }
mkarlsso 2:298679fff37c 1764
mkarlsso 2:298679fff37c 1765 found = tmpLine.find_first_of(37); //% for commenting
mkarlsso 2:298679fff37c 1766 if (found!=std::string::npos) {
mkarlsso 2:298679fff37c 1767 for (int p=found; p<tmpLine.size() ;p++) {
mkarlsso 2:298679fff37c 1768 tmpLine[p]= ' ';
mkarlsso 2:298679fff37c 1769 }
mkarlsso 2:298679fff37c 1770 }
mkarlsso 2:298679fff37c 1771
mkarlsso 2:298679fff37c 1772 //break up the line into tokens separated by spaces
mkarlsso 2:298679fff37c 1773 tokenize(tmpLine,tokens," ;");
mkarlsso 2:298679fff37c 1774
mkarlsso 2:298679fff37c 1775 std::vector<string>::size_type sz = tokens.size();
mkarlsso 2:298679fff37c 1776
mkarlsso 2:298679fff37c 1777 for (unsigned i = 0; i < sz; i++) {
mkarlsso 2:298679fff37c 1778 //pcPtr->printf("%s", tokens[i].c_str());
mkarlsso 2:298679fff37c 1779
mkarlsso 2:298679fff37c 1780
mkarlsso 2:298679fff37c 1781 //end statement signals the end of a block-----------------------------------------
mkarlsso 2:298679fff37c 1782 if (tokens[i].compare("end") == 0) { //ends the current block
mkarlsso 2:298679fff37c 1783
mkarlsso 2:298679fff37c 1784 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 1785 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 1786 lineError = true;
mkarlsso 2:298679fff37c 1787 }
mkarlsso 2:298679fff37c 1788
mkarlsso 2:298679fff37c 1789 ifBlockInit = false;
mkarlsso 2:298679fff37c 1790 whileBlockInit = false;
mkarlsso 2:298679fff37c 1791 elseFlag = false;
mkarlsso 2:298679fff37c 1792
mkarlsso 2:298679fff37c 1793 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 1794 if (blockDepth == 1) {
mkarlsso 2:298679fff37c 1795
mkarlsso 2:298679fff37c 1796
mkarlsso 2:298679fff37c 1797 //pcPtr->printf("Close trigger block for port %d\r\n",currentTriggerPort);
mkarlsso 2:298679fff37c 1798 currentTriggerPort = -1;
mkarlsso 2:298679fff37c 1799
mkarlsso 2:298679fff37c 1800
mkarlsso 2:298679fff37c 1801
mkarlsso 2:298679fff37c 1802 blockDepth = 0;
mkarlsso 2:298679fff37c 1803 } else if (blockDepth > 1) {
mkarlsso 2:298679fff37c 1804 //pcPtr->printf("Close block\r\n");
mkarlsso 2:298679fff37c 1805 blockDepth = blockDepth - 1;
mkarlsso 2:298679fff37c 1806 }
mkarlsso 2:298679fff37c 1807
mkarlsso 2:298679fff37c 1808 while ((tmpEventPtrArray.back()->blockType == 3) || (tmpEventPtrArray.back()->blockType == 4)){
mkarlsso 2:298679fff37c 1809 tmpEventPtrArray.pop_back(); //recursively remove the pointers to all else blocks
mkarlsso 2:298679fff37c 1810 }
mkarlsso 2:298679fff37c 1811 tmpEventPtrArray.pop_back(); //remove the pointer to the finished block
mkarlsso 2:298679fff37c 1812 } else {
mkarlsso 2:298679fff37c 1813 pcPtr->printf("Error: End statement without block\r\n");
mkarlsso 2:298679fff37c 1814 lineError = true;
mkarlsso 2:298679fff37c 1815 }
mkarlsso 2:298679fff37c 1816
mkarlsso 2:298679fff37c 1817
mkarlsso 2:298679fff37c 1818
mkarlsso 2:298679fff37c 1819 //sound statement used to play wave files------------------------------------------------
mkarlsso 2:298679fff37c 1820 //example: sound('soundfile')
mkarlsso 2:298679fff37c 1821 // sound(stop)
mkarlsso 2:298679fff37c 1822 } else if (tokens[i].find("sound(") != std::string::npos) {
mkarlsso 2:298679fff37c 1823 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 1824 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 1825 lineError = true;
mkarlsso 2:298679fff37c 1826 }
mkarlsso 2:298679fff37c 1827 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 1828 int pos1 = tmpLine.find("sound(")+6;
mkarlsso 2:298679fff37c 1829 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 1830 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 1831
mkarlsso 2:298679fff37c 1832 int* tmpVar = findIntVariable(dispVar);
mkarlsso 2:298679fff37c 1833 bool isText = false;
mkarlsso 2:298679fff37c 1834 bool stopSignal = false;
mkarlsso 2:298679fff37c 1835 bool resetSignal = false;
mkarlsso 2:298679fff37c 1836 if (tmpVar == NULL) {
mkarlsso 2:298679fff37c 1837 if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso 2:298679fff37c 1838 isText = true;
mkarlsso 2:298679fff37c 1839 } else if (dispVar.compare("stop") == 0) {
mkarlsso 2:298679fff37c 1840 stopSignal = true;
mkarlsso 2:298679fff37c 1841 } else if (dispVar.compare("reset") == 0) {
mkarlsso 2:298679fff37c 1842 resetSignal = true;
mkarlsso 2:298679fff37c 1843 } else {
mkarlsso 2:298679fff37c 1844 pcPtr->printf("Error: variable input to sound() does not exist\r\n");
mkarlsso 2:298679fff37c 1845 lineError = true;
mkarlsso 2:298679fff37c 1846 }
mkarlsso 2:298679fff37c 1847 }
mkarlsso 2:298679fff37c 1848 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 1849 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 1850 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 1851 lineError = true;
mkarlsso 2:298679fff37c 1852 }
mkarlsso 2:298679fff37c 1853 if (!lineError && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 1854 //we are not inside a block structure, so play sound now
mkarlsso 2:298679fff37c 1855 if (stopSignal) {
mkarlsso 2:298679fff37c 1856 soundControl S;
mkarlsso 2:298679fff37c 1857 S.setPlayback(false);
mkarlsso 2:298679fff37c 1858 S.execute();
mkarlsso 2:298679fff37c 1859 } else if (resetSignal) {
mkarlsso 2:298679fff37c 1860 soundControl S;
mkarlsso 2:298679fff37c 1861 S.setReset();
mkarlsso 2:298679fff37c 1862 S.execute();
mkarlsso 2:298679fff37c 1863 } else if (isText) {
mkarlsso 2:298679fff37c 1864
mkarlsso 2:298679fff37c 1865 if (pos2-pos1-2 <= 20) {
mkarlsso 2:298679fff37c 1866
mkarlsso 2:298679fff37c 1867 soundControl S;
mkarlsso 2:298679fff37c 1868 S.setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 2:298679fff37c 1869 S.execute();
mkarlsso 2:298679fff37c 1870 } else {
mkarlsso 2:298679fff37c 1871 pcPtr->printf("Error: sound file names must be 20 characters or less.\r\n");
mkarlsso 2:298679fff37c 1872 lineError = true;
mkarlsso 2:298679fff37c 1873 }
mkarlsso 2:298679fff37c 1874 } else {
mkarlsso 2:298679fff37c 1875 pcPtr->printf("Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n");
mkarlsso 2:298679fff37c 1876 lineError = true;
mkarlsso 2:298679fff37c 1877 }
mkarlsso 2:298679fff37c 1878
mkarlsso 2:298679fff37c 1879 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 2:298679fff37c 1880 //the disp function was put inside a block
mkarlsso 2:298679fff37c 1881 if (stopSignal) {
mkarlsso 2:298679fff37c 1882 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1883 sPtr->setPlayback(false);
mkarlsso 2:298679fff37c 1884 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1885 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1886 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1887 } else if (resetSignal) {
mkarlsso 2:298679fff37c 1888 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1889 sPtr->setReset();
mkarlsso 2:298679fff37c 1890 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1891 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1892 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1893 } else if (isText) {
mkarlsso 2:298679fff37c 1894
mkarlsso 2:298679fff37c 1895 if (pos2-pos1-2 <= 20) {
mkarlsso 2:298679fff37c 1896 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1897 sPtr->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 2:298679fff37c 1898 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1899 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1900 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1901 } else {
mkarlsso 2:298679fff37c 1902 pcPtr->printf("Error: sound file names must be 20 characters or less.\r\n");
mkarlsso 2:298679fff37c 1903 lineError = true;
mkarlsso 2:298679fff37c 1904 }
mkarlsso 2:298679fff37c 1905 } else {
mkarlsso 2:298679fff37c 1906 pcPtr->printf("Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n");
mkarlsso 2:298679fff37c 1907 lineError = true;
mkarlsso 2:298679fff37c 1908 }
mkarlsso 2:298679fff37c 1909
mkarlsso 2:298679fff37c 1910 //pcPtr->printf("Sound action\r\n");
mkarlsso 2:298679fff37c 1911 }
mkarlsso 2:298679fff37c 1912
mkarlsso 2:298679fff37c 1913 } else if (tokens[i].find("volume(") != std::string::npos) {
mkarlsso 2:298679fff37c 1914 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 1915 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 1916 lineError = true;
mkarlsso 2:298679fff37c 1917 }
mkarlsso 2:298679fff37c 1918 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 1919 int pos1 = tmpLine.find("volume(")+7;
mkarlsso 2:298679fff37c 1920 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 1921 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 1922
mkarlsso 2:298679fff37c 1923 int* tmpVar = findIntVariable(dispVar);
mkarlsso 2:298679fff37c 1924 bool isText = false;
mkarlsso 2:298679fff37c 1925 if (tmpVar == NULL) {
mkarlsso 2:298679fff37c 1926 if (isNumber(dispVar)) {
mkarlsso 2:298679fff37c 1927 isText = true;
mkarlsso 2:298679fff37c 1928 } else {
mkarlsso 2:298679fff37c 1929 pcPtr->printf("Error: variable input to volume() does not exist\r\n");
mkarlsso 2:298679fff37c 1930 lineError = true;
mkarlsso 2:298679fff37c 1931 }
mkarlsso 2:298679fff37c 1932 }
mkarlsso 2:298679fff37c 1933 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 1934 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 1935 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 1936 lineError = true;
mkarlsso 2:298679fff37c 1937 }
mkarlsso 2:298679fff37c 1938 if (!lineError && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 1939 //we are not inside a block structure, so play sound now
mkarlsso 2:298679fff37c 1940 if (isText) {
mkarlsso 2:298679fff37c 1941 int newVolume = atoi(dispVar.data());
mkarlsso 2:298679fff37c 1942 if ((newVolume >=0)&&(newVolume <= 255)) {
mkarlsso 2:298679fff37c 1943 soundControl S;
mkarlsso 2:298679fff37c 1944 S.setVolume(newVolume);
mkarlsso 2:298679fff37c 1945 S.execute();
mkarlsso 2:298679fff37c 1946 } else {
mkarlsso 2:298679fff37c 1947 pcPtr->printf("Error: sound volume must be between 0 and 255 .\r\n");
mkarlsso 2:298679fff37c 1948 lineError = true;
mkarlsso 2:298679fff37c 1949 }
mkarlsso 2:298679fff37c 1950 } else {
mkarlsso 2:298679fff37c 1951 soundControl S;
mkarlsso 2:298679fff37c 1952 S.setVolume(tmpVar);
mkarlsso 2:298679fff37c 1953 S.execute();
mkarlsso 2:298679fff37c 1954 }
mkarlsso 2:298679fff37c 1955
mkarlsso 2:298679fff37c 1956 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 2:298679fff37c 1957 //the disp function was put inside a block
mkarlsso 2:298679fff37c 1958 if (isText) {
mkarlsso 2:298679fff37c 1959 int newVolume = atoi(dispVar.data());
mkarlsso 2:298679fff37c 1960
mkarlsso 2:298679fff37c 1961 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1962 sPtr->setVolume(newVolume);
mkarlsso 2:298679fff37c 1963
mkarlsso 2:298679fff37c 1964 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1965 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1966 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1967
mkarlsso 2:298679fff37c 1968 } else {
mkarlsso 2:298679fff37c 1969 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1970 sPtr->setVolume(tmpVar);
mkarlsso 2:298679fff37c 1971 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1972 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1973 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1974 }
mkarlsso 2:298679fff37c 1975
mkarlsso 2:298679fff37c 1976 //pcPtr->printf("Volume action\r\n");
mkarlsso 2:298679fff37c 1977 }
mkarlsso 2:298679fff37c 1978 //clock statement used to is used to control the clock-------------------------
mkarlsso 2:298679fff37c 1979 //example: clock(reset); clock(slave); clock(standalone)
mkarlsso 2:298679fff37c 1980 } else if (tokens[i].find("clock(") != std::string::npos) { //clock commands
mkarlsso 2:298679fff37c 1981 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 1982 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 1983 lineError = true;
mkarlsso 2:298679fff37c 1984 }
mkarlsso 2:298679fff37c 1985 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 1986 pcPtr->printf("Error: clock commands only allowed outside of block structure\r\n");
mkarlsso 2:298679fff37c 1987 lineError = true;
mkarlsso 2:298679fff37c 1988 }
mkarlsso 2:298679fff37c 1989
mkarlsso 2:298679fff37c 1990 if (!lineError) {
mkarlsso 2:298679fff37c 1991 int pos1 = tmpLine.find("clock(")+6;
mkarlsso 2:298679fff37c 1992 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 1993 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 1994
mkarlsso 2:298679fff37c 1995
mkarlsso 2:298679fff37c 1996 if (blockDepth == 0) {
mkarlsso 2:298679fff37c 1997 if (dispVar.compare("reset") == 0) {
mkarlsso 2:298679fff37c 1998 resetTimer = true;
mkarlsso 2:298679fff37c 1999 queuePtr->eraseQueue();
mkarlsso 2:298679fff37c 2000 textDisplay.send(string("Clock reset to 0\r\n"));
mkarlsso 2:298679fff37c 2001 //pcPtr->printf("Clock reset to 0\r\n");
mkarlsso 2:298679fff37c 2002 } else if (dispVar.compare("slave") == 0) {
mkarlsso 2:298679fff37c 2003 if (!clockSlave) {
mkarlsso 2:298679fff37c 2004 changeToSlave = true;
mkarlsso 2:298679fff37c 2005 textDisplay.send(string("Slave mode\r\n"));
mkarlsso 2:298679fff37c 2006 //pcPtr->printf("Slave mode\r\n");
mkarlsso 2:298679fff37c 2007 }
mkarlsso 2:298679fff37c 2008 } else if (dispVar.compare("standalone") == 0) {
mkarlsso 2:298679fff37c 2009 if (clockSlave) {
mkarlsso 2:298679fff37c 2010 changeToStandAlone = true;
mkarlsso 2:298679fff37c 2011 textDisplay.send(string("Standalone mode\r\n"));
mkarlsso 2:298679fff37c 2012 //pcPtr->printf("Standalone mode\r\n");
mkarlsso 2:298679fff37c 2013 }
mkarlsso 2:298679fff37c 2014 } else {
mkarlsso 2:298679fff37c 2015 pcPtr->printf("Clock control statement not understood\r\n");
mkarlsso 2:298679fff37c 2016 lineError = true;
mkarlsso 2:298679fff37c 2017 }
mkarlsso 2:298679fff37c 2018 }
mkarlsso 2:298679fff37c 2019 }
mkarlsso 2:298679fff37c 2020
mkarlsso 2:298679fff37c 2021 //disp command used to display text via serial---------------------------------------
mkarlsso 2:298679fff37c 2022 //example: disp('hello'); disp(myVar)
mkarlsso 2:298679fff37c 2023 } else if (tokens[i].find("disp(") != std::string::npos) { //display value of variable
mkarlsso 2:298679fff37c 2024
mkarlsso 2:298679fff37c 2025 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2026 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2027 lineError = true;
mkarlsso 2:298679fff37c 2028 }
mkarlsso 2:298679fff37c 2029
mkarlsso 2:298679fff37c 2030 //int pos1 = tokens[i].find("disp(")+5;
mkarlsso 2:298679fff37c 2031 //int pos2 = tokens[i].find_first_of(")",pos1);
mkarlsso 2:298679fff37c 2032 //string dispVar = tokens[i].substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 2033
mkarlsso 2:298679fff37c 2034 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2035 int pos1 = tmpLine.find("disp(")+5;
mkarlsso 2:298679fff37c 2036 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 2037 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 2038
mkarlsso 2:298679fff37c 2039 int* tmpVar = findIntVariable(dispVar);
mkarlsso 2:298679fff37c 2040 bool isText = false;
mkarlsso 2:298679fff37c 2041 if (tmpVar == NULL) {
mkarlsso 2:298679fff37c 2042 if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso 2:298679fff37c 2043 isText = true;
mkarlsso 2:298679fff37c 2044 } else {
mkarlsso 2:298679fff37c 2045 pcPtr->printf("Error: variable to display does not exist\r\n");
mkarlsso 2:298679fff37c 2046 lineError = true;
mkarlsso 2:298679fff37c 2047 }
mkarlsso 2:298679fff37c 2048 }
mkarlsso 2:298679fff37c 2049 displayAction* dPtr = findFirstUnUsed(displayActionBlock, NUMDISPLAYACTIONS);
mkarlsso 2:298679fff37c 2050 if (dPtr == NULL) {
mkarlsso 2:298679fff37c 2051 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2052 lineError = true;
mkarlsso 2:298679fff37c 2053 }
mkarlsso 2:298679fff37c 2054 if (!lineError && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 2055 //we are not inside a block structure, so display now
mkarlsso 2:298679fff37c 2056
mkarlsso 2:298679fff37c 2057 if (isText) {
mkarlsso 2:298679fff37c 2058 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2059 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2060 dPtr->execute();
mkarlsso 2:298679fff37c 2061 //delete dPtr;
mkarlsso 2:298679fff37c 2062 dPtr->release();
mkarlsso 2:298679fff37c 2063 } else {
mkarlsso 2:298679fff37c 2064 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2065 dPtr->set(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2066 dPtr->execute();
mkarlsso 2:298679fff37c 2067 //delete dPtr;
mkarlsso 2:298679fff37c 2068 dPtr->release();
mkarlsso 2:298679fff37c 2069 }
mkarlsso 2:298679fff37c 2070
mkarlsso 2:298679fff37c 2071 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 2:298679fff37c 2072 //the disp function was put inside a block
mkarlsso 2:298679fff37c 2073 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2074 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2075 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2076 lineError = true;
mkarlsso 2:298679fff37c 2077 }
mkarlsso 2:298679fff37c 2078 if (!lineError && isText) {
mkarlsso 2:298679fff37c 2079 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2080 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2081 tmpAction->set(dPtr);
mkarlsso 2:298679fff37c 2082 //action* tmpAction = new action(dPtr);
mkarlsso 2:298679fff37c 2083 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2084 } else if (!lineError) {
mkarlsso 2:298679fff37c 2085 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2086 dPtr->set(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2087 tmpAction->set(dPtr);
mkarlsso 2:298679fff37c 2088 //action* tmpAction = new action(dPtr);
mkarlsso 2:298679fff37c 2089 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2090 }
mkarlsso 2:298679fff37c 2091
mkarlsso 2:298679fff37c 2092 //pcPtr->printf("Display action\r\n");
mkarlsso 2:298679fff37c 2093 }
mkarlsso 2:298679fff37c 2094
mkarlsso 2:298679fff37c 2095
mkarlsso 2:298679fff37c 2096 //int is used to decalar new variables. Only allowed outside of callbacks-------------------
mkarlsso 2:298679fff37c 2097 //example: int a; int b = 9
mkarlsso 2:298679fff37c 2098 } else if (tokens[i].compare("int") == 0) { //define a new integer variable
mkarlsso 2:298679fff37c 2099
mkarlsso 2:298679fff37c 2100 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2101 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2102 lineError = true;
mkarlsso 2:298679fff37c 2103 }
mkarlsso 2:298679fff37c 2104 tmpString = "";
mkarlsso 2:298679fff37c 2105 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2106 int spacesBeforeEqualSign = 0;
mkarlsso 2:298679fff37c 2107 bool countSpaces = true;
mkarlsso 2:298679fff37c 2108 //combine the tokens without whitespaces
mkarlsso 2:298679fff37c 2109 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 2:298679fff37c 2110 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2111 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 2:298679fff37c 2112 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2113 countSpaces = false;
mkarlsso 2:298679fff37c 2114 } else if (countSpaces) {
mkarlsso 2:298679fff37c 2115 spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2116 }
mkarlsso 2:298679fff37c 2117 }
mkarlsso 2:298679fff37c 2118
mkarlsso 2:298679fff37c 2119 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 2120 pcPtr->printf("Error: Variables can only be first declared outside of callbacks.\r\n");
mkarlsso 2:298679fff37c 2121 lineError = true;
mkarlsso 2:298679fff37c 2122 }
mkarlsso 2:298679fff37c 2123
mkarlsso 2:298679fff37c 2124 if ((!lineError) && (spacesBeforeEqualSign > 1)) {
mkarlsso 2:298679fff37c 2125 pcPtr->printf("Error: Variable can't have a space in it.\r\n");
mkarlsso 2:298679fff37c 2126 lineError = true;
mkarlsso 2:298679fff37c 2127 }
mkarlsso 2:298679fff37c 2128 stringInd = tmpString.find_first_of("=");
mkarlsso 2:298679fff37c 2129
mkarlsso 2:298679fff37c 2130 bool variableCreated = false;
mkarlsso 2:298679fff37c 2131 if (!lineError) {
mkarlsso 2:298679fff37c 2132 if (((stringInd == std::string::npos) && (sz == 2)) || (stringInd != std::string::npos)) {
mkarlsso 2:298679fff37c 2133 if (createIntVariable(tmpString.substr(0,stringInd))) {
mkarlsso 2:298679fff37c 2134 //pcPtr->printf("Created variable: %s\r\n", tmpString.substr(0,stringInd).data());
mkarlsso 2:298679fff37c 2135 variableCreated = true;
mkarlsso 2:298679fff37c 2136 } else {
mkarlsso 2:298679fff37c 2137 int* tmpVar = findIntVariable(tmpString.substr(0,stringInd));
mkarlsso 2:298679fff37c 2138 *tmpVar = 0;
mkarlsso 2:298679fff37c 2139 //pcPtr->printf("Reset variable %s to 0\r\n", tmpString.substr(0,stringInd).data());
mkarlsso 2:298679fff37c 2140 //lineError = true;
mkarlsso 2:298679fff37c 2141 }
mkarlsso 2:298679fff37c 2142 } else {
mkarlsso 2:298679fff37c 2143 pcPtr->printf("Error: variable declaration not understood.\r\n", tmpString.substr(0,stringInd).data());
mkarlsso 2:298679fff37c 2144 lineError = true;
mkarlsso 2:298679fff37c 2145 }
mkarlsso 2:298679fff37c 2146 }
mkarlsso 2:298679fff37c 2147
mkarlsso 2:298679fff37c 2148 if ((!lineError) && (stringInd != std::string::npos)) { //evaluate the expression
mkarlsso 2:298679fff37c 2149 action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 2:298679fff37c 2150 if (tmpAction != NULL) {
mkarlsso 2:298679fff37c 2151 tmpAction->execute();
mkarlsso 2:298679fff37c 2152 //delete tmpAction;
mkarlsso 2:298679fff37c 2153 tmpAction->release();
mkarlsso 2:298679fff37c 2154 } else {
mkarlsso 2:298679fff37c 2155 lineError = true;
mkarlsso 2:298679fff37c 2156 if (variableCreated) {
mkarlsso 2:298679fff37c 2157 delete globalVariables.back();
mkarlsso 2:298679fff37c 2158 globalVariables.pop_back();
mkarlsso 2:298679fff37c 2159 }
mkarlsso 2:298679fff37c 2160 }
mkarlsso 2:298679fff37c 2161 }
mkarlsso 2:298679fff37c 2162
mkarlsso 2:298679fff37c 2163 //serial command is used to toggle whether or not to buffer up output text----------------
mkarlsso 2:298679fff37c 2164 //examples: serial buffer; serial send
mkarlsso 2:298679fff37c 2165 } else if (tokens[i].compare("serial") == 0) {
mkarlsso 2:298679fff37c 2166 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2167 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2168 lineError = true;
mkarlsso 2:298679fff37c 2169 }
mkarlsso 2:298679fff37c 2170 bool stream = true;
mkarlsso 2:298679fff37c 2171 if ((!lineError)&&(i+1 < sz)){
mkarlsso 2:298679fff37c 2172 if (tokens[i+1].compare("buffer") == 0) {
mkarlsso 2:298679fff37c 2173 stream = false;
mkarlsso 2:298679fff37c 2174 } else if (tokens[i+1].compare("send") == 0) {
mkarlsso 2:298679fff37c 2175 stream = true;
mkarlsso 2:298679fff37c 2176 } else {
mkarlsso 2:298679fff37c 2177 pcPtr->printf("Error: 'serial' useage: 'serial buffer' or 'serial send'\r\n");
mkarlsso 2:298679fff37c 2178 lineError = true;
mkarlsso 2:298679fff37c 2179 }
mkarlsso 2:298679fff37c 2180 }
mkarlsso 2:298679fff37c 2181 i++;
mkarlsso 2:298679fff37c 2182 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 2183 if (stream) {
mkarlsso 2:298679fff37c 2184 textStreaming = true;
mkarlsso 2:298679fff37c 2185 } else {
mkarlsso 2:298679fff37c 2186 textStreaming = false;
mkarlsso 2:298679fff37c 2187 }
mkarlsso 2:298679fff37c 2188 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2189 if (stream) {
mkarlsso 2:298679fff37c 2190 //action* tmpAction = new action(1); //code 1 = turn on text streaming
mkarlsso 2:298679fff37c 2191 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2192 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2193 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2194 lineError = true;
mkarlsso 2:298679fff37c 2195 } else {
mkarlsso 2:298679fff37c 2196 tmpAction->set(1);
mkarlsso 2:298679fff37c 2197 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2198 }
mkarlsso 2:298679fff37c 2199
mkarlsso 2:298679fff37c 2200 } else {
mkarlsso 2:298679fff37c 2201 //action* tmpAction = new action(2); //code 2 = turn on text buffering
mkarlsso 2:298679fff37c 2202 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2203 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2204 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2205 lineError = true;
mkarlsso 2:298679fff37c 2206 } else {
mkarlsso 2:298679fff37c 2207 tmpAction->set(2);
mkarlsso 2:298679fff37c 2208 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2209 }
mkarlsso 2:298679fff37c 2210 }
mkarlsso 2:298679fff37c 2211 }
mkarlsso 2:298679fff37c 2212
mkarlsso 2:298679fff37c 2213 //updates command toggles the DIO update messages upon a change------------------
mkarlsso 2:298679fff37c 2214 //examples: updates on; updates off
mkarlsso 2:298679fff37c 2215 } else if (tokens[i].compare("updates") == 0) {
mkarlsso 2:298679fff37c 2216 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2217 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2218 lineError = true;
mkarlsso 2:298679fff37c 2219 }
mkarlsso 2:298679fff37c 2220 bool stream = true;
mkarlsso 2:298679fff37c 2221 if ((!lineError)&&(i+1 < sz)){
mkarlsso 2:298679fff37c 2222 if (tokens[i+1].compare("on") == 0) {
mkarlsso 2:298679fff37c 2223 stream = true;
mkarlsso 2:298679fff37c 2224 } else if (tokens[i+1].compare("off") == 0) {
mkarlsso 2:298679fff37c 2225 stream = false;
mkarlsso 2:298679fff37c 2226 } else {
mkarlsso 2:298679fff37c 2227 pcPtr->printf("Error: 'updates' useage: 'updates on' or 'updates off'\r\n");
mkarlsso 2:298679fff37c 2228 lineError = true;
mkarlsso 2:298679fff37c 2229 }
mkarlsso 2:298679fff37c 2230 }
mkarlsso 2:298679fff37c 2231 i++;
mkarlsso 2:298679fff37c 2232 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 2233 if (stream) {
mkarlsso 2:298679fff37c 2234 broadCastStateChanges = true;
mkarlsso 2:298679fff37c 2235 } else {
mkarlsso 2:298679fff37c 2236 broadCastStateChanges = false;
mkarlsso 2:298679fff37c 2237 }
mkarlsso 2:298679fff37c 2238 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2239 if (stream) {
mkarlsso 2:298679fff37c 2240 //action* tmpAction = new action(3); //code 3 = turn on updates
mkarlsso 2:298679fff37c 2241 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2242 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2243 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2244 lineError = true;
mkarlsso 2:298679fff37c 2245 } else {
mkarlsso 2:298679fff37c 2246 tmpAction->set(3);
mkarlsso 2:298679fff37c 2247 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2248 }
mkarlsso 2:298679fff37c 2249 } else {
mkarlsso 2:298679fff37c 2250 //action* tmpAction = new action(4); //code 4 = turn off updates
mkarlsso 2:298679fff37c 2251 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2252 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2253 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2254 lineError = true;
mkarlsso 2:298679fff37c 2255 } else {
mkarlsso 2:298679fff37c 2256 tmpAction->set(4);
mkarlsso 2:298679fff37c 2257 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2258 }
mkarlsso 2:298679fff37c 2259
mkarlsso 2:298679fff37c 2260 }
mkarlsso 2:298679fff37c 2261 }
mkarlsso 2:298679fff37c 2262
mkarlsso 2:298679fff37c 2263 //clear is used to clear things from memory---------------------------------
mkarlsso 2:298679fff37c 2264 //examples: clear all; clear callbacks; clear queue
mkarlsso 2:298679fff37c 2265 } else if (tokens[i].compare("ram") == 0) {
mkarlsso 2:298679fff37c 2266 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2267 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2268 lineError = true;
mkarlsso 2:298679fff37c 2269 }
mkarlsso 2:298679fff37c 2270 if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2271 pcPtr->printf("Error: ram statement is not allowed inside a block.\r\n");
mkarlsso 2:298679fff37c 2272 lineError = true;
mkarlsso 2:298679fff37c 2273 }
mkarlsso 2:298679fff37c 2274 if (!lineError) {
mkarlsso 2:298679fff37c 2275 DisplayRAMBanks();
mkarlsso 2:298679fff37c 2276 }
mkarlsso 2:298679fff37c 2277 } else if (tokens[i].compare("memory") == 0) {
mkarlsso 2:298679fff37c 2278 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2279 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2280 lineError = true;
mkarlsso 2:298679fff37c 2281 }
mkarlsso 2:298679fff37c 2282 if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2283 pcPtr->printf("Error: memory statement is not allowed inside a block.\r\n");
mkarlsso 2:298679fff37c 2284 lineError = true;
mkarlsso 2:298679fff37c 2285 }
mkarlsso 2:298679fff37c 2286 if (!lineError) {
mkarlsso 2:298679fff37c 2287 displayMemoryLeft();
mkarlsso 2:298679fff37c 2288 }
mkarlsso 2:298679fff37c 2289
mkarlsso 2:298679fff37c 2290
mkarlsso 2:298679fff37c 2291 } else if (tokens[i].compare("clear") == 0) { //delete all created events and variables
mkarlsso 2:298679fff37c 2292 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2293 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2294 lineError = true;
mkarlsso 2:298679fff37c 2295 }
mkarlsso 2:298679fff37c 2296 int clearMode = 0;
mkarlsso 2:298679fff37c 2297 if ((!lineError)&&(i+1 < sz)){
mkarlsso 2:298679fff37c 2298 if (tokens[i+1].compare("all") == 0) {
mkarlsso 2:298679fff37c 2299 clearMode = 1;
mkarlsso 2:298679fff37c 2300 } else if (tokens[i+1].compare("blocks") == 0) {
mkarlsso 2:298679fff37c 2301 clearMode = 2;
mkarlsso 2:298679fff37c 2302 } else if (tokens[i+1].compare("queue") == 0) {
mkarlsso 2:298679fff37c 2303 clearMode = 3;
mkarlsso 2:298679fff37c 2304 } else {
mkarlsso 2:298679fff37c 2305 pcPtr->printf("Error: clear what: all, blocks, or queue? \r\n");
mkarlsso 2:298679fff37c 2306 lineError = true;
mkarlsso 2:298679fff37c 2307 }
mkarlsso 2:298679fff37c 2308 } else {
mkarlsso 2:298679fff37c 2309 pcPtr->printf("Error: clear what: all, blocks, or queue? \r\n");
mkarlsso 2:298679fff37c 2310 lineError = true;
mkarlsso 2:298679fff37c 2311 }
mkarlsso 2:298679fff37c 2312
mkarlsso 2:298679fff37c 2313
mkarlsso 2:298679fff37c 2314 if ((!lineError) && (clearMode < 3) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2315 pcPtr->printf("Error: 'clear all' and 'clear blocks' only allowed outside of block structures\r\n");
mkarlsso 2:298679fff37c 2316 lineError = true;
mkarlsso 2:298679fff37c 2317 }
mkarlsso 2:298679fff37c 2318 if (!lineError) {
mkarlsso 2:298679fff37c 2319 i++;
mkarlsso 2:298679fff37c 2320 //clear variables
mkarlsso 2:298679fff37c 2321 if (clearMode == 1) {
mkarlsso 2:298679fff37c 2322 while (!globalVariables.empty()) {
mkarlsso 2:298679fff37c 2323 globalVariables.pop_back();
mkarlsso 2:298679fff37c 2324 }
mkarlsso 2:298679fff37c 2325 }
mkarlsso 2:298679fff37c 2326
mkarlsso 2:298679fff37c 2327 //clear callbacks, functions, and queue
mkarlsso 2:298679fff37c 2328 if (clearMode < 3) {
mkarlsso 2:298679fff37c 2329 for (int pNum = 1; pNum <= numPorts; pNum++) {
mkarlsso 2:298679fff37c 2330 //delete portVector[pNum]->triggerUpEventPtr;
mkarlsso 2:298679fff37c 2331 if (portVector[pNum]->triggerUpEventPtr != NULL) {
mkarlsso 2:298679fff37c 2332 portVector[pNum]->triggerUpEventPtr->release();
mkarlsso 2:298679fff37c 2333 }
mkarlsso 2:298679fff37c 2334 portVector[pNum]->triggerUpEventPtr = NULL;
mkarlsso 2:298679fff37c 2335
mkarlsso 2:298679fff37c 2336 //delete portVector[pNum]->triggerDownEventPtr;
mkarlsso 2:298679fff37c 2337 if (portVector[pNum]->triggerDownEventPtr != NULL) {
mkarlsso 2:298679fff37c 2338 portVector[pNum]->triggerDownEventPtr->release();
mkarlsso 2:298679fff37c 2339 }
mkarlsso 2:298679fff37c 2340 portVector[pNum]->triggerDownEventPtr = NULL;
mkarlsso 2:298679fff37c 2341 while (!functionArray.empty()) {
mkarlsso 2:298679fff37c 2342 delete functionArray.back();
mkarlsso 2:298679fff37c 2343 functionArray.pop_back();
mkarlsso 2:298679fff37c 2344 }
mkarlsso 2:298679fff37c 2345 }
mkarlsso 2:298679fff37c 2346
mkarlsso 2:298679fff37c 2347 queuePtr->eraseQueue();
mkarlsso 2:298679fff37c 2348 }
mkarlsso 2:298679fff37c 2349
mkarlsso 2:298679fff37c 2350 if (clearMode == 4) {
mkarlsso 2:298679fff37c 2351 if (blockDepth > 0) { //we are inside a block
mkarlsso 2:298679fff37c 2352 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2353 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2354 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2355 lineError = true;
mkarlsso 2:298679fff37c 2356 } else {
mkarlsso 2:298679fff37c 2357
mkarlsso 2:298679fff37c 2358 int8_t code = 0;
mkarlsso 2:298679fff37c 2359 tmpAction->set(code);
mkarlsso 2:298679fff37c 2360 //action* tmpAction = new action(code); //code 0 = clear queue
mkarlsso 2:298679fff37c 2361 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2362 }
mkarlsso 2:298679fff37c 2363 } else {
mkarlsso 2:298679fff37c 2364 //clear queue now
mkarlsso 2:298679fff37c 2365 queuePtr->eraseQueue();
mkarlsso 2:298679fff37c 2366 }
mkarlsso 2:298679fff37c 2367 }
mkarlsso 2:298679fff37c 2368
mkarlsso 2:298679fff37c 2369
mkarlsso 2:298679fff37c 2370 }
mkarlsso 2:298679fff37c 2371
mkarlsso 2:298679fff37c 2372 //do starts a block---------------------------------------------------------
mkarlsso 2:298679fff37c 2373 //example: do in 500
mkarlsso 2:298679fff37c 2374 // ...
mkarlsso 2:298679fff37c 2375 // end
mkarlsso 2:298679fff37c 2376
alustig3 5:4d6575e3a07e 2377 }else if(tokens[i].compare("kaboom") == 0){//MAX ANDY
alustig3 5:4d6575e3a07e 2378 mbed_reset();
alustig3 5:4d6575e3a07e 2379 }
alustig3 5:4d6575e3a07e 2380
alustig3 5:4d6575e3a07e 2381
alustig3 5:4d6575e3a07e 2382
alustig3 5:4d6575e3a07e 2383
alustig3 5:4d6575e3a07e 2384 else if (tokens[i].compare("do") == 0) { //the start of a block
mkarlsso 2:298679fff37c 2385
mkarlsso 2:298679fff37c 2386 if (!ifBlockInit && !whileBlockInit) {
mkarlsso 2:298679fff37c 2387
mkarlsso 2:298679fff37c 2388 if ((currentTriggerPort > 0) || (currentFunction > 0)) { //check to make sure we are inside a trigger block
mkarlsso 2:298679fff37c 2389 //pcPtr->printf("Start new block\r\n");
mkarlsso 2:298679fff37c 2390
mkarlsso 2:298679fff37c 2391 } else {
mkarlsso 2:298679fff37c 2392 pcPtr->printf("Error: a statement block must be placed inside a callback or function.\r\n");
mkarlsso 2:298679fff37c 2393 lineError = true;
mkarlsso 2:298679fff37c 2394 }
mkarlsso 2:298679fff37c 2395
mkarlsso 2:298679fff37c 2396 }
mkarlsso 2:298679fff37c 2397 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2398 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2399 bool eventReserved = false;
mkarlsso 2:298679fff37c 2400 if ((tmpEvent == NULL)||(tmpAction == NULL)) {
mkarlsso 2:298679fff37c 2401 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2402 lineError = true;
mkarlsso 2:298679fff37c 2403
mkarlsso 2:298679fff37c 2404 } else {
mkarlsso 2:298679fff37c 2405
mkarlsso 2:298679fff37c 2406
mkarlsso 2:298679fff37c 2407 }
mkarlsso 2:298679fff37c 2408
mkarlsso 2:298679fff37c 2409 if (i+2 < sz) { //a time delay in the block
mkarlsso 2:298679fff37c 2410
mkarlsso 2:298679fff37c 2411 if ((!lineError) && (tokens[i+1].compare("in") == 0) && (isNumber(tokens[i+2]))) {
mkarlsso 2:298679fff37c 2412
mkarlsso 2:298679fff37c 2413 currentDelay = atoi(tokens[i+2].data());
mkarlsso 2:298679fff37c 2414 if (currentDelay < 0) {
mkarlsso 2:298679fff37c 2415 pcPtr->printf("Error: block delay time must be a positive integer\r\n");
mkarlsso 2:298679fff37c 2416 lineError = true;
mkarlsso 2:298679fff37c 2417 } else if (!ifBlockInit) { //a standalone do block
mkarlsso 2:298679fff37c 2418 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2419 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2420 eventReserved = true;
mkarlsso 2:298679fff37c 2421 tmpEvent->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2422
mkarlsso 2:298679fff37c 2423 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 2:298679fff37c 2424 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2425 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2426 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2427 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2428 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 2:298679fff37c 2429 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2430 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2431 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2432 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2433 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 2:298679fff37c 2434 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2435
mkarlsso 2:298679fff37c 2436 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2437 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2438 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 2:298679fff37c 2439 }
mkarlsso 2:298679fff37c 2440 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2441 } else { //an if block
mkarlsso 2:298679fff37c 2442 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2443
mkarlsso 2:298679fff37c 2444 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2445 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 2:298679fff37c 2446 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2447 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 2:298679fff37c 2448 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 2:298679fff37c 2449 }
mkarlsso 2:298679fff37c 2450 } else if (elseFlag){
mkarlsso 2:298679fff37c 2451 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2452 } else if (thenFlag){
mkarlsso 2:298679fff37c 2453 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2454
mkarlsso 2:298679fff37c 2455 }
mkarlsso 2:298679fff37c 2456 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2457
mkarlsso 2:298679fff37c 2458 }
mkarlsso 2:298679fff37c 2459
mkarlsso 2:298679fff37c 2460 } else if ((!lineError) && (tokens[i+1].compare("in") == 0) && (findIntVariable(tokens[i+2])!=NULL)) {
mkarlsso 2:298679fff37c 2461
mkarlsso 2:298679fff37c 2462 int* delayVar = findIntVariable(tokens[i+2]);
mkarlsso 2:298679fff37c 2463 //currentDelay = atoi(tokens[i+2].data());
mkarlsso 2:298679fff37c 2464 if (!ifBlockInit) { //a standalone do block
mkarlsso 2:298679fff37c 2465 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2466 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2467 eventReserved = true;
mkarlsso 2:298679fff37c 2468 tmpEvent->setTimeLag(delayVar);
mkarlsso 2:298679fff37c 2469
mkarlsso 2:298679fff37c 2470 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 2:298679fff37c 2471 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2472 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2473 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2474 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2475 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 2:298679fff37c 2476 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2477 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2478 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2479 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2480 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 2:298679fff37c 2481 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2482
mkarlsso 2:298679fff37c 2483 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2484 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2485 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 2:298679fff37c 2486 }
mkarlsso 2:298679fff37c 2487 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2488 } else { //an if block
mkarlsso 2:298679fff37c 2489 tmpEventPtrArray.back()->setTimeLag(delayVar);
mkarlsso 2:298679fff37c 2490
mkarlsso 2:298679fff37c 2491 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2492 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 2:298679fff37c 2493 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2494 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 2:298679fff37c 2495 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 2:298679fff37c 2496 }
mkarlsso 2:298679fff37c 2497 } else if (elseFlag){
mkarlsso 2:298679fff37c 2498 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2499 } else if (thenFlag){
mkarlsso 2:298679fff37c 2500 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2501
mkarlsso 2:298679fff37c 2502 }
mkarlsso 2:298679fff37c 2503 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2504
mkarlsso 2:298679fff37c 2505 }
mkarlsso 2:298679fff37c 2506
mkarlsso 2:298679fff37c 2507 } else {
mkarlsso 2:298679fff37c 2508 pcPtr->printf("Error: block delay time must be a positive integer or a variable\r\n");
mkarlsso 2:298679fff37c 2509 lineError = true;
mkarlsso 2:298679fff37c 2510 }
mkarlsso 2:298679fff37c 2511 } else if (!lineError && !ifBlockInit) { //no time delay given, standalone do
mkarlsso 2:298679fff37c 2512 currentDelay = 0;
mkarlsso 2:298679fff37c 2513 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2514 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2515 eventReserved = true;
mkarlsso 2:298679fff37c 2516 tmpEvent->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2517 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2518 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2519 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2520 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2521 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2522 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2523 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2524 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2525 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2526 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 2:298679fff37c 2527 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2528 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2529 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2530 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 2:298679fff37c 2531 }
mkarlsso 2:298679fff37c 2532 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2533 } else if (!lineError) { //no time delay, if block
mkarlsso 2:298679fff37c 2534
mkarlsso 2:298679fff37c 2535 currentDelay = 0;
mkarlsso 2:298679fff37c 2536 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2537
mkarlsso 2:298679fff37c 2538
mkarlsso 2:298679fff37c 2539 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2540 if (blockDepth > 1) {
mkarlsso 2:298679fff37c 2541 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2542 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 2:298679fff37c 2543 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 2:298679fff37c 2544 }
mkarlsso 2:298679fff37c 2545 } else {
mkarlsso 2:298679fff37c 2546 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2547 }
mkarlsso 2:298679fff37c 2548
mkarlsso 2:298679fff37c 2549
mkarlsso 2:298679fff37c 2550 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2551 }
mkarlsso 2:298679fff37c 2552 if (lineError && eventReserved) {
mkarlsso 2:298679fff37c 2553 tmpEvent->release();
mkarlsso 2:298679fff37c 2554 }
mkarlsso 2:298679fff37c 2555 //close block initiation
mkarlsso 2:298679fff37c 2556 ifBlockInit = false;
mkarlsso 2:298679fff37c 2557 whileBlockInit = false;
mkarlsso 2:298679fff37c 2558 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2559 elseFlag = false;
mkarlsso 2:298679fff37c 2560 thenFlag = false;
mkarlsso 2:298679fff37c 2561
mkarlsso 2:298679fff37c 2562 //callback starts a callback block------------------------------------------
mkarlsso 2:298679fff37c 2563 //exmaple: callback portin(1) down
mkarlsso 2:298679fff37c 2564 // ...
mkarlsso 2:298679fff37c 2565 // end
mkarlsso 2:298679fff37c 2566 } else if (tokens[i].compare("callback") == 0) { //a new callback block
mkarlsso 2:298679fff37c 2567 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2568 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2569 lineError = true;
mkarlsso 2:298679fff37c 2570 }
mkarlsso 2:298679fff37c 2571 if (blockDepth != 0) {
mkarlsso 2:298679fff37c 2572 pcPtr->printf("Error: Can't declare a callback block within another block\r\n");
mkarlsso 2:298679fff37c 2573 lineError = true;
mkarlsso 2:298679fff37c 2574 }
mkarlsso 2:298679fff37c 2575 if (!lineError) {
mkarlsso 2:298679fff37c 2576 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2577 if (i+2 < sz) {
mkarlsso 2:298679fff37c 2578 if ((tokens[i+1].find("portin[") != std::string::npos) && (tokens[i+1].size() > 8) ) { //callback for a digital port
mkarlsso 2:298679fff37c 2579 int pos1 = tokens[i+1].find("portin[")+7;
mkarlsso 2:298679fff37c 2580 int pos2 = tokens[i+1].find_first_of("]",pos1);
mkarlsso 2:298679fff37c 2581 currentTriggerPort = atoi(tokens[i+1].substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 2582
mkarlsso 2:298679fff37c 2583 if (currentTriggerPort <= 0) {
mkarlsso 2:298679fff37c 2584 currentTriggerPort = -1;
mkarlsso 2:298679fff37c 2585 pcPtr->printf("Error: Not a valid port number\r\n");
mkarlsso 2:298679fff37c 2586 lineError = true;
mkarlsso 2:298679fff37c 2587 }
mkarlsso 2:298679fff37c 2588 } else {
mkarlsso 2:298679fff37c 2589 pcPtr->printf("Error: Not a valid callback input\r\n");
mkarlsso 2:298679fff37c 2590 lineError = true;
mkarlsso 2:298679fff37c 2591 }
mkarlsso 2:298679fff37c 2592 if (tokens[i+2].compare("up") == 0) {
mkarlsso 2:298679fff37c 2593 currentTriggerDir = 1;
mkarlsso 2:298679fff37c 2594 } else if (tokens[i+2].compare("down") == 0) {
mkarlsso 2:298679fff37c 2595 currentTriggerDir = -1;
mkarlsso 2:298679fff37c 2596 } else {
mkarlsso 2:298679fff37c 2597 pcPtr->printf("Error: No trigger direction given\r\n");
mkarlsso 2:298679fff37c 2598 lineError = true;
mkarlsso 2:298679fff37c 2599 }
mkarlsso 2:298679fff37c 2600
mkarlsso 2:298679fff37c 2601 } else {
mkarlsso 2:298679fff37c 2602 if (!lineError) pcPtr->printf("Error: Not enough arguments for callback statement\r\n");
mkarlsso 2:298679fff37c 2603 lineError = true;
mkarlsso 2:298679fff37c 2604 }
mkarlsso 2:298679fff37c 2605 if (sz > 3) {
mkarlsso 2:298679fff37c 2606 if (!((sz == 4) && (tokens[i+3].compare("do") == 0))) {
mkarlsso 2:298679fff37c 2607 pcPtr->printf("Error: Too many arguments in callback statement\r\n");
mkarlsso 2:298679fff37c 2608 lineError = true;
mkarlsso 2:298679fff37c 2609 }
mkarlsso 2:298679fff37c 2610 }
mkarlsso 2:298679fff37c 2611
mkarlsso 2:298679fff37c 2612 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2613 if (tmpEvent != NULL) {
mkarlsso 2:298679fff37c 2614 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2615
mkarlsso 2:298679fff37c 2616 } else {
mkarlsso 2:298679fff37c 2617 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2618 lineError = true;
mkarlsso 2:298679fff37c 2619 }
mkarlsso 2:298679fff37c 2620 if (!lineError) {
mkarlsso 2:298679fff37c 2621 //pcPtr->printf("Current port: %d\r\n", currentTriggerPort);
mkarlsso 2:298679fff37c 2622 blockDepth = 1;
mkarlsso 2:298679fff37c 2623 i = i+2;
mkarlsso 2:298679fff37c 2624 //create new event and attach it to the port
mkarlsso 2:298679fff37c 2625 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 2:298679fff37c 2626 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2627 if (currentTriggerDir == 1) {
mkarlsso 2:298679fff37c 2628
mkarlsso 2:298679fff37c 2629 portVector[currentTriggerPort]->setTriggerUpEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2630 } else {
mkarlsso 2:298679fff37c 2631
mkarlsso 2:298679fff37c 2632 portVector[currentTriggerPort]->setTriggerDownEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2633 }
mkarlsso 2:298679fff37c 2634
mkarlsso 2:298679fff37c 2635 }
mkarlsso 2:298679fff37c 2636 }
mkarlsso 2:298679fff37c 2637
mkarlsso 2:298679fff37c 2638 //if starts an if block----------------------------------------------
mkarlsso 2:298679fff37c 2639 //examples: if x < 10 && y == 1 do; if a==1 do in 1000
mkarlsso 2:298679fff37c 2640 } else if (tokens[i].compare("if") == 0) { //a new if block
mkarlsso 2:298679fff37c 2641 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2642 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2643 lineError = true;
mkarlsso 2:298679fff37c 2644 }
mkarlsso 2:298679fff37c 2645
mkarlsso 2:298679fff37c 2646 ifBlockInit = true;
mkarlsso 2:298679fff37c 2647 currentDelay = 0;
mkarlsso 2:298679fff37c 2648 bool eventDefined = false;
mkarlsso 2:298679fff37c 2649 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2650 if (tmpEvent != NULL) {
mkarlsso 2:298679fff37c 2651 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2652 eventDefined = true;
mkarlsso 2:298679fff37c 2653 } else {
mkarlsso 2:298679fff37c 2654 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2655 lineError = true;
mkarlsso 2:298679fff37c 2656 }
mkarlsso 2:298679fff37c 2657 if (!lineError) {
mkarlsso 2:298679fff37c 2658 //this is a regular event
mkarlsso 2:298679fff37c 2659 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 2:298679fff37c 2660 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2661
mkarlsso 2:298679fff37c 2662 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 2:298679fff37c 2663 tmpEventPtrArray.back()->blockType = 1; //this is an if block
mkarlsso 2:298679fff37c 2664 blockDepth = blockDepth + 1;
mkarlsso 2:298679fff37c 2665 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2666 tmpEventPtrArray.back()->blockType = 3; //this is an else if block
mkarlsso 2:298679fff37c 2667 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2668 tmpEventPtrArray.back()->blockType = 7; //this is a then if block
mkarlsso 2:298679fff37c 2669 }
mkarlsso 2:298679fff37c 2670 }
mkarlsso 2:298679fff37c 2671
mkarlsso 2:298679fff37c 2672 if (!lineError) {
mkarlsso 2:298679fff37c 2673 //combine the condition tokens without whitespaces
mkarlsso 2:298679fff37c 2674 tmpString = "";
mkarlsso 2:298679fff37c 2675 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 2:298679fff37c 2676 if (tokens[j].compare("do") != 0) {
mkarlsso 2:298679fff37c 2677 i++;
mkarlsso 2:298679fff37c 2678 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2679 } else {
mkarlsso 2:298679fff37c 2680 break;
mkarlsso 2:298679fff37c 2681 }
mkarlsso 2:298679fff37c 2682 }
mkarlsso 2:298679fff37c 2683 //adds the conditions to the current event
mkarlsso 2:298679fff37c 2684
mkarlsso 2:298679fff37c 2685 if (!evaluateConditions(tmpString, tmpEventPtrArray.back())) lineError = true;
mkarlsso 2:298679fff37c 2686 }
mkarlsso 2:298679fff37c 2687
mkarlsso 2:298679fff37c 2688 if (lineError && eventDefined) {
mkarlsso 2:298679fff37c 2689 tmpEvent->release();
mkarlsso 2:298679fff37c 2690 }
mkarlsso 2:298679fff37c 2691
mkarlsso 2:298679fff37c 2692
mkarlsso 2:298679fff37c 2693 //else starts an else block-------------------------------------
mkarlsso 2:298679fff37c 2694 //examples: else do in 500; else if x==7 do
mkarlsso 2:298679fff37c 2695 } else if (tokens[i].compare("else") == 0) { //an else block
mkarlsso 2:298679fff37c 2696 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2697 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2698 lineError = true;
mkarlsso 2:298679fff37c 2699 }
mkarlsso 2:298679fff37c 2700
mkarlsso 2:298679fff37c 2701 //trigger blocks can't have else conditions
mkarlsso 2:298679fff37c 2702 if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso 2:298679fff37c 2703 pcPtr->printf("Error: else statement can not occur after a trigger block or outside a block\r\n");
mkarlsso 2:298679fff37c 2704 lineError = true;
mkarlsso 2:298679fff37c 2705 }
mkarlsso 2:298679fff37c 2706
mkarlsso 2:298679fff37c 2707 //check to make sure we are in an 'if' block
mkarlsso 2:298679fff37c 2708 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 1) && (tmpEventPtrArray.back()->blockType != 3)) { //not currently in an 'if' or 'else if' block
mkarlsso 2:298679fff37c 2709 pcPtr->printf("Error: else statement can only occur in an 'if' block\r\n");
mkarlsso 2:298679fff37c 2710 lineError = true;
mkarlsso 2:298679fff37c 2711 }
mkarlsso 2:298679fff37c 2712 if (!lineError) {
mkarlsso 2:298679fff37c 2713 elseFlag = true;
mkarlsso 2:298679fff37c 2714
mkarlsso 2:298679fff37c 2715 }
mkarlsso 2:298679fff37c 2716 } else if (tokens[i].compare("then") == 0) { //a then block
mkarlsso 2:298679fff37c 2717 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2718 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2719 lineError = true;
mkarlsso 2:298679fff37c 2720 }
mkarlsso 2:298679fff37c 2721
mkarlsso 2:298679fff37c 2722 //trigger blocks can't have else conditions
mkarlsso 2:298679fff37c 2723 if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso 2:298679fff37c 2724 pcPtr->printf("Error: 'then' statement can only occur after a 'while' block\r\n");
mkarlsso 2:298679fff37c 2725 lineError = true;
mkarlsso 2:298679fff37c 2726 }
mkarlsso 2:298679fff37c 2727
mkarlsso 2:298679fff37c 2728 //check to make sure we are in a 'while' block
mkarlsso 2:298679fff37c 2729 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 5)) { //not currently in a while block
mkarlsso 2:298679fff37c 2730 pcPtr->printf("Error: 'then' statement can only occur in a 'while' block\r\n");
mkarlsso 2:298679fff37c 2731 lineError = true;
mkarlsso 2:298679fff37c 2732 }
mkarlsso 2:298679fff37c 2733 if (!lineError) {
mkarlsso 2:298679fff37c 2734 thenFlag = true;
mkarlsso 2:298679fff37c 2735
mkarlsso 2:298679fff37c 2736 }
mkarlsso 2:298679fff37c 2737 //while starts a while block----------------------------------------
mkarlsso 2:298679fff37c 2738 //example: while x<10 do every 100
mkarlsso 2:298679fff37c 2739 // ...
mkarlsso 2:298679fff37c 2740 // end
mkarlsso 2:298679fff37c 2741 } else if (tokens[i].compare("while") == 0) { //a new while block
mkarlsso 2:298679fff37c 2742 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2743 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2744 lineError = true;
mkarlsso 2:298679fff37c 2745 }
mkarlsso 2:298679fff37c 2746
mkarlsso 2:298679fff37c 2747 if ((currentTriggerPort > 0) || (currentFunction > 0)) { //check to make sure we are inside a trigger block
mkarlsso 2:298679fff37c 2748 //pcPtr->printf("Start new block\r\n");
mkarlsso 2:298679fff37c 2749
mkarlsso 2:298679fff37c 2750 } else {
mkarlsso 2:298679fff37c 2751 pcPtr->printf("Error: a statement block must be placed inside a callback or function.\r\n");
mkarlsso 2:298679fff37c 2752 lineError = true;
mkarlsso 2:298679fff37c 2753 }
mkarlsso 2:298679fff37c 2754 //whileBlockInit = true;
mkarlsso 2:298679fff37c 2755 currentDelay = 0;
mkarlsso 2:298679fff37c 2756
mkarlsso 2:298679fff37c 2757 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2758 if (tmpEvent != NULL) {
mkarlsso 2:298679fff37c 2759 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2760 tmpEvent->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2761 } else {
mkarlsso 2:298679fff37c 2762 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2763 lineError = true;
mkarlsso 2:298679fff37c 2764 }
mkarlsso 2:298679fff37c 2765
mkarlsso 2:298679fff37c 2766 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2767
mkarlsso 2:298679fff37c 2768
mkarlsso 2:298679fff37c 2769 if (!lineError) {
mkarlsso 2:298679fff37c 2770 //combine the condition tokens without whitespaces
mkarlsso 2:298679fff37c 2771 tmpString = "";
mkarlsso 2:298679fff37c 2772 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 2:298679fff37c 2773 if (tokens[j].compare("do") != 0) {
mkarlsso 2:298679fff37c 2774 i++;
mkarlsso 2:298679fff37c 2775 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2776 } else {
mkarlsso 2:298679fff37c 2777 break;
mkarlsso 2:298679fff37c 2778 }
mkarlsso 2:298679fff37c 2779 }
mkarlsso 2:298679fff37c 2780 //adds the conditions to the current event
mkarlsso 2:298679fff37c 2781 if (!evaluateConditions(tmpString, tmpEvent)) lineError = true;
mkarlsso 2:298679fff37c 2782 }
mkarlsso 2:298679fff37c 2783
mkarlsso 2:298679fff37c 2784 if (!lineError) {
mkarlsso 2:298679fff37c 2785 if ((i+3) < sz) {
mkarlsso 2:298679fff37c 2786 if ((tokens[i+1].compare("do") == 0) && (tokens[i+2].compare("every") == 0)) {
mkarlsso 2:298679fff37c 2787
mkarlsso 2:298679fff37c 2788 if (isNumber(tokens[i+3])) {
mkarlsso 2:298679fff37c 2789 uint32_t period = atoi(tokens[i+3].data());
mkarlsso 2:298679fff37c 2790 if (period > 0) {
mkarlsso 2:298679fff37c 2791 //pcPtr->printf("While block\r\n");
mkarlsso 2:298679fff37c 2792
mkarlsso 2:298679fff37c 2793 //tmpEvent->whileLoopPeriod = period;
mkarlsso 2:298679fff37c 2794 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 2:298679fff37c 2795 if (!elseFlag) {
mkarlsso 2:298679fff37c 2796 tmpEvent->blockType = 5; //this is a while block
mkarlsso 2:298679fff37c 2797
mkarlsso 2:298679fff37c 2798 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2799 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2800 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2801 lineError = true;
mkarlsso 2:298679fff37c 2802 } else {
mkarlsso 2:298679fff37c 2803 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2804 }
mkarlsso 2:298679fff37c 2805 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2806 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2807
mkarlsso 2:298679fff37c 2808 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2809 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2810 } else {
mkarlsso 2:298679fff37c 2811 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 2:298679fff37c 2812 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2813 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2814 }
mkarlsso 2:298679fff37c 2815 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2816 } else {
mkarlsso 2:298679fff37c 2817 pcPtr->printf("Error: loop period must be a positive integer.\r\n");
mkarlsso 2:298679fff37c 2818 lineError = true;
mkarlsso 2:298679fff37c 2819 }
mkarlsso 2:298679fff37c 2820 } else if (findIntVariable(tokens[i+3])!=NULL) {
mkarlsso 2:298679fff37c 2821
mkarlsso 2:298679fff37c 2822 int* period = findIntVariable(tokens[i+3]);
mkarlsso 2:298679fff37c 2823 //tmpEvent->whileLoopPeriodVar = period;
mkarlsso 2:298679fff37c 2824 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 2:298679fff37c 2825 if (!elseFlag) {
mkarlsso 2:298679fff37c 2826 tmpEvent->blockType = 5; //this is a while block
mkarlsso 2:298679fff37c 2827
mkarlsso 2:298679fff37c 2828 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2829 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2830 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2831 lineError = true;
mkarlsso 2:298679fff37c 2832 } else {
mkarlsso 2:298679fff37c 2833 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2834 }
mkarlsso 2:298679fff37c 2835 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2836 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2837
mkarlsso 2:298679fff37c 2838 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2839 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2840 } else {
mkarlsso 2:298679fff37c 2841 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 2:298679fff37c 2842 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2843 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2844 }
mkarlsso 2:298679fff37c 2845 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2846 }
mkarlsso 2:298679fff37c 2847 } else {
mkarlsso 2:298679fff37c 2848 pcPtr->printf("Error: expected a 'do every' statement\r\n");
mkarlsso 2:298679fff37c 2849 lineError = true;
mkarlsso 2:298679fff37c 2850 }
mkarlsso 2:298679fff37c 2851 } else {
mkarlsso 2:298679fff37c 2852 pcPtr->printf("Error: expected a 'do every' statement\r\n");
mkarlsso 2:298679fff37c 2853 lineError = true;
mkarlsso 2:298679fff37c 2854 }
mkarlsso 2:298679fff37c 2855 }
mkarlsso 2:298679fff37c 2856
mkarlsso 2:298679fff37c 2857 //if the line contains an '=' sign,the equality is evaulated-------------------------
mkarlsso 2:298679fff37c 2858 //examples: a = 1; a = b + 5; a = random(100); portout[2] = 1; portout[2] = flip
mkarlsso 2:298679fff37c 2859 } else if ((tmpLine.find_first_of("=") != std::string::npos) ) { //an expression
mkarlsso 2:298679fff37c 2860 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2861 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2862 lineError = true;
mkarlsso 2:298679fff37c 2863 }
mkarlsso 2:298679fff37c 2864
mkarlsso 2:298679fff37c 2865 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2866 tmpString = "";
mkarlsso 2:298679fff37c 2867 int spacesBeforeEqualSign = 0;
mkarlsso 2:298679fff37c 2868 bool countSpaces = true;
mkarlsso 2:298679fff37c 2869 //combine the tokens without whitespaces
mkarlsso 2:298679fff37c 2870 for (unsigned j = i; j < sz; j++) {
mkarlsso 2:298679fff37c 2871 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2872 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 2:298679fff37c 2873 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2874 countSpaces = false;
mkarlsso 2:298679fff37c 2875 } else if (countSpaces) {
mkarlsso 2:298679fff37c 2876 spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2877 }
mkarlsso 2:298679fff37c 2878 }
mkarlsso 2:298679fff37c 2879 if (!lineError && spacesBeforeEqualSign > 1) {
mkarlsso 2:298679fff37c 2880 pcPtr->printf("Error: Variable can't have a space in it.\r\n");
mkarlsso 2:298679fff37c 2881 lineError = true;
mkarlsso 2:298679fff37c 2882 }
mkarlsso 2:298679fff37c 2883
mkarlsso 2:298679fff37c 2884 if (!lineError) {
mkarlsso 2:298679fff37c 2885 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 2886 action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 2:298679fff37c 2887 if (tmpAction != NULL) {
mkarlsso 2:298679fff37c 2888 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2889 //pcPtr->printf("Added action with delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2890
mkarlsso 2:298679fff37c 2891 } else {
mkarlsso 2:298679fff37c 2892 lineError = true;
mkarlsso 2:298679fff37c 2893 }
mkarlsso 2:298679fff37c 2894
mkarlsso 2:298679fff37c 2895 } else { //assignment was written outside of any block structure, so execute now
mkarlsso 2:298679fff37c 2896
mkarlsso 2:298679fff37c 2897
mkarlsso 2:298679fff37c 2898 action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 2:298679fff37c 2899
mkarlsso 3:ae33b7f5a7c1 2900 if (tmpAction != NULL) {
mkarlsso 2:298679fff37c 2901 tmpAction->execute();
mkarlsso 3:ae33b7f5a7c1 2902
mkarlsso 2:298679fff37c 2903 //delete tmpAction;
mkarlsso 2:298679fff37c 2904 tmpAction->release();
mkarlsso 2:298679fff37c 2905 } else {
mkarlsso 2:298679fff37c 2906 lineError = true;
mkarlsso 2:298679fff37c 2907 }
mkarlsso 2:298679fff37c 2908 }
mkarlsso 2:298679fff37c 2909 }
alustig3 5:4d6575e3a07e 2910 }
alustig3 5:4d6575e3a07e 2911 //ANDY
alustig3 5:4d6575e3a07e 2912 else if (tokens[i].find("opto(") != std::string::npos) {
alustig3 5:4d6575e3a07e 2913 wholeLineEvaluated = true;
alustig3 5:4d6575e3a07e 2914 int pos1 = tmpLine.find("opto(")+5;
alustig3 5:4d6575e3a07e 2915 int pos2 = tmpLine.find_first_of(")",pos1);
alustig3 5:4d6575e3a07e 2916 string dispVar = tmpLine.substr(pos1,pos2-pos1);
alustig3 5:4d6575e3a07e 2917 device.printf(dispVar.c_str());
alustig3 5:4d6575e3a07e 2918 }
alustig3 5:4d6575e3a07e 2919
alustig3 5:4d6575e3a07e 2920 else {
mkarlsso 2:298679fff37c 2921 //if there was no match to any of the above, an error is given
mkarlsso 2:298679fff37c 2922 pcPtr->printf("Error: statement not understood.\r\n");
mkarlsso 2:298679fff37c 2923 lineError = true;
mkarlsso 2:298679fff37c 2924 }
mkarlsso 2:298679fff37c 2925
mkarlsso 2:298679fff37c 2926 if (lineError) break; //stop parsing the rest of the line if an error was detected
mkarlsso 2:298679fff37c 2927
mkarlsso 2:298679fff37c 2928 if (wholeLineEvaluated) { //some of the tokens forces the whole line to be avaluated at once
mkarlsso 2:298679fff37c 2929 i = sz; //skip ahead to end of the line
mkarlsso 2:298679fff37c 2930 }
mkarlsso 2:298679fff37c 2931
mkarlsso 2:298679fff37c 2932 }
mkarlsso 2:298679fff37c 2933
mkarlsso 2:298679fff37c 2934 //if there was an error, we quit compiling the code
mkarlsso 2:298679fff37c 2935 if (lineError) {
mkarlsso 2:298679fff37c 2936 pcPtr->printf("Line text: ");
mkarlsso 2:298679fff37c 2937 while (!tokens.empty()) {
mkarlsso 2:298679fff37c 2938 pcPtr->printf("%s ",tokens.front().data());
mkarlsso 2:298679fff37c 2939 tokens.erase(tokens.begin());
mkarlsso 2:298679fff37c 2940 }
mkarlsso 2:298679fff37c 2941 pcPtr->printf("\r\n");
mkarlsso 2:298679fff37c 2942 while (!currentBlock.empty()) {
mkarlsso 2:298679fff37c 2943 currentBlock.pop_back();
mkarlsso 2:298679fff37c 2944 }
mkarlsso 2:298679fff37c 2945 delete tmpEvent;
mkarlsso 2:298679fff37c 2946 } else {
mkarlsso 2:298679fff37c 2947
mkarlsso 2:298679fff37c 2948 while (!tokens.empty()) {
mkarlsso 2:298679fff37c 2949 tokens.pop_back();
mkarlsso 2:298679fff37c 2950 }
alustig3 5:4d6575e3a07e 2951 currentBlock.pop_back();
mkarlsso 2:298679fff37c 2952 }
mkarlsso 2:298679fff37c 2953
mkarlsso 2:298679fff37c 2954 }
mkarlsso 2:298679fff37c 2955
mkarlsso 2:298679fff37c 2956 //make sure that all blocks have a matching end statement
mkarlsso 2:298679fff37c 2957 if ((!lineError)&&(blockDepth > 0)) {
mkarlsso 2:298679fff37c 2958 pcPtr->printf("Error: Missing 1 or more end statements\r\n");
mkarlsso 2:298679fff37c 2959 lineError = true;
alustig3 5:4d6575e3a07e 2960 }
alustig3 5:4d6575e3a07e 2961 //pcPtr->printf("~~~\r\n"); //signals that the code was compiled
alustig3 5:4d6575e3a07e 2962 textDisplay.send("~~~\r\n");
mkarlsso 2:298679fff37c 2963 //displayMemoryLeft();
mkarlsso 2:298679fff37c 2964 //DisplayRAMBanks();
mkarlsso 2:298679fff37c 2965
mkarlsso 2:298679fff37c 2966 }
mkarlsso 2:298679fff37c 2967
mkarlsso 2:298679fff37c 2968
mkarlsso 2:298679fff37c 2969 //used to return a pointer to a variable, if it exists
mkarlsso 2:298679fff37c 2970 int* scriptStream::findIntVariable(string nameInput) {
mkarlsso 2:298679fff37c 2971
mkarlsso 2:298679fff37c 2972 int* outPtr = NULL;
mkarlsso 2:298679fff37c 2973 bool foundIt = false;
mkarlsso 2:298679fff37c 2974
mkarlsso 2:298679fff37c 2975 if (nameInput.find("portout") != std::string::npos) {
mkarlsso 2:298679fff37c 2976 int pos1 = nameInput.find("portout[")+8;
mkarlsso 2:298679fff37c 2977 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 2:298679fff37c 2978 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 2979 int portVal = 0;
mkarlsso 2:298679fff37c 2980 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 2:298679fff37c 2981 outPtr = &portVector[portnum]->outState;
mkarlsso 2:298679fff37c 2982 foundIt = true;
mkarlsso 2:298679fff37c 2983 }
mkarlsso 2:298679fff37c 2984 } else if (nameInput.find("portin") != std::string::npos) {
mkarlsso 2:298679fff37c 2985 int pos1 = nameInput.find("portin[")+7;
mkarlsso 2:298679fff37c 2986 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 2:298679fff37c 2987 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 2988 int portVal = 0;
mkarlsso 2:298679fff37c 2989 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 2:298679fff37c 2990 outPtr = &portVector[portnum]->inState;
mkarlsso 2:298679fff37c 2991 foundIt = true;
mkarlsso 2:298679fff37c 2992 }
mkarlsso 2:298679fff37c 2993 }
mkarlsso 2:298679fff37c 2994
mkarlsso 2:298679fff37c 2995 if (!foundIt) {
mkarlsso 2:298679fff37c 2996 std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso 2:298679fff37c 2997 for (unsigned i = 0; i < sz; i++) {
mkarlsso 2:298679fff37c 2998 if (nameInput.compare(globalVariables[i]->tag) == 0) {
mkarlsso 2:298679fff37c 2999 outPtr = &globalVariables[i]->value;
mkarlsso 2:298679fff37c 3000 break;
mkarlsso 2:298679fff37c 3001 }
mkarlsso 2:298679fff37c 3002 }
mkarlsso 2:298679fff37c 3003 }
mkarlsso 2:298679fff37c 3004
mkarlsso 2:298679fff37c 3005 return outPtr;
mkarlsso 2:298679fff37c 3006 }
mkarlsso 2:298679fff37c 3007
mkarlsso 2:298679fff37c 3008 bool scriptStream::createIntVariable(string nameInput) {
mkarlsso 2:298679fff37c 3009 if (findIntVariable(nameInput) == NULL) {
mkarlsso 2:298679fff37c 3010 globalVariables.push_back(new intVariable(nameInput, 0));
mkarlsso 2:298679fff37c 3011 return true;
mkarlsso 2:298679fff37c 3012 } else {
mkarlsso 2:298679fff37c 3013 return false;
mkarlsso 2:298679fff37c 3014 }
mkarlsso 2:298679fff37c 3015 }
mkarlsso 2:298679fff37c 3016
mkarlsso 2:298679fff37c 3017
mkarlsso 2:298679fff37c 3018 action* scriptStream::evaluateAssignmentForAction(string expression) {
mkarlsso 2:298679fff37c 3019
mkarlsso 2:298679fff37c 3020 //action* tmpAction = new action(); //create a new action
mkarlsso 2:298679fff37c 3021 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 3022 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 3023 pcPtr->printf("Error: no action memory slots available.\r\n");
mkarlsso 2:298679fff37c 3024 return NULL;
mkarlsso 2:298679fff37c 3025 }
mkarlsso 2:298679fff37c 3026 std::size_t stringInd;
mkarlsso 2:298679fff37c 3027 std::size_t stringInd2;
mkarlsso 2:298679fff37c 3028 string afterEqual;
mkarlsso 2:298679fff37c 3029 string beforeEqual;
mkarlsso 2:298679fff37c 3030 //The expression might have up to three variables
mkarlsso 2:298679fff37c 3031 int* tmpVar;
mkarlsso 2:298679fff37c 3032 int* tmpVar2;
mkarlsso 2:298679fff37c 3033 int* tmpVar3;
mkarlsso 2:298679fff37c 3034 stringInd = expression.find_first_of("="); //location of = sign, if it exists
mkarlsso 2:298679fff37c 3035 beforeEqual = expression.substr(0,stringInd); // the string after the = sign
mkarlsso 2:298679fff37c 3036 afterEqual = expression.substr(stringInd+1,std::string::npos); // the string after the = sign
mkarlsso 2:298679fff37c 3037 stringInd2 = afterEqual.find_first_of("+-"); //location of +/- sign (only one allowed)
mkarlsso 2:298679fff37c 3038 tmpVar = findIntVariable(expression.substr(0,stringInd)); //returns pointer to the variable
mkarlsso 2:298679fff37c 3039
mkarlsso 2:298679fff37c 3040 if (beforeEqual.find("portout[") != std::string::npos) { //set the output of a digital port
mkarlsso 2:298679fff37c 3041 int pos1 = beforeEqual.find("portout[")+8;
mkarlsso 2:298679fff37c 3042 int pos2 = beforeEqual.find_first_of("]",pos1);
mkarlsso 2:298679fff37c 3043 int portnum = atoi(beforeEqual.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 3044 int* tmpVar = findIntVariable(beforeEqual.substr(pos1,pos2-pos1)); //returns pointer to the variable, if given
mkarlsso 2:298679fff37c 3045 int portVal = 0;
mkarlsso 2:298679fff37c 3046 if ((tmpVar != NULL)||((portnum > 0) && (portnum <= numPorts))) {
mkarlsso 2:298679fff37c 3047 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 2:298679fff37c 3048 portVal = atoi(afterEqual.data());
mkarlsso 2:298679fff37c 3049 if ((portVal == 0) || (portVal == 1)) {
mkarlsso 2:298679fff37c 3050 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso 2:298679fff37c 3051 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 2:298679fff37c 3052 if (tmpMessage == NULL) {
mkarlsso 2:298679fff37c 3053 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3054 tmpAction->release();
mkarlsso 2:298679fff37c 3055 return NULL;
mkarlsso 2:298679fff37c 3056 } else {
mkarlsso 2:298679fff37c 3057 //tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso 2:298679fff37c 3058 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 2:298679fff37c 3059 tmpMessage->setMessage(NULL,portnum,portVal);
mkarlsso 2:298679fff37c 3060 } else {
mkarlsso 2:298679fff37c 3061 tmpMessage->setMessage(tmpVar,0,portVal);
mkarlsso 2:298679fff37c 3062 }
mkarlsso 2:298679fff37c 3063 }
mkarlsso 2:298679fff37c 3064
mkarlsso 2:298679fff37c 3065
mkarlsso 2:298679fff37c 3066 tmpAction->set(tmpMessage);
mkarlsso 2:298679fff37c 3067 //pcPtr->printf("Action: digital port %d set to %d\r\n",portnum,portVal);
mkarlsso 2:298679fff37c 3068 } else {
mkarlsso 2:298679fff37c 3069 pcPtr->printf("Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n");
mkarlsso 2:298679fff37c 3070 //delete tmpAction;
mkarlsso 2:298679fff37c 3071 tmpAction->release();
mkarlsso 2:298679fff37c 3072 return NULL;
mkarlsso 2:298679fff37c 3073 }
mkarlsso 2:298679fff37c 3074 } else if (afterEqual.compare("flip") == 0) {
mkarlsso 2:298679fff37c 3075 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso 2:298679fff37c 3076 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 2:298679fff37c 3077 if (tmpMessage == NULL) {
mkarlsso 2:298679fff37c 3078 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3079 tmpAction->release();
mkarlsso 2:298679fff37c 3080 return NULL;
mkarlsso 2:298679fff37c 3081 } else {
mkarlsso 2:298679fff37c 3082 //tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso 2:298679fff37c 3083 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 3:ae33b7f5a7c1 3084 tmpMessage->setMessage(NULL,portnum,-1);
mkarlsso 2:298679fff37c 3085 } else {
mkarlsso 3:ae33b7f5a7c1 3086 tmpMessage->setMessage(tmpVar,0,-1);
mkarlsso 2:298679fff37c 3087 }
mkarlsso 2:298679fff37c 3088 }
mkarlsso 2:298679fff37c 3089 tmpAction->set(tmpMessage);
mkarlsso 2:298679fff37c 3090 } else {
mkarlsso 2:298679fff37c 3091 pcPtr->printf("Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n");
mkarlsso 2:298679fff37c 3092 //delete tmpAction;
mkarlsso 2:298679fff37c 3093 tmpAction->release();
mkarlsso 2:298679fff37c 3094 return NULL;
mkarlsso 2:298679fff37c 3095 }
mkarlsso 2:298679fff37c 3096 } else {
mkarlsso 2:298679fff37c 3097 pcPtr->printf("Port number not found (must be between 1 and %d, or an existing variable)\r\n", numPorts);
mkarlsso 2:298679fff37c 3098 //delete tmpAction;
mkarlsso 2:298679fff37c 3099 tmpAction->release();
mkarlsso 2:298679fff37c 3100 return NULL;
mkarlsso 2:298679fff37c 3101 }
mkarlsso 2:298679fff37c 3102 } else if (beforeEqual.find("portin") != std::string::npos) {
mkarlsso 2:298679fff37c 3103 pcPtr->printf("Error: portins can not be set\r\n");
mkarlsso 2:298679fff37c 3104 //delete tmpAction;
mkarlsso 2:298679fff37c 3105 tmpAction->release();
mkarlsso 2:298679fff37c 3106 return NULL;
mkarlsso 2:298679fff37c 3107 } else if (tmpVar != NULL) {
mkarlsso 2:298679fff37c 3108 intOperation* tmpOp;
mkarlsso 2:298679fff37c 3109 intOperation* tmpOp2;
mkarlsso 2:298679fff37c 3110 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 2:298679fff37c 3111 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 2:298679fff37c 3112 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3113 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3114 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3115 tmpAction->release();
mkarlsso 2:298679fff37c 3116 return NULL;
mkarlsso 2:298679fff37c 3117 } else {
mkarlsso 2:298679fff37c 3118 tmpOp->set(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 2:298679fff37c 3119 }
mkarlsso 2:298679fff37c 3120 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3121 //pcPtr->printf("Action: set variable to constant numeric value\r\n");
mkarlsso 2:298679fff37c 3122 } else if ((stringInd2 == std::string::npos)&&(afterEqual.find("random") != std::string::npos)) {
mkarlsso 2:298679fff37c 3123
mkarlsso 2:298679fff37c 3124 int highVal = getRandomParam(afterEqual);
mkarlsso 2:298679fff37c 3125
mkarlsso 2:298679fff37c 3126 if (highVal > 0) {
mkarlsso 2:298679fff37c 3127 //tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 2:298679fff37c 3128 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3129 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3130 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3131 tmpAction->release();
mkarlsso 2:298679fff37c 3132 return NULL;
mkarlsso 2:298679fff37c 3133 } else {
mkarlsso 2:298679fff37c 3134 tmpOp->set(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 2:298679fff37c 3135 }
mkarlsso 2:298679fff37c 3136 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3137 //pcPtr->printf("Action: set variable to random value up to %d\r\n", highVal);
mkarlsso 2:298679fff37c 3138 } else {
mkarlsso 2:298679fff37c 3139 //delete tmpAction;
mkarlsso 2:298679fff37c 3140 tmpAction->release();
mkarlsso 2:298679fff37c 3141 return NULL;
mkarlsso 2:298679fff37c 3142 }
mkarlsso 2:298679fff37c 3143
mkarlsso 2:298679fff37c 3144 } else if (stringInd2 != std::string::npos) { //a +/- operation is there
mkarlsso 2:298679fff37c 3145 string multiplier("+");
mkarlsso 2:298679fff37c 3146 int multiplierInt = 1;
mkarlsso 2:298679fff37c 3147 if (afterEqual[stringInd2] == '-') {
mkarlsso 2:298679fff37c 3148 multiplier = "-";
mkarlsso 2:298679fff37c 3149 multiplierInt = -1;
mkarlsso 2:298679fff37c 3150 }
mkarlsso 2:298679fff37c 3151 tmpVar2 = findIntVariable(afterEqual.substr(0,stringInd2)); //before the +/- sign
mkarlsso 2:298679fff37c 3152 tmpVar3 = findIntVariable(afterEqual.substr(stringInd2+1,std::string::npos)); //after the +/- sign
mkarlsso 2:298679fff37c 3153
mkarlsso 2:298679fff37c 3154 if ((tmpVar2 != NULL) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //variable +/- number
mkarlsso 2:298679fff37c 3155 if (tmpVar2 == tmpVar) {
mkarlsso 2:298679fff37c 3156 multiplier.append("="); //final sign is += or -=
mkarlsso 2:298679fff37c 3157 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 2:298679fff37c 3158 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3159 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3160 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3161 tmpAction->release();
mkarlsso 2:298679fff37c 3162 return NULL;
mkarlsso 2:298679fff37c 3163 } else {
mkarlsso 2:298679fff37c 3164 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 2:298679fff37c 3165 }
mkarlsso 2:298679fff37c 3166 tmpAction->set(tmpOp);
alustig3 5:4d6575e3a07e 3167 pcPtr->printf("Action: change variable by constant amount\r\n");
mkarlsso 2:298679fff37c 3168 } else {
mkarlsso 3:ae33b7f5a7c1 3169
mkarlsso 2:298679fff37c 3170 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3171 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3172 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3173 tmpAction->release();
mkarlsso 2:298679fff37c 3174 return NULL;
mkarlsso 2:298679fff37c 3175 } else {
mkarlsso 3:ae33b7f5a7c1 3176
mkarlsso 2:298679fff37c 3177 tmpOp2->set(tmpVar2,multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 3:ae33b7f5a7c1 3178 //tmpOp->set(tmpVar, tmpOp2);
mkarlsso 3:ae33b7f5a7c1 3179 }
mkarlsso 3:ae33b7f5a7c1 3180
mkarlsso 3:ae33b7f5a7c1 3181 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3182 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3183 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3184 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3185 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3186 return NULL;
mkarlsso 3:ae33b7f5a7c1 3187 } else {
mkarlsso 2:298679fff37c 3188 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 3:ae33b7f5a7c1 3189 }
mkarlsso 3:ae33b7f5a7c1 3190
mkarlsso 2:298679fff37c 3191 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3192 //pcPtr->printf("Action: variable equals expression\r\n");
mkarlsso 2:298679fff37c 3193 }
mkarlsso 2:298679fff37c 3194
mkarlsso 2:298679fff37c 3195 } else if ((tmpVar3 != NULL) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- variable
mkarlsso 2:298679fff37c 3196 if (tmpVar3 == tmpVar) {
mkarlsso 3:ae33b7f5a7c1 3197 multiplier.append("="); //makes "+=" or "-="
mkarlsso 2:298679fff37c 3198 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 2:298679fff37c 3199 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3200 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3201 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3202 tmpAction->release();
mkarlsso 2:298679fff37c 3203 return NULL;
mkarlsso 2:298679fff37c 3204 } else {
mkarlsso 2:298679fff37c 3205 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 2:298679fff37c 3206 }
mkarlsso 2:298679fff37c 3207 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3208 //pcPtr->printf("Action: change variable by constant amount\r\n");
mkarlsso 2:298679fff37c 3209 } else {
mkarlsso 3:ae33b7f5a7c1 3210
mkarlsso 2:298679fff37c 3211 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3212 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3213 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3214 tmpAction->release();
mkarlsso 2:298679fff37c 3215 return NULL;
mkarlsso 2:298679fff37c 3216 } else {
mkarlsso 3:ae33b7f5a7c1 3217 tmpOp2->set(tmpVar3, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso 3:ae33b7f5a7c1 3218 }
mkarlsso 3:ae33b7f5a7c1 3219 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3220
mkarlsso 3:ae33b7f5a7c1 3221 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3222 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3223 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3224 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3225 return NULL;
mkarlsso 3:ae33b7f5a7c1 3226 } else {
mkarlsso 2:298679fff37c 3227 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3228 }
mkarlsso 2:298679fff37c 3229 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3230 //pcPtr->printf("Action: variable equals expression\r\n");
mkarlsso 2:298679fff37c 3231 }
mkarlsso 2:298679fff37c 3232
mkarlsso 2:298679fff37c 3233 } else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso 3:ae33b7f5a7c1 3234
mkarlsso 2:298679fff37c 3235 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3236 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3237 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3238 tmpAction->release();
mkarlsso 2:298679fff37c 3239 return NULL;
mkarlsso 2:298679fff37c 3240 } else {
mkarlsso 3:ae33b7f5a7c1 3241 tmpOp2->set(tmpVar2, multiplier.data(), tmpVar3);
mkarlsso 3:ae33b7f5a7c1 3242 }
mkarlsso 3:ae33b7f5a7c1 3243 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3244
mkarlsso 3:ae33b7f5a7c1 3245 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3246 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3247 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3248 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3249 return NULL;
mkarlsso 3:ae33b7f5a7c1 3250 } else {
mkarlsso 3:ae33b7f5a7c1 3251
mkarlsso 2:298679fff37c 3252 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3253 }
mkarlsso 2:298679fff37c 3254 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3255 //pcPtr->printf("Action: set variable to operation involving two variables\r\n");
mkarlsso 2:298679fff37c 3256 //tmpVar->value = tmpVar2->value + (multiplier * tmpVar3->value);
mkarlsso 2:298679fff37c 3257 } else if ( isNumber(afterEqual.substr(stringInd2+1,std::string::npos)) && isNumber(afterEqual.substr(0,stringInd2)) ) { //number +/- number
mkarlsso 2:298679fff37c 3258 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso 2:298679fff37c 3259 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3260 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3261 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3262 tmpAction->release();
mkarlsso 2:298679fff37c 3263 return NULL;
mkarlsso 2:298679fff37c 3264 } else {
mkarlsso 2:298679fff37c 3265 tmpOp->set(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso 2:298679fff37c 3266 }
mkarlsso 2:298679fff37c 3267 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3268 //pcPtr->printf("Action: set variable to constant numeric value\r\n");
mkarlsso 2:298679fff37c 3269
mkarlsso 2:298679fff37c 3270 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //random +/- number
mkarlsso 2:298679fff37c 3271 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 2:298679fff37c 3272
mkarlsso 2:298679fff37c 3273 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3274
mkarlsso 3:ae33b7f5a7c1 3275
mkarlsso 2:298679fff37c 3276 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3277 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3278 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3279 tmpAction->release();
mkarlsso 2:298679fff37c 3280 return NULL;
mkarlsso 2:298679fff37c 3281 } else {
mkarlsso 3:ae33b7f5a7c1 3282 tmpOp2->set(highVal, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 3:ae33b7f5a7c1 3283 }
mkarlsso 3:ae33b7f5a7c1 3284 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3285
mkarlsso 3:ae33b7f5a7c1 3286 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3287 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3288 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3289 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3290 return NULL;
mkarlsso 3:ae33b7f5a7c1 3291 } else {
mkarlsso 2:298679fff37c 3292 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3293 }
mkarlsso 2:298679fff37c 3294 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3295 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3296 } else {
mkarlsso 2:298679fff37c 3297 //delete tmpAction;
mkarlsso 2:298679fff37c 3298 tmpAction->release();
mkarlsso 2:298679fff37c 3299 return NULL;
mkarlsso 2:298679fff37c 3300 }
mkarlsso 2:298679fff37c 3301 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso 2:298679fff37c 3302 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 2:298679fff37c 3303
mkarlsso 2:298679fff37c 3304 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3305
mkarlsso 3:ae33b7f5a7c1 3306
mkarlsso 2:298679fff37c 3307 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3308 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3309 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3310 tmpAction->release();
mkarlsso 2:298679fff37c 3311 return NULL;
mkarlsso 2:298679fff37c 3312 } else {
mkarlsso 3:ae33b7f5a7c1 3313 tmpOp2->set(highVal, multiplier.data(), tmpVar3);
mkarlsso 3:ae33b7f5a7c1 3314 }
mkarlsso 3:ae33b7f5a7c1 3315 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3316 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3317 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3318 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3319 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3320 return NULL;
mkarlsso 3:ae33b7f5a7c1 3321 } else {
mkarlsso 2:298679fff37c 3322 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3323 }
mkarlsso 2:298679fff37c 3324 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3325 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3326 } else {
mkarlsso 2:298679fff37c 3327 //delete tmpAction;
mkarlsso 2:298679fff37c 3328 tmpAction->release();
mkarlsso 2:298679fff37c 3329 return NULL;
mkarlsso 2:298679fff37c 3330 }
mkarlsso 2:298679fff37c 3331
mkarlsso 2:298679fff37c 3332
mkarlsso 2:298679fff37c 3333 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //random +/- number
mkarlsso 2:298679fff37c 3334 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 2:298679fff37c 3335
mkarlsso 2:298679fff37c 3336 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3337
mkarlsso 3:ae33b7f5a7c1 3338
mkarlsso 2:298679fff37c 3339 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3340 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3341 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3342 tmpAction->release();
mkarlsso 2:298679fff37c 3343 return NULL;
mkarlsso 2:298679fff37c 3344 } else {
mkarlsso 3:ae33b7f5a7c1 3345 tmpOp2->set(highVal, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso 3:ae33b7f5a7c1 3346 }
mkarlsso 3:ae33b7f5a7c1 3347 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3348 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3349 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3350 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3351 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3352 return NULL;
mkarlsso 3:ae33b7f5a7c1 3353 } else {
mkarlsso 2:298679fff37c 3354 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3355 }
mkarlsso 2:298679fff37c 3356 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3357 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3358 } else {
mkarlsso 2:298679fff37c 3359 //delete tmpAction;
mkarlsso 2:298679fff37c 3360 tmpAction->release();
mkarlsso 2:298679fff37c 3361 return NULL;
mkarlsso 2:298679fff37c 3362 }
mkarlsso 2:298679fff37c 3363 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && (tmpVar2 != NULL)) { //random +/- number
mkarlsso 2:298679fff37c 3364 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 2:298679fff37c 3365
mkarlsso 2:298679fff37c 3366 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3367
mkarlsso 3:ae33b7f5a7c1 3368
mkarlsso 2:298679fff37c 3369 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3370 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3371 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3372 tmpAction->release();
mkarlsso 2:298679fff37c 3373 return NULL;
mkarlsso 2:298679fff37c 3374 } else {
mkarlsso 3:ae33b7f5a7c1 3375 tmpOp2->set(highVal, multiplier.data(), tmpVar2);
mkarlsso 3:ae33b7f5a7c1 3376 }
mkarlsso 3:ae33b7f5a7c1 3377 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3378 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3379 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3380 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3381 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3382 return NULL;
mkarlsso 3:ae33b7f5a7c1 3383 } else {
mkarlsso 2:298679fff37c 3384 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3385 }
mkarlsso 2:298679fff37c 3386 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3387 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3388 } else {
mkarlsso 2:298679fff37c 3389 //delete tmpAction;
mkarlsso 2:298679fff37c 3390 tmpAction->release();
mkarlsso 2:298679fff37c 3391 return NULL;
mkarlsso 2:298679fff37c 3392 }
mkarlsso 2:298679fff37c 3393 } else {
mkarlsso 2:298679fff37c 3394 pcPtr->printf("Expression not understood: %s\r\n",afterEqual.data());
mkarlsso 2:298679fff37c 3395 //delete tmpAction;
mkarlsso 2:298679fff37c 3396 tmpAction->release();
mkarlsso 2:298679fff37c 3397 return NULL;
mkarlsso 2:298679fff37c 3398 }
mkarlsso 2:298679fff37c 3399
mkarlsso 2:298679fff37c 3400 } else if (findIntVariable(afterEqual) != NULL) { //assign value of another variable
mkarlsso 2:298679fff37c 3401 //tmpOp = new intOperation(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 2:298679fff37c 3402 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3403 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3404 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3405 tmpAction->release();
mkarlsso 2:298679fff37c 3406 return NULL;
mkarlsso 2:298679fff37c 3407 } else {
mkarlsso 2:298679fff37c 3408 tmpOp->set(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 2:298679fff37c 3409 }
mkarlsso 2:298679fff37c 3410 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3411 //pcPtr->printf("Action: set variable to value of another\r\n");
mkarlsso 2:298679fff37c 3412 } else {
mkarlsso 2:298679fff37c 3413 pcPtr->printf("Variable not found: %s\r\n",afterEqual.data());
mkarlsso 2:298679fff37c 3414 //delete tmpAction;
mkarlsso 2:298679fff37c 3415 tmpAction->release();
mkarlsso 2:298679fff37c 3416 return NULL;
mkarlsso 2:298679fff37c 3417 }
mkarlsso 2:298679fff37c 3418
mkarlsso 2:298679fff37c 3419 } else {
mkarlsso 2:298679fff37c 3420 pcPtr->printf("Variable not found\r\n");
mkarlsso 2:298679fff37c 3421 //delete tmpAction;
mkarlsso 2:298679fff37c 3422 tmpAction->release();
mkarlsso 2:298679fff37c 3423 return NULL;
mkarlsso 2:298679fff37c 3424 }
mkarlsso 2:298679fff37c 3425 return tmpAction;
mkarlsso 2:298679fff37c 3426 }
mkarlsso 2:298679fff37c 3427
mkarlsso 2:298679fff37c 3428 bool scriptStream::isOutsideParenth(string expression,std::size_t foundItem) {
mkarlsso 2:298679fff37c 3429
mkarlsso 2:298679fff37c 3430 int pDepth = 0; // How many nested parentheses
mkarlsso 2:298679fff37c 3431 //pcPtr->printf("Check outside parentheses...");
mkarlsso 2:298679fff37c 3432 if (foundItem < expression.length()) {
mkarlsso 2:298679fff37c 3433 for (int i = 0; i <= foundItem; i++) {
mkarlsso 2:298679fff37c 3434 if (expression[i] == '(') {
mkarlsso 2:298679fff37c 3435 pDepth++;
mkarlsso 2:298679fff37c 3436 } else if (expression[i] == ')') {
mkarlsso 2:298679fff37c 3437 pDepth--;
mkarlsso 2:298679fff37c 3438 }
mkarlsso 2:298679fff37c 3439 }
mkarlsso 2:298679fff37c 3440 if (pDepth<=0) {
mkarlsso 2:298679fff37c 3441 //pcPtr->printf("yes.");
mkarlsso 2:298679fff37c 3442 return true;
mkarlsso 2:298679fff37c 3443 } else {
mkarlsso 2:298679fff37c 3444 //pcPtr->printf("no.");
mkarlsso 2:298679fff37c 3445 return false;
mkarlsso 2:298679fff37c 3446 }
mkarlsso 2:298679fff37c 3447 } else {
mkarlsso 2:298679fff37c 3448 return true;
mkarlsso 2:298679fff37c 3449 }
mkarlsso 2:298679fff37c 3450
mkarlsso 2:298679fff37c 3451 }
mkarlsso 2:298679fff37c 3452
mkarlsso 2:298679fff37c 3453 std::size_t scriptStream::findFirstOrOutsideParenth(string expression) {
mkarlsso 2:298679fff37c 3454
mkarlsso 2:298679fff37c 3455 std::size_t foundItem = expression.find("||");
mkarlsso 2:298679fff37c 3456 while (foundItem != std::string::npos) {
mkarlsso 2:298679fff37c 3457 if (isOutsideParenth(expression,foundItem)) {
mkarlsso 2:298679fff37c 3458 break;
mkarlsso 2:298679fff37c 3459 }
mkarlsso 2:298679fff37c 3460 foundItem = expression.find("||",foundItem+1);
mkarlsso 2:298679fff37c 3461 }
mkarlsso 2:298679fff37c 3462 return foundItem;
mkarlsso 2:298679fff37c 3463 }
mkarlsso 2:298679fff37c 3464
mkarlsso 2:298679fff37c 3465 std::size_t scriptStream::findFirstAndOutsideParenth(string expression) {
mkarlsso 2:298679fff37c 3466
mkarlsso 2:298679fff37c 3467 std::size_t foundItem = expression.find("&&");
mkarlsso 2:298679fff37c 3468 while (foundItem != std::string::npos) {
mkarlsso 2:298679fff37c 3469 if (isOutsideParenth(expression,foundItem)){
mkarlsso 2:298679fff37c 3470 break;
mkarlsso 2:298679fff37c 3471 }
mkarlsso 2:298679fff37c 3472 foundItem = expression.find("&&",foundItem+1);
mkarlsso 2:298679fff37c 3473 }
mkarlsso 2:298679fff37c 3474 return foundItem;
mkarlsso 2:298679fff37c 3475 }
mkarlsso 2:298679fff37c 3476
mkarlsso 2:298679fff37c 3477 condition* scriptStream::parseConditions(string expression) {
mkarlsso 2:298679fff37c 3478 //This function is used to parse a condition string
mkarlsso 2:298679fff37c 3479 //such as (x < y && x != z) || (y == 2)
mkarlsso 2:298679fff37c 3480 //This function first identifies the root node of the logic tree
mkarlsso 2:298679fff37c 3481 //based on operator precedence ( () > && > || ), and then recursively calls itself
mkarlsso 2:298679fff37c 3482 //to find the nodes of the branches. The basic building blocks of
mkarlsso 2:298679fff37c 3483 //the final condition object are arithmatic comparitors (a > b) and
mkarlsso 2:298679fff37c 3484 //other condition objects.
mkarlsso 2:298679fff37c 3485
mkarlsso 2:298679fff37c 3486
mkarlsso 2:298679fff37c 3487 //pcPtr->printf("Parsing condition: %s\r\n", expression.data());
mkarlsso 2:298679fff37c 3488 condition* newCondition = NULL;
mkarlsso 2:298679fff37c 3489 bool singleCondition = false; //no compound conditions
mkarlsso 2:298679fff37c 3490 string afterComparator;
mkarlsso 2:298679fff37c 3491 string beforeComparator;
mkarlsso 2:298679fff37c 3492
mkarlsso 2:298679fff37c 3493 std::size_t found;
mkarlsso 2:298679fff37c 3494
mkarlsso 2:298679fff37c 3495 //To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso 2:298679fff37c 3496 //so we look for OR conditions first
mkarlsso 2:298679fff37c 3497 char currentOperator = OR_CONDITION;
mkarlsso 2:298679fff37c 3498 //pcPtr->printf("Looking for OR condition...");
mkarlsso 2:298679fff37c 3499 found = findFirstOrOutsideParenth(expression);
mkarlsso 2:298679fff37c 3500 if (found==std::string::npos) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso 2:298679fff37c 3501 currentOperator = AND_CONDITION;
mkarlsso 2:298679fff37c 3502 //pcPtr->printf("Looking for AND condition...");
mkarlsso 2:298679fff37c 3503 found = findFirstAndOutsideParenth(expression);
mkarlsso 2:298679fff37c 3504 }
mkarlsso 2:298679fff37c 3505 if (found==std::string::npos) { //no or/and conditions outside parentheses found
mkarlsso 2:298679fff37c 3506 //if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso 2:298679fff37c 3507 bool removedParenth = false;
mkarlsso 2:298679fff37c 3508 if ((expression[0] == '(') && (expression[expression.length()-1] == ')')) {
mkarlsso 2:298679fff37c 3509 //pcPtr->printf("Remove parentheses");
mkarlsso 2:298679fff37c 3510 expression = expression.substr(1,expression.length()-2);
mkarlsso 2:298679fff37c 3511 removedParenth = true;
mkarlsso 2:298679fff37c 3512 }
mkarlsso 2:298679fff37c 3513 if (removedParenth) { //we removed parentheses, so try again
mkarlsso 2:298679fff37c 3514 return parseConditions(expression);
mkarlsso 2:298679fff37c 3515 } else {
mkarlsso 2:298679fff37c 3516 singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso 2:298679fff37c 3517 }
mkarlsso 2:298679fff37c 3518 }
mkarlsso 2:298679fff37c 3519
mkarlsso 2:298679fff37c 3520 if (singleCondition) { //no compound conditions found
mkarlsso 2:298679fff37c 3521 //pcPtr->printf("Single condition");
mkarlsso 2:298679fff37c 3522 std::size_t equalStringInd;
mkarlsso 2:298679fff37c 3523 std::size_t greaterOrEqualStringInd;
mkarlsso 2:298679fff37c 3524 std::size_t lessThanOrEqualStringInd;
mkarlsso 2:298679fff37c 3525 std::size_t notEqualStringInd;
mkarlsso 2:298679fff37c 3526 std::size_t greaterThanStringInd;
mkarlsso 2:298679fff37c 3527 std::size_t lessThanStringInd;
mkarlsso 2:298679fff37c 3528 std::size_t generalCompareStringInd;
mkarlsso 2:298679fff37c 3529
mkarlsso 2:298679fff37c 3530
mkarlsso 2:298679fff37c 3531 string tmpCondition = expression;
mkarlsso 2:298679fff37c 3532 string compareString;
mkarlsso 2:298679fff37c 3533 //The expression might have up to three variables
mkarlsso 2:298679fff37c 3534 int* tmpVar;
mkarlsso 2:298679fff37c 3535 int* tmpVar2;
mkarlsso 2:298679fff37c 3536 int* tmpVar3;
mkarlsso 2:298679fff37c 3537
mkarlsso 2:298679fff37c 3538 int offset = 0;
mkarlsso 2:298679fff37c 3539 equalStringInd = tmpCondition.find("=="); //location of comparator
mkarlsso 2:298679fff37c 3540 greaterOrEqualStringInd = tmpCondition.find(">="); //location of comparator
mkarlsso 2:298679fff37c 3541 lessThanOrEqualStringInd = tmpCondition.find("<="); //location of comparator
mkarlsso 2:298679fff37c 3542 notEqualStringInd = tmpCondition.find("!="); //location of comparator
mkarlsso 2:298679fff37c 3543 greaterThanStringInd = tmpCondition.find_first_of(">"); //location of comparator
mkarlsso 2:298679fff37c 3544 lessThanStringInd = tmpCondition.find_first_of("<"); //location of comparator
mkarlsso 2:298679fff37c 3545
mkarlsso 2:298679fff37c 3546 if ((equalStringInd != std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3547 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3548
mkarlsso 2:298679fff37c 3549 generalCompareStringInd = equalStringInd;
mkarlsso 2:298679fff37c 3550 compareString = "==";
mkarlsso 2:298679fff37c 3551 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd != std::string::npos) &&
mkarlsso 2:298679fff37c 3552 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3553
mkarlsso 2:298679fff37c 3554 generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso 2:298679fff37c 3555 compareString = ">=";
mkarlsso 2:298679fff37c 3556 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3557 (lessThanOrEqualStringInd != std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3558
mkarlsso 2:298679fff37c 3559 generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso 2:298679fff37c 3560 compareString = "<=";
mkarlsso 2:298679fff37c 3561 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3562 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd != std::string::npos)){
mkarlsso 2:298679fff37c 3563
mkarlsso 2:298679fff37c 3564 generalCompareStringInd = notEqualStringInd;
mkarlsso 2:298679fff37c 3565 compareString = "!=";
mkarlsso 2:298679fff37c 3566 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3567 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3568 (greaterThanStringInd != std::string::npos) && (lessThanStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3569
mkarlsso 2:298679fff37c 3570 generalCompareStringInd = greaterThanStringInd;
mkarlsso 2:298679fff37c 3571 compareString = ">";
mkarlsso 2:298679fff37c 3572 offset = 1;
mkarlsso 2:298679fff37c 3573 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3574 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3575 (greaterThanStringInd == std::string::npos) && (lessThanStringInd != std::string::npos)){
mkarlsso 2:298679fff37c 3576
mkarlsso 2:298679fff37c 3577 generalCompareStringInd = lessThanStringInd;
mkarlsso 2:298679fff37c 3578 compareString = "<";
mkarlsso 2:298679fff37c 3579 offset = 1;
mkarlsso 2:298679fff37c 3580
mkarlsso 2:298679fff37c 3581 }else {
mkarlsso 2:298679fff37c 3582 pcPtr->printf("Condition not understood: %s\r\n", expression.data());
mkarlsso 2:298679fff37c 3583 return 0;
mkarlsso 2:298679fff37c 3584 }
mkarlsso 2:298679fff37c 3585
mkarlsso 2:298679fff37c 3586 intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso 2:298679fff37c 3587 if (newCompare == NULL) {
mkarlsso 2:298679fff37c 3588 pcPtr->printf("Error: No memory slots available.");
mkarlsso 2:298679fff37c 3589 return NULL;
mkarlsso 2:298679fff37c 3590 }
mkarlsso 2:298679fff37c 3591 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 2:298679fff37c 3592 if (newCondition == NULL) {
mkarlsso 2:298679fff37c 3593 pcPtr->printf("Error: No memory slots available.");
mkarlsso 2:298679fff37c 3594 return NULL;
mkarlsso 2:298679fff37c 3595 }
mkarlsso 2:298679fff37c 3596 afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso 2:298679fff37c 3597
mkarlsso 2:298679fff37c 3598 beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso 2:298679fff37c 3599 tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso 2:298679fff37c 3600 if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso 2:298679fff37c 3601 tmpVar2 = findIntVariable(afterComparator); //returns pointer to the variable
mkarlsso 2:298679fff37c 3602 if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso 2:298679fff37c 3603 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso 2:298679fff37c 3604 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 2:298679fff37c 3605 newCompare->set(tmpVar,compareString.data(),tmpVar2);
mkarlsso 2:298679fff37c 3606 newCondition->set(newCompare);
mkarlsso 2:298679fff37c 3607
mkarlsso 2:298679fff37c 3608 //pcPtr->printf("Var vs. Var condition added: %s\r\n", tmpCondition.data());
mkarlsso 2:298679fff37c 3609 } else if (isNumber(afterComparator)) {
mkarlsso 2:298679fff37c 3610 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 2:298679fff37c 3611 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 2:298679fff37c 3612 newCompare->set(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 2:298679fff37c 3613 newCondition->set(newCompare);
mkarlsso 2:298679fff37c 3614
mkarlsso 2:298679fff37c 3615 //pcPtr->printf("Var vs. Int condition added: %s\r\n", tmpCondition.data());
mkarlsso 2:298679fff37c 3616 } //more here
mkarlsso 2:298679fff37c 3617
mkarlsso 2:298679fff37c 3618 } else {
mkarlsso 2:298679fff37c 3619 pcPtr->printf("Condition not understood: %s\r\n", expression.data());
mkarlsso 2:298679fff37c 3620
mkarlsso 2:298679fff37c 3621 return NULL;
mkarlsso 2:298679fff37c 3622 }
mkarlsso 2:298679fff37c 3623
mkarlsso 2:298679fff37c 3624 } else { //this is a compound condition (with either && or ||)
mkarlsso 2:298679fff37c 3625 //pcPtr->printf("Compound condition");
mkarlsso 2:298679fff37c 3626 afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso 2:298679fff37c 3627 beforeComparator = expression.substr(0,found);
mkarlsso 2:298679fff37c 3628 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 2:298679fff37c 3629 if (newCondition == NULL) {
mkarlsso 2:298679fff37c 3630 pcPtr->printf("Error: No memory slots available.");
mkarlsso 2:298679fff37c 3631 return NULL;
mkarlsso 2:298679fff37c 3632 } else {
mkarlsso 2:298679fff37c 3633 newCondition->isUsed = true; //reserve the condition slot;
mkarlsso 2:298679fff37c 3634 }
mkarlsso 2:298679fff37c 3635 //recursively call this function to parse the sub conditions
mkarlsso 2:298679fff37c 3636 condition* cond1 = parseConditions(beforeComparator);
mkarlsso 2:298679fff37c 3637 if (cond1 == NULL) {
mkarlsso 2:298679fff37c 3638 newCondition->release();
mkarlsso 2:298679fff37c 3639 return NULL;
mkarlsso 2:298679fff37c 3640 }
mkarlsso 2:298679fff37c 3641 condition* cond2 = parseConditions(afterComparator);
mkarlsso 2:298679fff37c 3642 if (cond2 == NULL) {
mkarlsso 2:298679fff37c 3643 newCondition->release();
mkarlsso 2:298679fff37c 3644 cond1->release();
mkarlsso 2:298679fff37c 3645 return NULL;
mkarlsso 2:298679fff37c 3646 }
mkarlsso 2:298679fff37c 3647 newCondition->set(cond1,currentOperator, cond2);
mkarlsso 2:298679fff37c 3648
mkarlsso 2:298679fff37c 3649 }
mkarlsso 2:298679fff37c 3650
mkarlsso 2:298679fff37c 3651 return newCondition; //all went well, so return the newly made condition
mkarlsso 2:298679fff37c 3652
mkarlsso 2:298679fff37c 3653 }
mkarlsso 2:298679fff37c 3654
mkarlsso 2:298679fff37c 3655 bool scriptStream::evaluateConditions(string expression, event* currentEvent) {
mkarlsso 2:298679fff37c 3656 //calls the function to parse the condition string. The condition pointer is then
mkarlsso 2:298679fff37c 3657 //attached to the event
mkarlsso 2:298679fff37c 3658
mkarlsso 2:298679fff37c 3659 condition* newCondition = NULL;
mkarlsso 2:298679fff37c 3660 newCondition = parseConditions(expression);
mkarlsso 2:298679fff37c 3661 if (newCondition == NULL) {
mkarlsso 2:298679fff37c 3662 return false;
mkarlsso 2:298679fff37c 3663 } else {
mkarlsso 2:298679fff37c 3664 currentEvent->addCondition(newCondition);
mkarlsso 2:298679fff37c 3665 return true;
mkarlsso 2:298679fff37c 3666 }
mkarlsso 2:298679fff37c 3667 }
mkarlsso 2:298679fff37c 3668
mkarlsso 2:298679fff37c 3669 int scriptStream::getRandomParam(string expression) {
mkarlsso 2:298679fff37c 3670
mkarlsso 2:298679fff37c 3671 int pos1 = expression.find("random(")+7;
mkarlsso 2:298679fff37c 3672 int pos2 = expression.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 3673 int highVal = atoi(expression.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 3674
mkarlsso 2:298679fff37c 3675 if ((highVal > 0)) {
mkarlsso 2:298679fff37c 3676 return highVal;
mkarlsso 2:298679fff37c 3677 } else {
mkarlsso 2:298679fff37c 3678 pcPtr->printf("Error: random parameter must be 1 or more\r\n");
mkarlsso 2:298679fff37c 3679 return 0;
mkarlsso 2:298679fff37c 3680 }
mkarlsso 2:298679fff37c 3681 }
mkarlsso 2:298679fff37c 3682
mkarlsso 2:298679fff37c 3683
mkarlsso 2:298679fff37c 3684 outputStream::outputStream(int bufferSizeIn):
mkarlsso 2:298679fff37c 3685 readHead(0),
mkarlsso 2:298679fff37c 3686 writeHead(0),
mkarlsso 2:298679fff37c 3687 totalWriteHead(0),
mkarlsso 2:298679fff37c 3688 totalReadHead(0),
mkarlsso 2:298679fff37c 3689 bufferSize(bufferSizeIn),
mkarlsso 2:298679fff37c 3690 unsentData(false) {
mkarlsso 2:298679fff37c 3691
mkarlsso 2:298679fff37c 3692 outputBuffer = new char[bufferSize];
mkarlsso 2:298679fff37c 3693
mkarlsso 2:298679fff37c 3694 }
mkarlsso 2:298679fff37c 3695
mkarlsso 2:298679fff37c 3696 outputStream::~outputStream() {
mkarlsso 2:298679fff37c 3697 delete[] outputBuffer;
mkarlsso 2:298679fff37c 3698 }
mkarlsso 2:298679fff37c 3699
mkarlsso 2:298679fff37c 3700 //adds text to the buffer
mkarlsso 2:298679fff37c 3701 void outputStream::send(string outputString) {
mkarlsso 2:298679fff37c 3702 int strLen = outputString.size();
mkarlsso 2:298679fff37c 3703
mkarlsso 2:298679fff37c 3704 int total = 0;
mkarlsso 2:298679fff37c 3705 int chunk = 0;
mkarlsso 2:298679fff37c 3706 if (!(totalWriteHead+strLen > (totalReadHead + bufferSize))) {
mkarlsso 2:298679fff37c 3707 while (strLen - total > 0) {
mkarlsso 2:298679fff37c 3708 chunk = min((bufferSize - writeHead), strLen - total);
mkarlsso 2:298679fff37c 3709 outputString.copy(outputBuffer + writeHead, chunk, total);
mkarlsso 2:298679fff37c 3710 writeHead = (writeHead + chunk) % bufferSize;
mkarlsso 2:298679fff37c 3711 totalWriteHead += chunk;
mkarlsso 2:298679fff37c 3712 total += chunk;
mkarlsso 2:298679fff37c 3713 }
mkarlsso 2:298679fff37c 3714 if (total > 0) {
mkarlsso 2:298679fff37c 3715 unsentData = true;
mkarlsso 2:298679fff37c 3716 }
mkarlsso 2:298679fff37c 3717 }
mkarlsso 2:298679fff37c 3718 }
mkarlsso 2:298679fff37c 3719
mkarlsso 2:298679fff37c 3720 //the main loop gets one character per loop and write it to the serial port
mkarlsso 2:298679fff37c 3721 char outputStream::getNextChar() {
mkarlsso 2:298679fff37c 3722
mkarlsso 2:298679fff37c 3723
mkarlsso 2:298679fff37c 3724 if (totalReadHead < totalWriteHead) {
mkarlsso 2:298679fff37c 3725 tmpOut = *(outputBuffer+readHead);
mkarlsso 2:298679fff37c 3726 readHead = (readHead+1) % bufferSize;
mkarlsso 2:298679fff37c 3727 totalReadHead++;
mkarlsso 2:298679fff37c 3728 if (totalReadHead >= totalWriteHead) {
mkarlsso 2:298679fff37c 3729 unsentData = false;
mkarlsso 2:298679fff37c 3730 }
mkarlsso 2:298679fff37c 3731 }
mkarlsso 2:298679fff37c 3732 return tmpOut;
mkarlsso 2:298679fff37c 3733
mkarlsso 2:298679fff37c 3734 }
mkarlsso 2:298679fff37c 3735