Andy Lustig / Mbed 2 deprecated perturbRoom_legacy

perturh room legacy

Dependencies:   SMARTWAV USBDevice mbed stateScript

Fork of stateScript by Mattias Karlsson

behave.cpp@5:e62cd80aa22f, 2015-05-16 (annotated)

Committer:
alustig3
Date:
Sat May 16 23:41:46 2015 +0000
Revision:
5:e62cd80aa22f
Parent:
4:34aca2142df9 
changes

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
alustig3 5:e62cd80aa22f 19 extern USBSerial pc;
alustig3 5:e62cd80aa22f 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:e62cd80aa22f 134 digitalPort::digitalPort(DigitalOut* DOP): //added by me
alustig3 5:e62cd80aa22f 135 outPin(DOP),
alustig3 5:e62cd80aa22f 136 outState(0){
alustig3 5:e62cd80aa22f 137
alustig3 5:e62cd80aa22f 138 lastChangeTime = 0;
alustig3 5:e62cd80aa22f 139 lastOutChangeTime = 0;
alustig3 5:e62cd80aa22f 140 lastChangeInterval = 0;
alustig3 5:e62cd80aa22f 141 lastDownEvent.triggered = false;
alustig3 5:e62cd80aa22f 142 lastUpEvent.triggered = false;
alustig3 5:e62cd80aa22f 143 triggerUpEventPtr = NULL;
alustig3 5:e62cd80aa22f 144 triggerDownEventPtr = NULL;
alustig3 5:e62cd80aa22f 145 outStateChanged = false;
alustig3 5:e62cd80aa22f 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
alustig3 5:e62cd80aa22f 274 displayAction::displayAction(int* variable, string varNameInput, USBSerial* 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
alustig3 5:e62cd80aa22f 282 displayAction::displayAction(string text, USBSerial* 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
alustig3 5:e62cd80aa22f 289 void displayAction::set(int* variable, string varNameInput, USBSerial* 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
alustig3 5:e62cd80aa22f 297 void displayAction::set(string text, USBSerial* 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:e62cd80aa22f 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
alustig3 5:e62cd80aa22f 1695 scriptStream::scriptStream(USBSerial* 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:e62cd80aa22f 1705
alustig3 5:e62cd80aa22f 1706 lineError = false;
alustig3 5:e62cd80aa22f 1707 blockDepth = 0;
alustig3 5:e62cd80aa22f 1708 ifBlockInit = false;
alustig3 5:e62cd80aa22f 1709 whileBlockInit = false;
alustig3 5:e62cd80aa22f 1710 elseFlag = false;
alustig3 5:e62cd80aa22f 1711 currentDelay = 0;
mkarlsso 4:34aca2142df9 1712
alustig3 5:e62cd80aa22f 1713 }
alustig3 5:e62cd80aa22f 1714
alustig3 5:e62cd80aa22f 1715 void scriptStream::addLineToCurrentBlock(char* lineInput) {
mkarlsso 2:298679fff37c 1716
alustig3 5:e62cd80aa22f 1717 bool compile = false;
alustig3 5:e62cd80aa22f 1718 bool keep = false;
alustig3 5:e62cd80aa22f 1719 for (int i = 0; i < 128; i++) {
alustig3 5:e62cd80aa22f 1720 if (lineInput[i] == ';') {
alustig3 5:e62cd80aa22f 1721 compile = true;
alustig3 5:e62cd80aa22f 1722 } else if (lineInput[i] == ' ') {
alustig3 5:e62cd80aa22f 1723 continue;
alustig3 5:e62cd80aa22f 1724 } else if (lineInput[i] == '\0') {
alustig3 5:e62cd80aa22f 1725 break;
alustig3 5:e62cd80aa22f 1726 } else {
alustig3 5:e62cd80aa22f 1727 keep = true;
alustig3 5:e62cd80aa22f 1728 compile = false;
alustig3 5:e62cd80aa22f 1729 }
alustig3 5:e62cd80aa22f 1730 }
alustig3 5:e62cd80aa22f 1731 if (keep) currentBlock.insert(currentBlock.begin(),string(lineInput));
alustig3 5:e62cd80aa22f 1732 if (compile) parseBlock();
alustig3 5:e62cd80aa22f 1733
alustig3 5:e62cd80aa22f 1734 }
alustig3 5:e62cd80aa22f 1735
alustig3 5:e62cd80aa22f 1736
alustig3 5:e62cd80aa22f 1737 //SCRIPT PARSING - all script commands are defined here.
alustig3 5:e62cd80aa22f 1738 //-------------------------------------------------------
alustig3 5:e62cd80aa22f 1739 void scriptStream::parseBlock() {
alustig3 5:e62cd80aa22f 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:e62cd80aa22f 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();
alustig3 5:e62cd80aa22f 1863 } else if (isText) {
mkarlsso 2:298679fff37c 1864 if (pos2-pos1-2 <= 20) {
mkarlsso 2:298679fff37c 1865 soundControl S;
mkarlsso 2:298679fff37c 1866 S.setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
alustig3 5:e62cd80aa22f 1867 S.setPlayback(true);//ANDY
mkarlsso 2:298679fff37c 1868 S.execute();
mkarlsso 2:298679fff37c 1869 } else {
mkarlsso 2:298679fff37c 1870 pcPtr->printf("Error: sound file names must be 20 characters or less.\r\n");
mkarlsso 2:298679fff37c 1871 lineError = true;
mkarlsso 2:298679fff37c 1872 }
mkarlsso 2:298679fff37c 1873 } else {
mkarlsso 2:298679fff37c 1874 pcPtr->printf("Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n");
mkarlsso 2:298679fff37c 1875 lineError = true;
mkarlsso 2:298679fff37c 1876 }
mkarlsso 2:298679fff37c 1877
mkarlsso 2:298679fff37c 1878 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 2:298679fff37c 1879 //the disp function was put inside a block
mkarlsso 2:298679fff37c 1880 if (stopSignal) {
mkarlsso 2:298679fff37c 1881 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1882 sPtr->setPlayback(false);
mkarlsso 2:298679fff37c 1883 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1884 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1885 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1886 } else if (resetSignal) {
mkarlsso 2:298679fff37c 1887 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1888 sPtr->setReset();
mkarlsso 2:298679fff37c 1889 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1890 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1891 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1892 } else if (isText) {
mkarlsso 2:298679fff37c 1893
mkarlsso 2:298679fff37c 1894 if (pos2-pos1-2 <= 20) {
mkarlsso 2:298679fff37c 1895 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1896 sPtr->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 2:298679fff37c 1897 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1898 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1899 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1900 } else {
mkarlsso 2:298679fff37c 1901 pcPtr->printf("Error: sound file names must be 20 characters or less.\r\n");
mkarlsso 2:298679fff37c 1902 lineError = true;
mkarlsso 2:298679fff37c 1903 }
mkarlsso 2:298679fff37c 1904 } else {
mkarlsso 2:298679fff37c 1905 pcPtr->printf("Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n");
mkarlsso 2:298679fff37c 1906 lineError = true;
mkarlsso 2:298679fff37c 1907 }
mkarlsso 2:298679fff37c 1908
mkarlsso 2:298679fff37c 1909 //pcPtr->printf("Sound action\r\n");
mkarlsso 2:298679fff37c 1910 }
mkarlsso 2:298679fff37c 1911
mkarlsso 2:298679fff37c 1912 } else if (tokens[i].find("volume(") != std::string::npos) {
mkarlsso 2:298679fff37c 1913 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 1914 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 1915 lineError = true;
mkarlsso 2:298679fff37c 1916 }
mkarlsso 2:298679fff37c 1917 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 1918 int pos1 = tmpLine.find("volume(")+7;
mkarlsso 2:298679fff37c 1919 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 1920 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 1921
mkarlsso 2:298679fff37c 1922 int* tmpVar = findIntVariable(dispVar);
mkarlsso 2:298679fff37c 1923 bool isText = false;
mkarlsso 2:298679fff37c 1924 if (tmpVar == NULL) {
mkarlsso 2:298679fff37c 1925 if (isNumber(dispVar)) {
mkarlsso 2:298679fff37c 1926 isText = true;
mkarlsso 2:298679fff37c 1927 } else {
mkarlsso 2:298679fff37c 1928 pcPtr->printf("Error: variable input to volume() does not exist\r\n");
mkarlsso 2:298679fff37c 1929 lineError = true;
mkarlsso 2:298679fff37c 1930 }
mkarlsso 2:298679fff37c 1931 }
mkarlsso 2:298679fff37c 1932 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 1933 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 1934 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 1935 lineError = true;
mkarlsso 2:298679fff37c 1936 }
mkarlsso 2:298679fff37c 1937 if (!lineError && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 1938 //we are not inside a block structure, so play sound now
mkarlsso 2:298679fff37c 1939 if (isText) {
mkarlsso 2:298679fff37c 1940 int newVolume = atoi(dispVar.data());
mkarlsso 2:298679fff37c 1941 if ((newVolume >=0)&&(newVolume <= 255)) {
mkarlsso 2:298679fff37c 1942 soundControl S;
mkarlsso 2:298679fff37c 1943 S.setVolume(newVolume);
mkarlsso 2:298679fff37c 1944 S.execute();
mkarlsso 2:298679fff37c 1945 } else {
mkarlsso 2:298679fff37c 1946 pcPtr->printf("Error: sound volume must be between 0 and 255 .\r\n");
mkarlsso 2:298679fff37c 1947 lineError = true;
mkarlsso 2:298679fff37c 1948 }
mkarlsso 2:298679fff37c 1949 } else {
mkarlsso 2:298679fff37c 1950 soundControl S;
mkarlsso 2:298679fff37c 1951 S.setVolume(tmpVar);
mkarlsso 2:298679fff37c 1952 S.execute();
mkarlsso 2:298679fff37c 1953 }
mkarlsso 2:298679fff37c 1954
mkarlsso 2:298679fff37c 1955 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 2:298679fff37c 1956 //the disp function was put inside a block
mkarlsso 2:298679fff37c 1957 if (isText) {
mkarlsso 2:298679fff37c 1958 int newVolume = atoi(dispVar.data());
mkarlsso 2:298679fff37c 1959
mkarlsso 2:298679fff37c 1960 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1961 sPtr->setVolume(newVolume);
mkarlsso 2:298679fff37c 1962
mkarlsso 2:298679fff37c 1963 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1964 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1965 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1966
mkarlsso 2:298679fff37c 1967 } else {
mkarlsso 2:298679fff37c 1968 soundControl* sPtr = new soundControl();
mkarlsso 2:298679fff37c 1969 sPtr->setVolume(tmpVar);
mkarlsso 2:298679fff37c 1970 //action* tmpAction = new action(sPtr);
mkarlsso 2:298679fff37c 1971 tmpAction->set(sPtr);
mkarlsso 2:298679fff37c 1972 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 1973 }
mkarlsso 2:298679fff37c 1974
mkarlsso 2:298679fff37c 1975 //pcPtr->printf("Volume action\r\n");
mkarlsso 2:298679fff37c 1976 }
mkarlsso 2:298679fff37c 1977 //clock statement used to is used to control the clock-------------------------
mkarlsso 2:298679fff37c 1978 //example: clock(reset); clock(slave); clock(standalone)
mkarlsso 2:298679fff37c 1979 } else if (tokens[i].find("clock(") != std::string::npos) { //clock commands
mkarlsso 2:298679fff37c 1980 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 1981 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 1982 lineError = true;
mkarlsso 2:298679fff37c 1983 }
mkarlsso 2:298679fff37c 1984 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 1985 pcPtr->printf("Error: clock commands only allowed outside of block structure\r\n");
mkarlsso 2:298679fff37c 1986 lineError = true;
mkarlsso 2:298679fff37c 1987 }
mkarlsso 2:298679fff37c 1988
mkarlsso 2:298679fff37c 1989 if (!lineError) {
mkarlsso 2:298679fff37c 1990 int pos1 = tmpLine.find("clock(")+6;
mkarlsso 2:298679fff37c 1991 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 1992 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 1993
mkarlsso 2:298679fff37c 1994
mkarlsso 2:298679fff37c 1995 if (blockDepth == 0) {
mkarlsso 2:298679fff37c 1996 if (dispVar.compare("reset") == 0) {
mkarlsso 2:298679fff37c 1997 resetTimer = true;
mkarlsso 2:298679fff37c 1998 queuePtr->eraseQueue();
mkarlsso 2:298679fff37c 1999 textDisplay.send(string("Clock reset to 0\r\n"));
mkarlsso 2:298679fff37c 2000 //pcPtr->printf("Clock reset to 0\r\n");
mkarlsso 2:298679fff37c 2001 } else if (dispVar.compare("slave") == 0) {
mkarlsso 2:298679fff37c 2002 if (!clockSlave) {
mkarlsso 2:298679fff37c 2003 changeToSlave = true;
mkarlsso 2:298679fff37c 2004 textDisplay.send(string("Slave mode\r\n"));
mkarlsso 2:298679fff37c 2005 //pcPtr->printf("Slave mode\r\n");
mkarlsso 2:298679fff37c 2006 }
mkarlsso 2:298679fff37c 2007 } else if (dispVar.compare("standalone") == 0) {
mkarlsso 2:298679fff37c 2008 if (clockSlave) {
mkarlsso 2:298679fff37c 2009 changeToStandAlone = true;
mkarlsso 2:298679fff37c 2010 textDisplay.send(string("Standalone mode\r\n"));
mkarlsso 2:298679fff37c 2011 //pcPtr->printf("Standalone mode\r\n");
mkarlsso 2:298679fff37c 2012 }
mkarlsso 2:298679fff37c 2013 } else {
mkarlsso 2:298679fff37c 2014 pcPtr->printf("Clock control statement not understood\r\n");
mkarlsso 2:298679fff37c 2015 lineError = true;
mkarlsso 2:298679fff37c 2016 }
mkarlsso 2:298679fff37c 2017 }
mkarlsso 2:298679fff37c 2018 }
mkarlsso 2:298679fff37c 2019
mkarlsso 2:298679fff37c 2020 //disp command used to display text via serial---------------------------------------
mkarlsso 2:298679fff37c 2021 //example: disp('hello'); disp(myVar)
mkarlsso 2:298679fff37c 2022 } else if (tokens[i].find("disp(") != std::string::npos) { //display value of variable
mkarlsso 2:298679fff37c 2023
mkarlsso 2:298679fff37c 2024 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2025 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2026 lineError = true;
mkarlsso 2:298679fff37c 2027 }
mkarlsso 2:298679fff37c 2028
mkarlsso 2:298679fff37c 2029 //int pos1 = tokens[i].find("disp(")+5;
mkarlsso 2:298679fff37c 2030 //int pos2 = tokens[i].find_first_of(")",pos1);
mkarlsso 2:298679fff37c 2031 //string dispVar = tokens[i].substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 2032
mkarlsso 2:298679fff37c 2033 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2034 int pos1 = tmpLine.find("disp(")+5;
mkarlsso 2:298679fff37c 2035 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 2036 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 2:298679fff37c 2037
mkarlsso 2:298679fff37c 2038 int* tmpVar = findIntVariable(dispVar);
mkarlsso 2:298679fff37c 2039 bool isText = false;
mkarlsso 2:298679fff37c 2040 if (tmpVar == NULL) {
mkarlsso 2:298679fff37c 2041 if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso 2:298679fff37c 2042 isText = true;
mkarlsso 2:298679fff37c 2043 } else {
mkarlsso 2:298679fff37c 2044 pcPtr->printf("Error: variable to display does not exist\r\n");
mkarlsso 2:298679fff37c 2045 lineError = true;
mkarlsso 2:298679fff37c 2046 }
mkarlsso 2:298679fff37c 2047 }
mkarlsso 2:298679fff37c 2048 displayAction* dPtr = findFirstUnUsed(displayActionBlock, NUMDISPLAYACTIONS);
mkarlsso 2:298679fff37c 2049 if (dPtr == NULL) {
mkarlsso 2:298679fff37c 2050 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2051 lineError = true;
mkarlsso 2:298679fff37c 2052 }
mkarlsso 2:298679fff37c 2053 if (!lineError && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 2054 //we are not inside a block structure, so display now
mkarlsso 2:298679fff37c 2055
mkarlsso 2:298679fff37c 2056 if (isText) {
mkarlsso 2:298679fff37c 2057 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2058 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2059 dPtr->execute();
mkarlsso 2:298679fff37c 2060 //delete dPtr;
mkarlsso 2:298679fff37c 2061 dPtr->release();
mkarlsso 2:298679fff37c 2062 } else {
mkarlsso 2:298679fff37c 2063 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2064 dPtr->set(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2065 dPtr->execute();
mkarlsso 2:298679fff37c 2066 //delete dPtr;
mkarlsso 2:298679fff37c 2067 dPtr->release();
mkarlsso 2:298679fff37c 2068 }
mkarlsso 2:298679fff37c 2069
mkarlsso 2:298679fff37c 2070 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 2:298679fff37c 2071 //the disp function was put inside a block
mkarlsso 2:298679fff37c 2072 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2073 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2074 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2075 lineError = true;
mkarlsso 2:298679fff37c 2076 }
mkarlsso 2:298679fff37c 2077 if (!lineError && isText) {
mkarlsso 2:298679fff37c 2078 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2079 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 2:298679fff37c 2080 tmpAction->set(dPtr);
mkarlsso 2:298679fff37c 2081 //action* tmpAction = new action(dPtr);
mkarlsso 2:298679fff37c 2082 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2083 } else if (!lineError) {
mkarlsso 2:298679fff37c 2084 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2085 dPtr->set(tmpVar, dispVar, pcPtr);
mkarlsso 2:298679fff37c 2086 tmpAction->set(dPtr);
mkarlsso 2:298679fff37c 2087 //action* tmpAction = new action(dPtr);
mkarlsso 2:298679fff37c 2088 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2089 }
mkarlsso 2:298679fff37c 2090
mkarlsso 2:298679fff37c 2091 //pcPtr->printf("Display action\r\n");
mkarlsso 2:298679fff37c 2092 }
mkarlsso 2:298679fff37c 2093
mkarlsso 2:298679fff37c 2094
mkarlsso 2:298679fff37c 2095 //int is used to decalar new variables. Only allowed outside of callbacks-------------------
mkarlsso 2:298679fff37c 2096 //example: int a; int b = 9
mkarlsso 2:298679fff37c 2097 } else if (tokens[i].compare("int") == 0) { //define a new integer variable
mkarlsso 2:298679fff37c 2098
mkarlsso 2:298679fff37c 2099 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2100 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2101 lineError = true;
mkarlsso 2:298679fff37c 2102 }
mkarlsso 2:298679fff37c 2103 tmpString = "";
mkarlsso 2:298679fff37c 2104 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2105 int spacesBeforeEqualSign = 0;
mkarlsso 2:298679fff37c 2106 bool countSpaces = true;
mkarlsso 2:298679fff37c 2107 //combine the tokens without whitespaces
mkarlsso 2:298679fff37c 2108 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 2:298679fff37c 2109 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2110 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 2:298679fff37c 2111 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2112 countSpaces = false;
mkarlsso 2:298679fff37c 2113 } else if (countSpaces) {
mkarlsso 2:298679fff37c 2114 spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2115 }
mkarlsso 2:298679fff37c 2116 }
mkarlsso 2:298679fff37c 2117
mkarlsso 2:298679fff37c 2118 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 2119 pcPtr->printf("Error: Variables can only be first declared outside of callbacks.\r\n");
mkarlsso 2:298679fff37c 2120 lineError = true;
mkarlsso 2:298679fff37c 2121 }
mkarlsso 2:298679fff37c 2122
mkarlsso 2:298679fff37c 2123 if ((!lineError) && (spacesBeforeEqualSign > 1)) {
mkarlsso 2:298679fff37c 2124 pcPtr->printf("Error: Variable can't have a space in it.\r\n");
mkarlsso 2:298679fff37c 2125 lineError = true;
mkarlsso 2:298679fff37c 2126 }
mkarlsso 2:298679fff37c 2127 stringInd = tmpString.find_first_of("=");
mkarlsso 2:298679fff37c 2128
mkarlsso 2:298679fff37c 2129 bool variableCreated = false;
mkarlsso 2:298679fff37c 2130 if (!lineError) {
mkarlsso 2:298679fff37c 2131 if (((stringInd == std::string::npos) && (sz == 2)) || (stringInd != std::string::npos)) {
mkarlsso 2:298679fff37c 2132 if (createIntVariable(tmpString.substr(0,stringInd))) {
mkarlsso 2:298679fff37c 2133 //pcPtr->printf("Created variable: %s\r\n", tmpString.substr(0,stringInd).data());
mkarlsso 2:298679fff37c 2134 variableCreated = true;
mkarlsso 2:298679fff37c 2135 } else {
mkarlsso 2:298679fff37c 2136 int* tmpVar = findIntVariable(tmpString.substr(0,stringInd));
mkarlsso 2:298679fff37c 2137 *tmpVar = 0;
mkarlsso 2:298679fff37c 2138 //pcPtr->printf("Reset variable %s to 0\r\n", tmpString.substr(0,stringInd).data());
mkarlsso 2:298679fff37c 2139 //lineError = true;
mkarlsso 2:298679fff37c 2140 }
mkarlsso 2:298679fff37c 2141 } else {
mkarlsso 2:298679fff37c 2142 pcPtr->printf("Error: variable declaration not understood.\r\n", tmpString.substr(0,stringInd).data());
mkarlsso 2:298679fff37c 2143 lineError = true;
mkarlsso 2:298679fff37c 2144 }
mkarlsso 2:298679fff37c 2145 }
mkarlsso 2:298679fff37c 2146
mkarlsso 2:298679fff37c 2147 if ((!lineError) && (stringInd != std::string::npos)) { //evaluate the expression
mkarlsso 2:298679fff37c 2148 action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 2:298679fff37c 2149 if (tmpAction != NULL) {
mkarlsso 2:298679fff37c 2150 tmpAction->execute();
mkarlsso 2:298679fff37c 2151 //delete tmpAction;
mkarlsso 2:298679fff37c 2152 tmpAction->release();
mkarlsso 2:298679fff37c 2153 } else {
mkarlsso 2:298679fff37c 2154 lineError = true;
mkarlsso 2:298679fff37c 2155 if (variableCreated) {
mkarlsso 2:298679fff37c 2156 delete globalVariables.back();
mkarlsso 2:298679fff37c 2157 globalVariables.pop_back();
mkarlsso 2:298679fff37c 2158 }
mkarlsso 2:298679fff37c 2159 }
mkarlsso 2:298679fff37c 2160 }
mkarlsso 2:298679fff37c 2161
mkarlsso 2:298679fff37c 2162 //serial command is used to toggle whether or not to buffer up output text----------------
mkarlsso 2:298679fff37c 2163 //examples: serial buffer; serial send
mkarlsso 2:298679fff37c 2164 } else if (tokens[i].compare("serial") == 0) {
mkarlsso 2:298679fff37c 2165 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2166 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2167 lineError = true;
mkarlsso 2:298679fff37c 2168 }
mkarlsso 2:298679fff37c 2169 bool stream = true;
mkarlsso 2:298679fff37c 2170 if ((!lineError)&&(i+1 < sz)){
mkarlsso 2:298679fff37c 2171 if (tokens[i+1].compare("buffer") == 0) {
mkarlsso 2:298679fff37c 2172 stream = false;
mkarlsso 2:298679fff37c 2173 } else if (tokens[i+1].compare("send") == 0) {
mkarlsso 2:298679fff37c 2174 stream = true;
mkarlsso 2:298679fff37c 2175 } else {
mkarlsso 2:298679fff37c 2176 pcPtr->printf("Error: 'serial' useage: 'serial buffer' or 'serial send'\r\n");
mkarlsso 2:298679fff37c 2177 lineError = true;
mkarlsso 2:298679fff37c 2178 }
mkarlsso 2:298679fff37c 2179 }
mkarlsso 2:298679fff37c 2180 i++;
mkarlsso 2:298679fff37c 2181 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 2182 if (stream) {
mkarlsso 2:298679fff37c 2183 textStreaming = true;
mkarlsso 2:298679fff37c 2184 } else {
mkarlsso 2:298679fff37c 2185 textStreaming = false;
mkarlsso 2:298679fff37c 2186 }
mkarlsso 2:298679fff37c 2187 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2188 if (stream) {
mkarlsso 2:298679fff37c 2189 //action* tmpAction = new action(1); //code 1 = turn on text streaming
mkarlsso 2:298679fff37c 2190 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2191 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2192 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2193 lineError = true;
mkarlsso 2:298679fff37c 2194 } else {
mkarlsso 2:298679fff37c 2195 tmpAction->set(1);
mkarlsso 2:298679fff37c 2196 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2197 }
mkarlsso 2:298679fff37c 2198
mkarlsso 2:298679fff37c 2199 } else {
mkarlsso 2:298679fff37c 2200 //action* tmpAction = new action(2); //code 2 = turn on text buffering
mkarlsso 2:298679fff37c 2201 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2202 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2203 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2204 lineError = true;
mkarlsso 2:298679fff37c 2205 } else {
mkarlsso 2:298679fff37c 2206 tmpAction->set(2);
mkarlsso 2:298679fff37c 2207 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2208 }
mkarlsso 2:298679fff37c 2209 }
mkarlsso 2:298679fff37c 2210 }
mkarlsso 2:298679fff37c 2211
mkarlsso 2:298679fff37c 2212 //updates command toggles the DIO update messages upon a change------------------
mkarlsso 2:298679fff37c 2213 //examples: updates on; updates off
mkarlsso 2:298679fff37c 2214 } else if (tokens[i].compare("updates") == 0) {
mkarlsso 2:298679fff37c 2215 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2216 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2217 lineError = true;
mkarlsso 2:298679fff37c 2218 }
mkarlsso 2:298679fff37c 2219 bool stream = true;
mkarlsso 2:298679fff37c 2220 if ((!lineError)&&(i+1 < sz)){
mkarlsso 2:298679fff37c 2221 if (tokens[i+1].compare("on") == 0) {
mkarlsso 2:298679fff37c 2222 stream = true;
mkarlsso 2:298679fff37c 2223 } else if (tokens[i+1].compare("off") == 0) {
mkarlsso 2:298679fff37c 2224 stream = false;
mkarlsso 2:298679fff37c 2225 } else {
mkarlsso 2:298679fff37c 2226 pcPtr->printf("Error: 'updates' useage: 'updates on' or 'updates off'\r\n");
mkarlsso 2:298679fff37c 2227 lineError = true;
mkarlsso 2:298679fff37c 2228 }
mkarlsso 2:298679fff37c 2229 }
mkarlsso 2:298679fff37c 2230 i++;
mkarlsso 2:298679fff37c 2231 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 2:298679fff37c 2232 if (stream) {
mkarlsso 2:298679fff37c 2233 broadCastStateChanges = true;
mkarlsso 2:298679fff37c 2234 } else {
mkarlsso 2:298679fff37c 2235 broadCastStateChanges = false;
mkarlsso 2:298679fff37c 2236 }
mkarlsso 2:298679fff37c 2237 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2238 if (stream) {
mkarlsso 2:298679fff37c 2239 //action* tmpAction = new action(3); //code 3 = turn on updates
mkarlsso 2:298679fff37c 2240 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2241 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2242 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2243 lineError = true;
mkarlsso 2:298679fff37c 2244 } else {
mkarlsso 2:298679fff37c 2245 tmpAction->set(3);
mkarlsso 2:298679fff37c 2246 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2247 }
mkarlsso 2:298679fff37c 2248 } else {
mkarlsso 2:298679fff37c 2249 //action* tmpAction = new action(4); //code 4 = turn off updates
mkarlsso 2:298679fff37c 2250 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2251 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2252 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2253 lineError = true;
mkarlsso 2:298679fff37c 2254 } else {
mkarlsso 2:298679fff37c 2255 tmpAction->set(4);
mkarlsso 2:298679fff37c 2256 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2257 }
mkarlsso 2:298679fff37c 2258
mkarlsso 2:298679fff37c 2259 }
mkarlsso 2:298679fff37c 2260 }
mkarlsso 2:298679fff37c 2261
mkarlsso 2:298679fff37c 2262 //clear is used to clear things from memory---------------------------------
mkarlsso 2:298679fff37c 2263 //examples: clear all; clear callbacks; clear queue
mkarlsso 2:298679fff37c 2264 } else if (tokens[i].compare("ram") == 0) {
mkarlsso 2:298679fff37c 2265 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2266 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2267 lineError = true;
mkarlsso 2:298679fff37c 2268 }
mkarlsso 2:298679fff37c 2269 if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2270 pcPtr->printf("Error: ram statement is not allowed inside a block.\r\n");
mkarlsso 2:298679fff37c 2271 lineError = true;
mkarlsso 2:298679fff37c 2272 }
mkarlsso 2:298679fff37c 2273 if (!lineError) {
mkarlsso 2:298679fff37c 2274 DisplayRAMBanks();
mkarlsso 2:298679fff37c 2275 }
mkarlsso 2:298679fff37c 2276 } else if (tokens[i].compare("memory") == 0) {
mkarlsso 2:298679fff37c 2277 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2278 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2279 lineError = true;
mkarlsso 2:298679fff37c 2280 }
mkarlsso 2:298679fff37c 2281 if ((!lineError) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2282 pcPtr->printf("Error: memory statement is not allowed inside a block.\r\n");
mkarlsso 2:298679fff37c 2283 lineError = true;
mkarlsso 2:298679fff37c 2284 }
mkarlsso 2:298679fff37c 2285 if (!lineError) {
mkarlsso 2:298679fff37c 2286 displayMemoryLeft();
mkarlsso 2:298679fff37c 2287 }
mkarlsso 2:298679fff37c 2288
mkarlsso 2:298679fff37c 2289
mkarlsso 2:298679fff37c 2290 } else if (tokens[i].compare("clear") == 0) { //delete all created events and variables
mkarlsso 2:298679fff37c 2291 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2292 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2293 lineError = true;
mkarlsso 2:298679fff37c 2294 }
mkarlsso 2:298679fff37c 2295 int clearMode = 0;
mkarlsso 2:298679fff37c 2296 if ((!lineError)&&(i+1 < sz)){
mkarlsso 2:298679fff37c 2297 if (tokens[i+1].compare("all") == 0) {
mkarlsso 2:298679fff37c 2298 clearMode = 1;
mkarlsso 2:298679fff37c 2299 } else if (tokens[i+1].compare("blocks") == 0) {
mkarlsso 2:298679fff37c 2300 clearMode = 2;
mkarlsso 2:298679fff37c 2301 } else if (tokens[i+1].compare("queue") == 0) {
mkarlsso 2:298679fff37c 2302 clearMode = 3;
mkarlsso 2:298679fff37c 2303 } else {
mkarlsso 2:298679fff37c 2304 pcPtr->printf("Error: clear what: all, blocks, or queue? \r\n");
mkarlsso 2:298679fff37c 2305 lineError = true;
mkarlsso 2:298679fff37c 2306 }
mkarlsso 2:298679fff37c 2307 } else {
mkarlsso 2:298679fff37c 2308 pcPtr->printf("Error: clear what: all, blocks, or queue? \r\n");
mkarlsso 2:298679fff37c 2309 lineError = true;
mkarlsso 2:298679fff37c 2310 }
mkarlsso 2:298679fff37c 2311
mkarlsso 2:298679fff37c 2312
mkarlsso 2:298679fff37c 2313 if ((!lineError) && (clearMode < 3) && (blockDepth > 0)) {
mkarlsso 2:298679fff37c 2314 pcPtr->printf("Error: 'clear all' and 'clear blocks' only allowed outside of block structures\r\n");
mkarlsso 2:298679fff37c 2315 lineError = true;
mkarlsso 2:298679fff37c 2316 }
mkarlsso 2:298679fff37c 2317 if (!lineError) {
mkarlsso 2:298679fff37c 2318 i++;
mkarlsso 2:298679fff37c 2319 //clear variables
mkarlsso 2:298679fff37c 2320 if (clearMode == 1) {
mkarlsso 2:298679fff37c 2321 while (!globalVariables.empty()) {
mkarlsso 2:298679fff37c 2322 globalVariables.pop_back();
mkarlsso 2:298679fff37c 2323 }
mkarlsso 2:298679fff37c 2324 }
mkarlsso 2:298679fff37c 2325
mkarlsso 2:298679fff37c 2326 //clear callbacks, functions, and queue
mkarlsso 2:298679fff37c 2327 if (clearMode < 3) {
mkarlsso 2:298679fff37c 2328 for (int pNum = 1; pNum <= numPorts; pNum++) {
mkarlsso 2:298679fff37c 2329 //delete portVector[pNum]->triggerUpEventPtr;
mkarlsso 2:298679fff37c 2330 if (portVector[pNum]->triggerUpEventPtr != NULL) {
mkarlsso 2:298679fff37c 2331 portVector[pNum]->triggerUpEventPtr->release();
mkarlsso 2:298679fff37c 2332 }
mkarlsso 2:298679fff37c 2333 portVector[pNum]->triggerUpEventPtr = NULL;
mkarlsso 2:298679fff37c 2334
mkarlsso 2:298679fff37c 2335 //delete portVector[pNum]->triggerDownEventPtr;
mkarlsso 2:298679fff37c 2336 if (portVector[pNum]->triggerDownEventPtr != NULL) {
mkarlsso 2:298679fff37c 2337 portVector[pNum]->triggerDownEventPtr->release();
mkarlsso 2:298679fff37c 2338 }
mkarlsso 2:298679fff37c 2339 portVector[pNum]->triggerDownEventPtr = NULL;
mkarlsso 2:298679fff37c 2340 while (!functionArray.empty()) {
mkarlsso 2:298679fff37c 2341 delete functionArray.back();
mkarlsso 2:298679fff37c 2342 functionArray.pop_back();
mkarlsso 2:298679fff37c 2343 }
mkarlsso 2:298679fff37c 2344 }
mkarlsso 2:298679fff37c 2345
mkarlsso 2:298679fff37c 2346 queuePtr->eraseQueue();
mkarlsso 2:298679fff37c 2347 }
mkarlsso 2:298679fff37c 2348
mkarlsso 2:298679fff37c 2349 if (clearMode == 4) {
mkarlsso 2:298679fff37c 2350 if (blockDepth > 0) { //we are inside a block
mkarlsso 2:298679fff37c 2351 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2352 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2353 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2354 lineError = true;
mkarlsso 2:298679fff37c 2355 } else {
mkarlsso 2:298679fff37c 2356
mkarlsso 2:298679fff37c 2357 int8_t code = 0;
mkarlsso 2:298679fff37c 2358 tmpAction->set(code);
mkarlsso 2:298679fff37c 2359 //action* tmpAction = new action(code); //code 0 = clear queue
mkarlsso 2:298679fff37c 2360 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2361 }
mkarlsso 2:298679fff37c 2362 } else {
mkarlsso 2:298679fff37c 2363 //clear queue now
mkarlsso 2:298679fff37c 2364 queuePtr->eraseQueue();
mkarlsso 2:298679fff37c 2365 }
mkarlsso 2:298679fff37c 2366 }
mkarlsso 2:298679fff37c 2367
mkarlsso 2:298679fff37c 2368
mkarlsso 2:298679fff37c 2369 }
mkarlsso 2:298679fff37c 2370
mkarlsso 2:298679fff37c 2371 //do starts a block---------------------------------------------------------
mkarlsso 2:298679fff37c 2372 //example: do in 500
mkarlsso 2:298679fff37c 2373 // ...
mkarlsso 2:298679fff37c 2374 // end
mkarlsso 2:298679fff37c 2375
alustig3 5:e62cd80aa22f 2376 }else if(tokens[i].compare("kaboom") == 0){//MAX ANDY
alustig3 5:e62cd80aa22f 2377 mbed_reset();
alustig3 5:e62cd80aa22f 2378 }
alustig3 5:e62cd80aa22f 2379
alustig3 5:e62cd80aa22f 2380
alustig3 5:e62cd80aa22f 2381
alustig3 5:e62cd80aa22f 2382
alustig3 5:e62cd80aa22f 2383 else if (tokens[i].compare("do") == 0) { //the start of a block
mkarlsso 2:298679fff37c 2384
mkarlsso 2:298679fff37c 2385 if (!ifBlockInit && !whileBlockInit) {
mkarlsso 2:298679fff37c 2386
mkarlsso 2:298679fff37c 2387 if ((currentTriggerPort > 0) || (currentFunction > 0)) { //check to make sure we are inside a trigger block
mkarlsso 2:298679fff37c 2388 //pcPtr->printf("Start new block\r\n");
mkarlsso 2:298679fff37c 2389
mkarlsso 2:298679fff37c 2390 } else {
mkarlsso 2:298679fff37c 2391 pcPtr->printf("Error: a statement block must be placed inside a callback or function.\r\n");
mkarlsso 2:298679fff37c 2392 lineError = true;
mkarlsso 2:298679fff37c 2393 }
mkarlsso 2:298679fff37c 2394
mkarlsso 2:298679fff37c 2395 }
mkarlsso 2:298679fff37c 2396 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2397 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2398 bool eventReserved = false;
mkarlsso 2:298679fff37c 2399 if ((tmpEvent == NULL)||(tmpAction == NULL)) {
mkarlsso 2:298679fff37c 2400 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2401 lineError = true;
mkarlsso 2:298679fff37c 2402
mkarlsso 2:298679fff37c 2403 } else {
mkarlsso 2:298679fff37c 2404
mkarlsso 2:298679fff37c 2405
mkarlsso 2:298679fff37c 2406 }
mkarlsso 2:298679fff37c 2407
mkarlsso 2:298679fff37c 2408 if (i+2 < sz) { //a time delay in the block
mkarlsso 2:298679fff37c 2409
mkarlsso 2:298679fff37c 2410 if ((!lineError) && (tokens[i+1].compare("in") == 0) && (isNumber(tokens[i+2]))) {
mkarlsso 2:298679fff37c 2411
mkarlsso 2:298679fff37c 2412 currentDelay = atoi(tokens[i+2].data());
mkarlsso 2:298679fff37c 2413 if (currentDelay < 0) {
mkarlsso 2:298679fff37c 2414 pcPtr->printf("Error: block delay time must be a positive integer\r\n");
mkarlsso 2:298679fff37c 2415 lineError = true;
mkarlsso 2:298679fff37c 2416 } else if (!ifBlockInit) { //a standalone do block
mkarlsso 2:298679fff37c 2417 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2418 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2419 eventReserved = true;
mkarlsso 2:298679fff37c 2420 tmpEvent->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2421
mkarlsso 2:298679fff37c 2422 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 2:298679fff37c 2423 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2424 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2425 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2426 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2427 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 2:298679fff37c 2428 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2429 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2430 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2431 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2432 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 2:298679fff37c 2433 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2434
mkarlsso 2:298679fff37c 2435 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2436 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2437 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 2:298679fff37c 2438 }
mkarlsso 2:298679fff37c 2439 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2440 } else { //an if block
mkarlsso 2:298679fff37c 2441 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2442
mkarlsso 2:298679fff37c 2443 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2444 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 2:298679fff37c 2445 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2446 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 2:298679fff37c 2447 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 2:298679fff37c 2448 }
mkarlsso 2:298679fff37c 2449 } else if (elseFlag){
mkarlsso 2:298679fff37c 2450 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2451 } else if (thenFlag){
mkarlsso 2:298679fff37c 2452 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2453
mkarlsso 2:298679fff37c 2454 }
mkarlsso 2:298679fff37c 2455 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2456
mkarlsso 2:298679fff37c 2457 }
mkarlsso 2:298679fff37c 2458
mkarlsso 2:298679fff37c 2459 } else if ((!lineError) && (tokens[i+1].compare("in") == 0) && (findIntVariable(tokens[i+2])!=NULL)) {
mkarlsso 2:298679fff37c 2460
mkarlsso 2:298679fff37c 2461 int* delayVar = findIntVariable(tokens[i+2]);
mkarlsso 2:298679fff37c 2462 //currentDelay = atoi(tokens[i+2].data());
mkarlsso 2:298679fff37c 2463 if (!ifBlockInit) { //a standalone do block
mkarlsso 2:298679fff37c 2464 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2465 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2466 eventReserved = true;
mkarlsso 2:298679fff37c 2467 tmpEvent->setTimeLag(delayVar);
mkarlsso 2:298679fff37c 2468
mkarlsso 2:298679fff37c 2469 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 2:298679fff37c 2470 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2471 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2472 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2473 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2474 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 2:298679fff37c 2475 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2476 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2477 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2478 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2479 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 2:298679fff37c 2480 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2481
mkarlsso 2:298679fff37c 2482 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2483 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2484 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 2:298679fff37c 2485 }
mkarlsso 2:298679fff37c 2486 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2487 } else { //an if block
mkarlsso 2:298679fff37c 2488 tmpEventPtrArray.back()->setTimeLag(delayVar);
mkarlsso 2:298679fff37c 2489
mkarlsso 2:298679fff37c 2490 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2491 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 2:298679fff37c 2492 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2493 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 2:298679fff37c 2494 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 2:298679fff37c 2495 }
mkarlsso 2:298679fff37c 2496 } else if (elseFlag){
mkarlsso 2:298679fff37c 2497 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2498 } else if (thenFlag){
mkarlsso 2:298679fff37c 2499 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2500
mkarlsso 2:298679fff37c 2501 }
mkarlsso 2:298679fff37c 2502 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2503
mkarlsso 2:298679fff37c 2504 }
mkarlsso 2:298679fff37c 2505
mkarlsso 2:298679fff37c 2506 } else {
mkarlsso 2:298679fff37c 2507 pcPtr->printf("Error: block delay time must be a positive integer or a variable\r\n");
mkarlsso 2:298679fff37c 2508 lineError = true;
mkarlsso 2:298679fff37c 2509 }
mkarlsso 2:298679fff37c 2510 } else if (!lineError && !ifBlockInit) { //no time delay given, standalone do
mkarlsso 2:298679fff37c 2511 currentDelay = 0;
mkarlsso 2:298679fff37c 2512 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2513 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2514 eventReserved = true;
mkarlsso 2:298679fff37c 2515 tmpEvent->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2516 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2517 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2518 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2519 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2520 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2521 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2522 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2523 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2524 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2525 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 2:298679fff37c 2526 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2527 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2528 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2529 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 2:298679fff37c 2530 }
mkarlsso 2:298679fff37c 2531 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2532 } else if (!lineError) { //no time delay, if block
mkarlsso 2:298679fff37c 2533
mkarlsso 2:298679fff37c 2534 currentDelay = 0;
mkarlsso 2:298679fff37c 2535 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2536
mkarlsso 2:298679fff37c 2537
mkarlsso 2:298679fff37c 2538 if (!elseFlag && !thenFlag) {
mkarlsso 2:298679fff37c 2539 if (blockDepth > 1) {
mkarlsso 2:298679fff37c 2540 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2541 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 2:298679fff37c 2542 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 2:298679fff37c 2543 }
mkarlsso 2:298679fff37c 2544 } else {
mkarlsso 2:298679fff37c 2545 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2546 }
mkarlsso 2:298679fff37c 2547
mkarlsso 2:298679fff37c 2548
mkarlsso 2:298679fff37c 2549 //pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2550 }
mkarlsso 2:298679fff37c 2551 if (lineError && eventReserved) {
mkarlsso 2:298679fff37c 2552 tmpEvent->release();
mkarlsso 2:298679fff37c 2553 }
mkarlsso 2:298679fff37c 2554 //close block initiation
mkarlsso 2:298679fff37c 2555 ifBlockInit = false;
mkarlsso 2:298679fff37c 2556 whileBlockInit = false;
mkarlsso 2:298679fff37c 2557 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2558 elseFlag = false;
mkarlsso 2:298679fff37c 2559 thenFlag = false;
mkarlsso 2:298679fff37c 2560
mkarlsso 2:298679fff37c 2561 //callback starts a callback block------------------------------------------
mkarlsso 2:298679fff37c 2562 //exmaple: callback portin(1) down
mkarlsso 2:298679fff37c 2563 // ...
mkarlsso 2:298679fff37c 2564 // end
mkarlsso 2:298679fff37c 2565 } else if (tokens[i].compare("callback") == 0) { //a new callback block
mkarlsso 2:298679fff37c 2566 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2567 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2568 lineError = true;
mkarlsso 2:298679fff37c 2569 }
mkarlsso 2:298679fff37c 2570 if (blockDepth != 0) {
mkarlsso 2:298679fff37c 2571 pcPtr->printf("Error: Can't declare a callback block within another block\r\n");
mkarlsso 2:298679fff37c 2572 lineError = true;
mkarlsso 2:298679fff37c 2573 }
mkarlsso 2:298679fff37c 2574 if (!lineError) {
mkarlsso 2:298679fff37c 2575 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2576 if (i+2 < sz) {
mkarlsso 2:298679fff37c 2577 if ((tokens[i+1].find("portin[") != std::string::npos) && (tokens[i+1].size() > 8) ) { //callback for a digital port
mkarlsso 2:298679fff37c 2578 int pos1 = tokens[i+1].find("portin[")+7;
mkarlsso 2:298679fff37c 2579 int pos2 = tokens[i+1].find_first_of("]",pos1);
mkarlsso 2:298679fff37c 2580 currentTriggerPort = atoi(tokens[i+1].substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 2581
mkarlsso 2:298679fff37c 2582 if (currentTriggerPort <= 0) {
mkarlsso 2:298679fff37c 2583 currentTriggerPort = -1;
mkarlsso 2:298679fff37c 2584 pcPtr->printf("Error: Not a valid port number\r\n");
mkarlsso 2:298679fff37c 2585 lineError = true;
mkarlsso 2:298679fff37c 2586 }
mkarlsso 2:298679fff37c 2587 } else {
mkarlsso 2:298679fff37c 2588 pcPtr->printf("Error: Not a valid callback input\r\n");
mkarlsso 2:298679fff37c 2589 lineError = true;
mkarlsso 2:298679fff37c 2590 }
mkarlsso 2:298679fff37c 2591 if (tokens[i+2].compare("up") == 0) {
mkarlsso 2:298679fff37c 2592 currentTriggerDir = 1;
mkarlsso 2:298679fff37c 2593 } else if (tokens[i+2].compare("down") == 0) {
mkarlsso 2:298679fff37c 2594 currentTriggerDir = -1;
mkarlsso 2:298679fff37c 2595 } else {
mkarlsso 2:298679fff37c 2596 pcPtr->printf("Error: No trigger direction given\r\n");
mkarlsso 2:298679fff37c 2597 lineError = true;
mkarlsso 2:298679fff37c 2598 }
mkarlsso 2:298679fff37c 2599
mkarlsso 2:298679fff37c 2600 } else {
mkarlsso 2:298679fff37c 2601 if (!lineError) pcPtr->printf("Error: Not enough arguments for callback statement\r\n");
mkarlsso 2:298679fff37c 2602 lineError = true;
mkarlsso 2:298679fff37c 2603 }
mkarlsso 2:298679fff37c 2604 if (sz > 3) {
mkarlsso 2:298679fff37c 2605 if (!((sz == 4) && (tokens[i+3].compare("do") == 0))) {
mkarlsso 2:298679fff37c 2606 pcPtr->printf("Error: Too many arguments in callback statement\r\n");
mkarlsso 2:298679fff37c 2607 lineError = true;
mkarlsso 2:298679fff37c 2608 }
mkarlsso 2:298679fff37c 2609 }
mkarlsso 2:298679fff37c 2610
mkarlsso 2:298679fff37c 2611 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2612 if (tmpEvent != NULL) {
mkarlsso 2:298679fff37c 2613 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2614
mkarlsso 2:298679fff37c 2615 } else {
mkarlsso 2:298679fff37c 2616 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2617 lineError = true;
mkarlsso 2:298679fff37c 2618 }
mkarlsso 2:298679fff37c 2619 if (!lineError) {
mkarlsso 2:298679fff37c 2620 //pcPtr->printf("Current port: %d\r\n", currentTriggerPort);
mkarlsso 2:298679fff37c 2621 blockDepth = 1;
mkarlsso 2:298679fff37c 2622 i = i+2;
mkarlsso 2:298679fff37c 2623 //create new event and attach it to the port
mkarlsso 2:298679fff37c 2624 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 2:298679fff37c 2625 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2626 if (currentTriggerDir == 1) {
mkarlsso 2:298679fff37c 2627
mkarlsso 2:298679fff37c 2628 portVector[currentTriggerPort]->setTriggerUpEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2629 } else {
mkarlsso 2:298679fff37c 2630
mkarlsso 2:298679fff37c 2631 portVector[currentTriggerPort]->setTriggerDownEvent(tmpEventPtrArray.back());
mkarlsso 2:298679fff37c 2632 }
mkarlsso 2:298679fff37c 2633
mkarlsso 2:298679fff37c 2634 }
mkarlsso 2:298679fff37c 2635 }
mkarlsso 2:298679fff37c 2636
mkarlsso 2:298679fff37c 2637 //if starts an if block----------------------------------------------
mkarlsso 2:298679fff37c 2638 //examples: if x < 10 && y == 1 do; if a==1 do in 1000
mkarlsso 2:298679fff37c 2639 } else if (tokens[i].compare("if") == 0) { //a new if block
mkarlsso 2:298679fff37c 2640 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2641 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2642 lineError = true;
mkarlsso 2:298679fff37c 2643 }
mkarlsso 2:298679fff37c 2644
mkarlsso 2:298679fff37c 2645 ifBlockInit = true;
mkarlsso 2:298679fff37c 2646 currentDelay = 0;
mkarlsso 2:298679fff37c 2647 bool eventDefined = false;
mkarlsso 2:298679fff37c 2648 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2649 if (tmpEvent != NULL) {
mkarlsso 2:298679fff37c 2650 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2651 eventDefined = true;
mkarlsso 2:298679fff37c 2652 } else {
mkarlsso 2:298679fff37c 2653 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2654 lineError = true;
mkarlsso 2:298679fff37c 2655 }
mkarlsso 2:298679fff37c 2656 if (!lineError) {
mkarlsso 2:298679fff37c 2657 //this is a regular event
mkarlsso 2:298679fff37c 2658 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 2:298679fff37c 2659 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2660
mkarlsso 2:298679fff37c 2661 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 2:298679fff37c 2662 tmpEventPtrArray.back()->blockType = 1; //this is an if block
mkarlsso 2:298679fff37c 2663 blockDepth = blockDepth + 1;
mkarlsso 2:298679fff37c 2664 } else if (elseFlag) {
mkarlsso 2:298679fff37c 2665 tmpEventPtrArray.back()->blockType = 3; //this is an else if block
mkarlsso 2:298679fff37c 2666 } else if (thenFlag) {
mkarlsso 2:298679fff37c 2667 tmpEventPtrArray.back()->blockType = 7; //this is a then if block
mkarlsso 2:298679fff37c 2668 }
mkarlsso 2:298679fff37c 2669 }
mkarlsso 2:298679fff37c 2670
mkarlsso 2:298679fff37c 2671 if (!lineError) {
mkarlsso 2:298679fff37c 2672 //combine the condition tokens without whitespaces
mkarlsso 2:298679fff37c 2673 tmpString = "";
mkarlsso 2:298679fff37c 2674 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 2:298679fff37c 2675 if (tokens[j].compare("do") != 0) {
mkarlsso 2:298679fff37c 2676 i++;
mkarlsso 2:298679fff37c 2677 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2678 } else {
mkarlsso 2:298679fff37c 2679 break;
mkarlsso 2:298679fff37c 2680 }
mkarlsso 2:298679fff37c 2681 }
mkarlsso 2:298679fff37c 2682 //adds the conditions to the current event
mkarlsso 2:298679fff37c 2683
mkarlsso 2:298679fff37c 2684 if (!evaluateConditions(tmpString, tmpEventPtrArray.back())) lineError = true;
mkarlsso 2:298679fff37c 2685 }
mkarlsso 2:298679fff37c 2686
mkarlsso 2:298679fff37c 2687 if (lineError && eventDefined) {
mkarlsso 2:298679fff37c 2688 tmpEvent->release();
mkarlsso 2:298679fff37c 2689 }
mkarlsso 2:298679fff37c 2690
mkarlsso 2:298679fff37c 2691
mkarlsso 2:298679fff37c 2692 //else starts an else block-------------------------------------
mkarlsso 2:298679fff37c 2693 //examples: else do in 500; else if x==7 do
mkarlsso 2:298679fff37c 2694 } else if (tokens[i].compare("else") == 0) { //an else block
mkarlsso 2:298679fff37c 2695 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2696 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2697 lineError = true;
mkarlsso 2:298679fff37c 2698 }
mkarlsso 2:298679fff37c 2699
mkarlsso 2:298679fff37c 2700 //trigger blocks can't have else conditions
mkarlsso 2:298679fff37c 2701 if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso 2:298679fff37c 2702 pcPtr->printf("Error: else statement can not occur after a trigger block or outside a block\r\n");
mkarlsso 2:298679fff37c 2703 lineError = true;
mkarlsso 2:298679fff37c 2704 }
mkarlsso 2:298679fff37c 2705
mkarlsso 2:298679fff37c 2706 //check to make sure we are in an 'if' block
mkarlsso 2:298679fff37c 2707 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 1) && (tmpEventPtrArray.back()->blockType != 3)) { //not currently in an 'if' or 'else if' block
mkarlsso 2:298679fff37c 2708 pcPtr->printf("Error: else statement can only occur in an 'if' block\r\n");
mkarlsso 2:298679fff37c 2709 lineError = true;
mkarlsso 2:298679fff37c 2710 }
mkarlsso 2:298679fff37c 2711 if (!lineError) {
mkarlsso 2:298679fff37c 2712 elseFlag = true;
mkarlsso 2:298679fff37c 2713
mkarlsso 2:298679fff37c 2714 }
mkarlsso 2:298679fff37c 2715 } else if (tokens[i].compare("then") == 0) { //a then block
mkarlsso 2:298679fff37c 2716 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2717 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2718 lineError = true;
mkarlsso 2:298679fff37c 2719 }
mkarlsso 2:298679fff37c 2720
mkarlsso 2:298679fff37c 2721 //trigger blocks can't have else conditions
mkarlsso 2:298679fff37c 2722 if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso 2:298679fff37c 2723 pcPtr->printf("Error: 'then' statement can only occur after a 'while' block\r\n");
mkarlsso 2:298679fff37c 2724 lineError = true;
mkarlsso 2:298679fff37c 2725 }
mkarlsso 2:298679fff37c 2726
mkarlsso 2:298679fff37c 2727 //check to make sure we are in a 'while' block
mkarlsso 2:298679fff37c 2728 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 5)) { //not currently in a while block
mkarlsso 2:298679fff37c 2729 pcPtr->printf("Error: 'then' statement can only occur in a 'while' block\r\n");
mkarlsso 2:298679fff37c 2730 lineError = true;
mkarlsso 2:298679fff37c 2731 }
mkarlsso 2:298679fff37c 2732 if (!lineError) {
mkarlsso 2:298679fff37c 2733 thenFlag = true;
mkarlsso 2:298679fff37c 2734
mkarlsso 2:298679fff37c 2735 }
mkarlsso 2:298679fff37c 2736 //while starts a while block----------------------------------------
mkarlsso 2:298679fff37c 2737 //example: while x<10 do every 100
mkarlsso 2:298679fff37c 2738 // ...
mkarlsso 2:298679fff37c 2739 // end
mkarlsso 2:298679fff37c 2740 } else if (tokens[i].compare("while") == 0) { //a new while block
mkarlsso 2:298679fff37c 2741 if (ifBlockInit || whileBlockInit) {
mkarlsso 2:298679fff37c 2742 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2743 lineError = true;
mkarlsso 2:298679fff37c 2744 }
mkarlsso 2:298679fff37c 2745
mkarlsso 2:298679fff37c 2746 if ((currentTriggerPort > 0) || (currentFunction > 0)) { //check to make sure we are inside a trigger block
mkarlsso 2:298679fff37c 2747 //pcPtr->printf("Start new block\r\n");
mkarlsso 2:298679fff37c 2748
mkarlsso 2:298679fff37c 2749 } else {
mkarlsso 2:298679fff37c 2750 pcPtr->printf("Error: a statement block must be placed inside a callback or function.\r\n");
mkarlsso 2:298679fff37c 2751 lineError = true;
mkarlsso 2:298679fff37c 2752 }
mkarlsso 2:298679fff37c 2753 //whileBlockInit = true;
mkarlsso 2:298679fff37c 2754 currentDelay = 0;
mkarlsso 2:298679fff37c 2755
mkarlsso 2:298679fff37c 2756 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 2:298679fff37c 2757 if (tmpEvent != NULL) {
mkarlsso 2:298679fff37c 2758 tmpEvent->isUsed = true;
mkarlsso 2:298679fff37c 2759 tmpEvent->setTimeLag(currentDelay);
mkarlsso 2:298679fff37c 2760 } else {
mkarlsso 2:298679fff37c 2761 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2762 lineError = true;
mkarlsso 2:298679fff37c 2763 }
mkarlsso 2:298679fff37c 2764
mkarlsso 2:298679fff37c 2765 //tmpEvent = new event(queuePtr);
mkarlsso 2:298679fff37c 2766
mkarlsso 2:298679fff37c 2767
mkarlsso 2:298679fff37c 2768 if (!lineError) {
mkarlsso 2:298679fff37c 2769 //combine the condition tokens without whitespaces
mkarlsso 2:298679fff37c 2770 tmpString = "";
mkarlsso 2:298679fff37c 2771 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 2:298679fff37c 2772 if (tokens[j].compare("do") != 0) {
mkarlsso 2:298679fff37c 2773 i++;
mkarlsso 2:298679fff37c 2774 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2775 } else {
mkarlsso 2:298679fff37c 2776 break;
mkarlsso 2:298679fff37c 2777 }
mkarlsso 2:298679fff37c 2778 }
mkarlsso 2:298679fff37c 2779 //adds the conditions to the current event
mkarlsso 2:298679fff37c 2780 if (!evaluateConditions(tmpString, tmpEvent)) lineError = true;
mkarlsso 2:298679fff37c 2781 }
mkarlsso 2:298679fff37c 2782
mkarlsso 2:298679fff37c 2783 if (!lineError) {
mkarlsso 2:298679fff37c 2784 if ((i+3) < sz) {
mkarlsso 2:298679fff37c 2785 if ((tokens[i+1].compare("do") == 0) && (tokens[i+2].compare("every") == 0)) {
mkarlsso 2:298679fff37c 2786
mkarlsso 2:298679fff37c 2787 if (isNumber(tokens[i+3])) {
mkarlsso 2:298679fff37c 2788 uint32_t period = atoi(tokens[i+3].data());
mkarlsso 2:298679fff37c 2789 if (period > 0) {
mkarlsso 2:298679fff37c 2790 //pcPtr->printf("While block\r\n");
mkarlsso 2:298679fff37c 2791
mkarlsso 2:298679fff37c 2792 //tmpEvent->whileLoopPeriod = period;
mkarlsso 2:298679fff37c 2793 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 2:298679fff37c 2794 if (!elseFlag) {
mkarlsso 2:298679fff37c 2795 tmpEvent->blockType = 5; //this is a while block
mkarlsso 2:298679fff37c 2796
mkarlsso 2:298679fff37c 2797 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2798 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2799 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2800 lineError = true;
mkarlsso 2:298679fff37c 2801 } else {
mkarlsso 2:298679fff37c 2802 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2803 }
mkarlsso 2:298679fff37c 2804 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2805 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2806
mkarlsso 2:298679fff37c 2807 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2808 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2809 } else {
mkarlsso 2:298679fff37c 2810 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 2:298679fff37c 2811 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2812 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2813 }
mkarlsso 2:298679fff37c 2814 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2815 } else {
mkarlsso 2:298679fff37c 2816 pcPtr->printf("Error: loop period must be a positive integer.\r\n");
mkarlsso 2:298679fff37c 2817 lineError = true;
mkarlsso 2:298679fff37c 2818 }
mkarlsso 2:298679fff37c 2819 } else if (findIntVariable(tokens[i+3])!=NULL) {
mkarlsso 2:298679fff37c 2820
mkarlsso 2:298679fff37c 2821 int* period = findIntVariable(tokens[i+3]);
mkarlsso 2:298679fff37c 2822 //tmpEvent->whileLoopPeriodVar = period;
mkarlsso 2:298679fff37c 2823 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 2:298679fff37c 2824 if (!elseFlag) {
mkarlsso 2:298679fff37c 2825 tmpEvent->blockType = 5; //this is a while block
mkarlsso 2:298679fff37c 2826
mkarlsso 2:298679fff37c 2827 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 2828 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 2829 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 2830 lineError = true;
mkarlsso 2:298679fff37c 2831 } else {
mkarlsso 2:298679fff37c 2832 tmpAction->set(tmpEvent);
mkarlsso 2:298679fff37c 2833 }
mkarlsso 2:298679fff37c 2834 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 2:298679fff37c 2835 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2836
mkarlsso 2:298679fff37c 2837 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2838 blockDepth = blockDepth+1;
mkarlsso 2:298679fff37c 2839 } else {
mkarlsso 2:298679fff37c 2840 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 2:298679fff37c 2841 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 2:298679fff37c 2842 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 2:298679fff37c 2843 }
mkarlsso 2:298679fff37c 2844 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2845 }
mkarlsso 2:298679fff37c 2846 } else {
mkarlsso 2:298679fff37c 2847 pcPtr->printf("Error: expected a 'do every' statement\r\n");
mkarlsso 2:298679fff37c 2848 lineError = true;
mkarlsso 2:298679fff37c 2849 }
mkarlsso 2:298679fff37c 2850 } else {
mkarlsso 2:298679fff37c 2851 pcPtr->printf("Error: expected a 'do every' statement\r\n");
mkarlsso 2:298679fff37c 2852 lineError = true;
mkarlsso 2:298679fff37c 2853 }
mkarlsso 2:298679fff37c 2854 }
mkarlsso 2:298679fff37c 2855
mkarlsso 2:298679fff37c 2856 //if the line contains an '=' sign,the equality is evaulated-------------------------
mkarlsso 2:298679fff37c 2857 //examples: a = 1; a = b + 5; a = random(100); portout[2] = 1; portout[2] = flip
mkarlsso 2:298679fff37c 2858 } else if ((tmpLine.find_first_of("=") != std::string::npos) ) { //an expression
mkarlsso 2:298679fff37c 2859 if (ifBlockInit || whileBlockInit || elseFlag) {
mkarlsso 2:298679fff37c 2860 pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso 2:298679fff37c 2861 lineError = true;
mkarlsso 2:298679fff37c 2862 }
mkarlsso 2:298679fff37c 2863
mkarlsso 2:298679fff37c 2864 wholeLineEvaluated = true;
mkarlsso 2:298679fff37c 2865 tmpString = "";
mkarlsso 2:298679fff37c 2866 int spacesBeforeEqualSign = 0;
mkarlsso 2:298679fff37c 2867 bool countSpaces = true;
mkarlsso 2:298679fff37c 2868 //combine the tokens without whitespaces
mkarlsso 2:298679fff37c 2869 for (unsigned j = i; j < sz; j++) {
mkarlsso 2:298679fff37c 2870 tmpString.append(tokens[j]);
mkarlsso 2:298679fff37c 2871 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 2:298679fff37c 2872 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2873 countSpaces = false;
mkarlsso 2:298679fff37c 2874 } else if (countSpaces) {
mkarlsso 2:298679fff37c 2875 spacesBeforeEqualSign++;
mkarlsso 2:298679fff37c 2876 }
mkarlsso 2:298679fff37c 2877 }
mkarlsso 2:298679fff37c 2878 if (!lineError && spacesBeforeEqualSign > 1) {
mkarlsso 2:298679fff37c 2879 pcPtr->printf("Error: Variable can't have a space in it.\r\n");
mkarlsso 2:298679fff37c 2880 lineError = true;
mkarlsso 2:298679fff37c 2881 }
mkarlsso 2:298679fff37c 2882
mkarlsso 2:298679fff37c 2883 if (!lineError) {
mkarlsso 2:298679fff37c 2884 if (blockDepth > 0) {
mkarlsso 2:298679fff37c 2885 action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 2:298679fff37c 2886 if (tmpAction != NULL) {
mkarlsso 2:298679fff37c 2887 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 2:298679fff37c 2888 //pcPtr->printf("Added action with delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso 2:298679fff37c 2889
mkarlsso 2:298679fff37c 2890 } else {
mkarlsso 2:298679fff37c 2891 lineError = true;
mkarlsso 2:298679fff37c 2892 }
mkarlsso 2:298679fff37c 2893
mkarlsso 2:298679fff37c 2894 } else { //assignment was written outside of any block structure, so execute now
mkarlsso 2:298679fff37c 2895
mkarlsso 2:298679fff37c 2896
mkarlsso 2:298679fff37c 2897 action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 2:298679fff37c 2898
mkarlsso 3:ae33b7f5a7c1 2899 if (tmpAction != NULL) {
mkarlsso 2:298679fff37c 2900 tmpAction->execute();
mkarlsso 3:ae33b7f5a7c1 2901
mkarlsso 2:298679fff37c 2902 //delete tmpAction;
mkarlsso 2:298679fff37c 2903 tmpAction->release();
mkarlsso 2:298679fff37c 2904 } else {
mkarlsso 2:298679fff37c 2905 lineError = true;
mkarlsso 2:298679fff37c 2906 }
mkarlsso 2:298679fff37c 2907 }
mkarlsso 2:298679fff37c 2908 }
alustig3 5:e62cd80aa22f 2909 }
alustig3 5:e62cd80aa22f 2910 //ANDY
alustig3 5:e62cd80aa22f 2911 // else if (tokens[i].find("opto(") != std::string::npos) {
alustig3 5:e62cd80aa22f 2912 // wholeLineEvaluated = true;
alustig3 5:e62cd80aa22f 2913 // int pos1 = tmpLine.find("opto(")+5;
alustig3 5:e62cd80aa22f 2914 // int pos2 = tmpLine.find_first_of(")",pos1);
alustig3 5:e62cd80aa22f 2915 // string dispVar = tmpLine.substr(pos1,pos2-pos1);
alustig3 5:e62cd80aa22f 2916 // device.printf(dispVar.c_str());
alustig3 5:e62cd80aa22f 2917 // }
alustig3 5:e62cd80aa22f 2918
alustig3 5:e62cd80aa22f 2919 else {
mkarlsso 2:298679fff37c 2920 //if there was no match to any of the above, an error is given
mkarlsso 2:298679fff37c 2921 pcPtr->printf("Error: statement not understood.\r\n");
mkarlsso 2:298679fff37c 2922 lineError = true;
mkarlsso 2:298679fff37c 2923 }
mkarlsso 2:298679fff37c 2924
mkarlsso 2:298679fff37c 2925 if (lineError) break; //stop parsing the rest of the line if an error was detected
mkarlsso 2:298679fff37c 2926
mkarlsso 2:298679fff37c 2927 if (wholeLineEvaluated) { //some of the tokens forces the whole line to be avaluated at once
mkarlsso 2:298679fff37c 2928 i = sz; //skip ahead to end of the line
mkarlsso 2:298679fff37c 2929 }
mkarlsso 2:298679fff37c 2930
mkarlsso 2:298679fff37c 2931 }
mkarlsso 2:298679fff37c 2932
mkarlsso 2:298679fff37c 2933 //if there was an error, we quit compiling the code
mkarlsso 2:298679fff37c 2934 if (lineError) {
mkarlsso 2:298679fff37c 2935 pcPtr->printf("Line text: ");
mkarlsso 2:298679fff37c 2936 while (!tokens.empty()) {
mkarlsso 2:298679fff37c 2937 pcPtr->printf("%s ",tokens.front().data());
mkarlsso 2:298679fff37c 2938 tokens.erase(tokens.begin());
mkarlsso 2:298679fff37c 2939 }
mkarlsso 2:298679fff37c 2940 pcPtr->printf("\r\n");
mkarlsso 2:298679fff37c 2941 while (!currentBlock.empty()) {
mkarlsso 2:298679fff37c 2942 currentBlock.pop_back();
mkarlsso 2:298679fff37c 2943 }
mkarlsso 2:298679fff37c 2944 delete tmpEvent;
mkarlsso 2:298679fff37c 2945 } else {
mkarlsso 2:298679fff37c 2946
mkarlsso 2:298679fff37c 2947 while (!tokens.empty()) {
mkarlsso 2:298679fff37c 2948 tokens.pop_back();
mkarlsso 2:298679fff37c 2949 }
alustig3 5:e62cd80aa22f 2950 currentBlock.pop_back();
mkarlsso 2:298679fff37c 2951 }
mkarlsso 2:298679fff37c 2952
mkarlsso 2:298679fff37c 2953 }
mkarlsso 2:298679fff37c 2954
mkarlsso 2:298679fff37c 2955 //make sure that all blocks have a matching end statement
mkarlsso 2:298679fff37c 2956 if ((!lineError)&&(blockDepth > 0)) {
mkarlsso 2:298679fff37c 2957 pcPtr->printf("Error: Missing 1 or more end statements\r\n");
mkarlsso 2:298679fff37c 2958 lineError = true;
alustig3 5:e62cd80aa22f 2959 }
alustig3 5:e62cd80aa22f 2960 //pcPtr->printf("~~~\r\n"); //signals that the code was compiled
alustig3 5:e62cd80aa22f 2961 textDisplay.send("~~~\r\n");
mkarlsso 2:298679fff37c 2962 //displayMemoryLeft();
mkarlsso 2:298679fff37c 2963 //DisplayRAMBanks();
mkarlsso 2:298679fff37c 2964
mkarlsso 2:298679fff37c 2965 }
mkarlsso 2:298679fff37c 2966
mkarlsso 2:298679fff37c 2967
mkarlsso 2:298679fff37c 2968 //used to return a pointer to a variable, if it exists
mkarlsso 2:298679fff37c 2969 int* scriptStream::findIntVariable(string nameInput) {
mkarlsso 2:298679fff37c 2970
mkarlsso 2:298679fff37c 2971 int* outPtr = NULL;
mkarlsso 2:298679fff37c 2972 bool foundIt = false;
mkarlsso 2:298679fff37c 2973
mkarlsso 2:298679fff37c 2974 if (nameInput.find("portout") != std::string::npos) {
mkarlsso 2:298679fff37c 2975 int pos1 = nameInput.find("portout[")+8;
mkarlsso 2:298679fff37c 2976 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 2:298679fff37c 2977 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 2978 int portVal = 0;
mkarlsso 2:298679fff37c 2979 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 2:298679fff37c 2980 outPtr = &portVector[portnum]->outState;
mkarlsso 2:298679fff37c 2981 foundIt = true;
mkarlsso 2:298679fff37c 2982 }
mkarlsso 2:298679fff37c 2983 } else if (nameInput.find("portin") != std::string::npos) {
mkarlsso 2:298679fff37c 2984 int pos1 = nameInput.find("portin[")+7;
mkarlsso 2:298679fff37c 2985 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 2:298679fff37c 2986 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 2987 int portVal = 0;
mkarlsso 2:298679fff37c 2988 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 2:298679fff37c 2989 outPtr = &portVector[portnum]->inState;
mkarlsso 2:298679fff37c 2990 foundIt = true;
mkarlsso 2:298679fff37c 2991 }
mkarlsso 2:298679fff37c 2992 }
mkarlsso 2:298679fff37c 2993
mkarlsso 2:298679fff37c 2994 if (!foundIt) {
mkarlsso 2:298679fff37c 2995 std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso 2:298679fff37c 2996 for (unsigned i = 0; i < sz; i++) {
mkarlsso 2:298679fff37c 2997 if (nameInput.compare(globalVariables[i]->tag) == 0) {
mkarlsso 2:298679fff37c 2998 outPtr = &globalVariables[i]->value;
mkarlsso 2:298679fff37c 2999 break;
mkarlsso 2:298679fff37c 3000 }
mkarlsso 2:298679fff37c 3001 }
mkarlsso 2:298679fff37c 3002 }
mkarlsso 2:298679fff37c 3003
mkarlsso 2:298679fff37c 3004 return outPtr;
mkarlsso 2:298679fff37c 3005 }
mkarlsso 2:298679fff37c 3006
mkarlsso 2:298679fff37c 3007 bool scriptStream::createIntVariable(string nameInput) {
mkarlsso 2:298679fff37c 3008 if (findIntVariable(nameInput) == NULL) {
mkarlsso 2:298679fff37c 3009 globalVariables.push_back(new intVariable(nameInput, 0));
mkarlsso 2:298679fff37c 3010 return true;
mkarlsso 2:298679fff37c 3011 } else {
mkarlsso 2:298679fff37c 3012 return false;
mkarlsso 2:298679fff37c 3013 }
mkarlsso 2:298679fff37c 3014 }
mkarlsso 2:298679fff37c 3015
mkarlsso 2:298679fff37c 3016
mkarlsso 2:298679fff37c 3017 action* scriptStream::evaluateAssignmentForAction(string expression) {
mkarlsso 2:298679fff37c 3018
mkarlsso 2:298679fff37c 3019 //action* tmpAction = new action(); //create a new action
mkarlsso 2:298679fff37c 3020 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 2:298679fff37c 3021 if (tmpAction == NULL) {
mkarlsso 2:298679fff37c 3022 pcPtr->printf("Error: no action memory slots available.\r\n");
mkarlsso 2:298679fff37c 3023 return NULL;
mkarlsso 2:298679fff37c 3024 }
mkarlsso 2:298679fff37c 3025 std::size_t stringInd;
mkarlsso 2:298679fff37c 3026 std::size_t stringInd2;
mkarlsso 2:298679fff37c 3027 string afterEqual;
mkarlsso 2:298679fff37c 3028 string beforeEqual;
mkarlsso 2:298679fff37c 3029 //The expression might have up to three variables
mkarlsso 2:298679fff37c 3030 int* tmpVar;
mkarlsso 2:298679fff37c 3031 int* tmpVar2;
mkarlsso 2:298679fff37c 3032 int* tmpVar3;
mkarlsso 2:298679fff37c 3033 stringInd = expression.find_first_of("="); //location of = sign, if it exists
mkarlsso 2:298679fff37c 3034 beforeEqual = expression.substr(0,stringInd); // the string after the = sign
mkarlsso 2:298679fff37c 3035 afterEqual = expression.substr(stringInd+1,std::string::npos); // the string after the = sign
mkarlsso 2:298679fff37c 3036 stringInd2 = afterEqual.find_first_of("+-"); //location of +/- sign (only one allowed)
mkarlsso 2:298679fff37c 3037 tmpVar = findIntVariable(expression.substr(0,stringInd)); //returns pointer to the variable
mkarlsso 2:298679fff37c 3038
mkarlsso 2:298679fff37c 3039 if (beforeEqual.find("portout[") != std::string::npos) { //set the output of a digital port
mkarlsso 2:298679fff37c 3040 int pos1 = beforeEqual.find("portout[")+8;
mkarlsso 2:298679fff37c 3041 int pos2 = beforeEqual.find_first_of("]",pos1);
mkarlsso 2:298679fff37c 3042 int portnum = atoi(beforeEqual.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 3043 int* tmpVar = findIntVariable(beforeEqual.substr(pos1,pos2-pos1)); //returns pointer to the variable, if given
mkarlsso 2:298679fff37c 3044 int portVal = 0;
mkarlsso 2:298679fff37c 3045 if ((tmpVar != NULL)||((portnum > 0) && (portnum <= numPorts))) {
mkarlsso 2:298679fff37c 3046 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 2:298679fff37c 3047 portVal = atoi(afterEqual.data());
mkarlsso 2:298679fff37c 3048 if ((portVal == 0) || (portVal == 1)) {
mkarlsso 2:298679fff37c 3049 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso 2:298679fff37c 3050 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 2:298679fff37c 3051 if (tmpMessage == NULL) {
mkarlsso 2:298679fff37c 3052 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3053 tmpAction->release();
mkarlsso 2:298679fff37c 3054 return NULL;
mkarlsso 2:298679fff37c 3055 } else {
mkarlsso 2:298679fff37c 3056 //tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso 2:298679fff37c 3057 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 2:298679fff37c 3058 tmpMessage->setMessage(NULL,portnum,portVal);
mkarlsso 2:298679fff37c 3059 } else {
mkarlsso 2:298679fff37c 3060 tmpMessage->setMessage(tmpVar,0,portVal);
mkarlsso 2:298679fff37c 3061 }
mkarlsso 2:298679fff37c 3062 }
mkarlsso 2:298679fff37c 3063
mkarlsso 2:298679fff37c 3064
mkarlsso 2:298679fff37c 3065 tmpAction->set(tmpMessage);
mkarlsso 2:298679fff37c 3066 //pcPtr->printf("Action: digital port %d set to %d\r\n",portnum,portVal);
mkarlsso 2:298679fff37c 3067 } else {
mkarlsso 2:298679fff37c 3068 pcPtr->printf("Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n");
mkarlsso 2:298679fff37c 3069 //delete tmpAction;
mkarlsso 2:298679fff37c 3070 tmpAction->release();
mkarlsso 2:298679fff37c 3071 return NULL;
mkarlsso 2:298679fff37c 3072 }
mkarlsso 2:298679fff37c 3073 } else if (afterEqual.compare("flip") == 0) {
mkarlsso 2:298679fff37c 3074 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso 2:298679fff37c 3075 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 2:298679fff37c 3076 if (tmpMessage == NULL) {
mkarlsso 2:298679fff37c 3077 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3078 tmpAction->release();
mkarlsso 2:298679fff37c 3079 return NULL;
mkarlsso 2:298679fff37c 3080 } else {
mkarlsso 2:298679fff37c 3081 //tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso 2:298679fff37c 3082 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 3:ae33b7f5a7c1 3083 tmpMessage->setMessage(NULL,portnum,-1);
mkarlsso 2:298679fff37c 3084 } else {
mkarlsso 3:ae33b7f5a7c1 3085 tmpMessage->setMessage(tmpVar,0,-1);
mkarlsso 2:298679fff37c 3086 }
mkarlsso 2:298679fff37c 3087 }
mkarlsso 2:298679fff37c 3088 tmpAction->set(tmpMessage);
mkarlsso 2:298679fff37c 3089 } else {
mkarlsso 2:298679fff37c 3090 pcPtr->printf("Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n");
mkarlsso 2:298679fff37c 3091 //delete tmpAction;
mkarlsso 2:298679fff37c 3092 tmpAction->release();
mkarlsso 2:298679fff37c 3093 return NULL;
mkarlsso 2:298679fff37c 3094 }
mkarlsso 2:298679fff37c 3095 } else {
mkarlsso 2:298679fff37c 3096 pcPtr->printf("Port number not found (must be between 1 and %d, or an existing variable)\r\n", numPorts);
mkarlsso 2:298679fff37c 3097 //delete tmpAction;
mkarlsso 2:298679fff37c 3098 tmpAction->release();
mkarlsso 2:298679fff37c 3099 return NULL;
mkarlsso 2:298679fff37c 3100 }
mkarlsso 2:298679fff37c 3101 } else if (beforeEqual.find("portin") != std::string::npos) {
mkarlsso 2:298679fff37c 3102 pcPtr->printf("Error: portins can not be set\r\n");
mkarlsso 2:298679fff37c 3103 //delete tmpAction;
mkarlsso 2:298679fff37c 3104 tmpAction->release();
mkarlsso 2:298679fff37c 3105 return NULL;
mkarlsso 2:298679fff37c 3106 } else if (tmpVar != NULL) {
mkarlsso 2:298679fff37c 3107 intOperation* tmpOp;
mkarlsso 2:298679fff37c 3108 intOperation* tmpOp2;
mkarlsso 2:298679fff37c 3109 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 2:298679fff37c 3110 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 2:298679fff37c 3111 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3112 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3113 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3114 tmpAction->release();
mkarlsso 2:298679fff37c 3115 return NULL;
mkarlsso 2:298679fff37c 3116 } else {
mkarlsso 2:298679fff37c 3117 tmpOp->set(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 2:298679fff37c 3118 }
mkarlsso 2:298679fff37c 3119 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3120 //pcPtr->printf("Action: set variable to constant numeric value\r\n");
mkarlsso 2:298679fff37c 3121 } else if ((stringInd2 == std::string::npos)&&(afterEqual.find("random") != std::string::npos)) {
mkarlsso 2:298679fff37c 3122
mkarlsso 2:298679fff37c 3123 int highVal = getRandomParam(afterEqual);
mkarlsso 2:298679fff37c 3124
mkarlsso 2:298679fff37c 3125 if (highVal > 0) {
mkarlsso 2:298679fff37c 3126 //tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 2:298679fff37c 3127 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3128 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3129 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3130 tmpAction->release();
mkarlsso 2:298679fff37c 3131 return NULL;
mkarlsso 2:298679fff37c 3132 } else {
mkarlsso 2:298679fff37c 3133 tmpOp->set(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 2:298679fff37c 3134 }
mkarlsso 2:298679fff37c 3135 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3136 //pcPtr->printf("Action: set variable to random value up to %d\r\n", highVal);
mkarlsso 2:298679fff37c 3137 } else {
mkarlsso 2:298679fff37c 3138 //delete tmpAction;
mkarlsso 2:298679fff37c 3139 tmpAction->release();
mkarlsso 2:298679fff37c 3140 return NULL;
mkarlsso 2:298679fff37c 3141 }
mkarlsso 2:298679fff37c 3142
mkarlsso 2:298679fff37c 3143 } else if (stringInd2 != std::string::npos) { //a +/- operation is there
mkarlsso 2:298679fff37c 3144 string multiplier("+");
mkarlsso 2:298679fff37c 3145 int multiplierInt = 1;
mkarlsso 2:298679fff37c 3146 if (afterEqual[stringInd2] == '-') {
mkarlsso 2:298679fff37c 3147 multiplier = "-";
mkarlsso 2:298679fff37c 3148 multiplierInt = -1;
mkarlsso 2:298679fff37c 3149 }
mkarlsso 2:298679fff37c 3150 tmpVar2 = findIntVariable(afterEqual.substr(0,stringInd2)); //before the +/- sign
mkarlsso 2:298679fff37c 3151 tmpVar3 = findIntVariable(afterEqual.substr(stringInd2+1,std::string::npos)); //after the +/- sign
mkarlsso 2:298679fff37c 3152
mkarlsso 2:298679fff37c 3153 if ((tmpVar2 != NULL) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //variable +/- number
mkarlsso 2:298679fff37c 3154 if (tmpVar2 == tmpVar) {
mkarlsso 2:298679fff37c 3155 multiplier.append("="); //final sign is += or -=
mkarlsso 2:298679fff37c 3156 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 2:298679fff37c 3157 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3158 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3159 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3160 tmpAction->release();
mkarlsso 2:298679fff37c 3161 return NULL;
mkarlsso 2:298679fff37c 3162 } else {
mkarlsso 2:298679fff37c 3163 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 2:298679fff37c 3164 }
mkarlsso 2:298679fff37c 3165 tmpAction->set(tmpOp);
alustig3 5:e62cd80aa22f 3166 pcPtr->printf("Action: change variable by constant amount\r\n");
mkarlsso 2:298679fff37c 3167 } else {
mkarlsso 3:ae33b7f5a7c1 3168
mkarlsso 2:298679fff37c 3169 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3170 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3171 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3172 tmpAction->release();
mkarlsso 2:298679fff37c 3173 return NULL;
mkarlsso 2:298679fff37c 3174 } else {
mkarlsso 3:ae33b7f5a7c1 3175
mkarlsso 2:298679fff37c 3176 tmpOp2->set(tmpVar2,multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 3:ae33b7f5a7c1 3177 //tmpOp->set(tmpVar, tmpOp2);
mkarlsso 3:ae33b7f5a7c1 3178 }
mkarlsso 3:ae33b7f5a7c1 3179
mkarlsso 3:ae33b7f5a7c1 3180 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3181 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3182 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3183 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3184 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3185 return NULL;
mkarlsso 3:ae33b7f5a7c1 3186 } else {
mkarlsso 2:298679fff37c 3187 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 3:ae33b7f5a7c1 3188 }
mkarlsso 3:ae33b7f5a7c1 3189
mkarlsso 2:298679fff37c 3190 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3191 //pcPtr->printf("Action: variable equals expression\r\n");
mkarlsso 2:298679fff37c 3192 }
mkarlsso 2:298679fff37c 3193
mkarlsso 2:298679fff37c 3194 } else if ((tmpVar3 != NULL) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- variable
mkarlsso 2:298679fff37c 3195 if (tmpVar3 == tmpVar) {
mkarlsso 3:ae33b7f5a7c1 3196 multiplier.append("="); //makes "+=" or "-="
mkarlsso 2:298679fff37c 3197 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 2:298679fff37c 3198 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3199 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3200 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3201 tmpAction->release();
mkarlsso 2:298679fff37c 3202 return NULL;
mkarlsso 2:298679fff37c 3203 } else {
mkarlsso 2:298679fff37c 3204 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 2:298679fff37c 3205 }
mkarlsso 2:298679fff37c 3206 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3207 //pcPtr->printf("Action: change variable by constant amount\r\n");
mkarlsso 2:298679fff37c 3208 } else {
mkarlsso 3:ae33b7f5a7c1 3209
mkarlsso 2:298679fff37c 3210 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3211 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3212 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3213 tmpAction->release();
mkarlsso 2:298679fff37c 3214 return NULL;
mkarlsso 2:298679fff37c 3215 } else {
mkarlsso 3:ae33b7f5a7c1 3216 tmpOp2->set(tmpVar3, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso 3:ae33b7f5a7c1 3217 }
mkarlsso 3:ae33b7f5a7c1 3218 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3219
mkarlsso 3:ae33b7f5a7c1 3220 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3221 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3222 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3223 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3224 return NULL;
mkarlsso 3:ae33b7f5a7c1 3225 } else {
mkarlsso 2:298679fff37c 3226 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3227 }
mkarlsso 2:298679fff37c 3228 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3229 //pcPtr->printf("Action: variable equals expression\r\n");
mkarlsso 2:298679fff37c 3230 }
mkarlsso 2:298679fff37c 3231
mkarlsso 2:298679fff37c 3232 } else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso 3:ae33b7f5a7c1 3233
mkarlsso 2:298679fff37c 3234 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3235 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3236 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3237 tmpAction->release();
mkarlsso 2:298679fff37c 3238 return NULL;
mkarlsso 2:298679fff37c 3239 } else {
mkarlsso 3:ae33b7f5a7c1 3240 tmpOp2->set(tmpVar2, multiplier.data(), tmpVar3);
mkarlsso 3:ae33b7f5a7c1 3241 }
mkarlsso 3:ae33b7f5a7c1 3242 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3243
mkarlsso 3:ae33b7f5a7c1 3244 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3245 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3246 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3247 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3248 return NULL;
mkarlsso 3:ae33b7f5a7c1 3249 } else {
mkarlsso 3:ae33b7f5a7c1 3250
mkarlsso 2:298679fff37c 3251 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3252 }
mkarlsso 2:298679fff37c 3253 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3254 //pcPtr->printf("Action: set variable to operation involving two variables\r\n");
mkarlsso 2:298679fff37c 3255 //tmpVar->value = tmpVar2->value + (multiplier * tmpVar3->value);
mkarlsso 2:298679fff37c 3256 } else if ( isNumber(afterEqual.substr(stringInd2+1,std::string::npos)) && isNumber(afterEqual.substr(0,stringInd2)) ) { //number +/- number
mkarlsso 2:298679fff37c 3257 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso 2:298679fff37c 3258 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3259 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3260 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3261 tmpAction->release();
mkarlsso 2:298679fff37c 3262 return NULL;
mkarlsso 2:298679fff37c 3263 } else {
mkarlsso 2:298679fff37c 3264 tmpOp->set(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso 2:298679fff37c 3265 }
mkarlsso 2:298679fff37c 3266 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3267 //pcPtr->printf("Action: set variable to constant numeric value\r\n");
mkarlsso 2:298679fff37c 3268
mkarlsso 2:298679fff37c 3269 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //random +/- number
mkarlsso 2:298679fff37c 3270 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 2:298679fff37c 3271
mkarlsso 2:298679fff37c 3272 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3273
mkarlsso 3:ae33b7f5a7c1 3274
mkarlsso 2:298679fff37c 3275 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3276 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3277 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3278 tmpAction->release();
mkarlsso 2:298679fff37c 3279 return NULL;
mkarlsso 2:298679fff37c 3280 } else {
mkarlsso 3:ae33b7f5a7c1 3281 tmpOp2->set(highVal, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 3:ae33b7f5a7c1 3282 }
mkarlsso 3:ae33b7f5a7c1 3283 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3284
mkarlsso 3:ae33b7f5a7c1 3285 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3286 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3287 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3288 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3289 return NULL;
mkarlsso 3:ae33b7f5a7c1 3290 } else {
mkarlsso 2:298679fff37c 3291 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3292 }
mkarlsso 2:298679fff37c 3293 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3294 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3295 } else {
mkarlsso 2:298679fff37c 3296 //delete tmpAction;
mkarlsso 2:298679fff37c 3297 tmpAction->release();
mkarlsso 2:298679fff37c 3298 return NULL;
mkarlsso 2:298679fff37c 3299 }
mkarlsso 2:298679fff37c 3300 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso 2:298679fff37c 3301 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 2:298679fff37c 3302
mkarlsso 2:298679fff37c 3303 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3304
mkarlsso 3:ae33b7f5a7c1 3305
mkarlsso 2:298679fff37c 3306 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3307 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3308 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3309 tmpAction->release();
mkarlsso 2:298679fff37c 3310 return NULL;
mkarlsso 2:298679fff37c 3311 } else {
mkarlsso 3:ae33b7f5a7c1 3312 tmpOp2->set(highVal, multiplier.data(), tmpVar3);
mkarlsso 3:ae33b7f5a7c1 3313 }
mkarlsso 3:ae33b7f5a7c1 3314 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3315 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3316 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3317 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3318 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3319 return NULL;
mkarlsso 3:ae33b7f5a7c1 3320 } else {
mkarlsso 2:298679fff37c 3321 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3322 }
mkarlsso 2:298679fff37c 3323 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3324 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3325 } else {
mkarlsso 2:298679fff37c 3326 //delete tmpAction;
mkarlsso 2:298679fff37c 3327 tmpAction->release();
mkarlsso 2:298679fff37c 3328 return NULL;
mkarlsso 2:298679fff37c 3329 }
mkarlsso 2:298679fff37c 3330
mkarlsso 2:298679fff37c 3331
mkarlsso 2:298679fff37c 3332 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //random +/- number
mkarlsso 2:298679fff37c 3333 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 2:298679fff37c 3334
mkarlsso 2:298679fff37c 3335 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3336
mkarlsso 3:ae33b7f5a7c1 3337
mkarlsso 2:298679fff37c 3338 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3339 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3340 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3341 tmpAction->release();
mkarlsso 2:298679fff37c 3342 return NULL;
mkarlsso 2:298679fff37c 3343 } else {
mkarlsso 3:ae33b7f5a7c1 3344 tmpOp2->set(highVal, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso 3:ae33b7f5a7c1 3345 }
mkarlsso 3:ae33b7f5a7c1 3346 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3347 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3348 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3349 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3350 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3351 return NULL;
mkarlsso 3:ae33b7f5a7c1 3352 } else {
mkarlsso 2:298679fff37c 3353 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3354 }
mkarlsso 2:298679fff37c 3355 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3356 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3357 } else {
mkarlsso 2:298679fff37c 3358 //delete tmpAction;
mkarlsso 2:298679fff37c 3359 tmpAction->release();
mkarlsso 2:298679fff37c 3360 return NULL;
mkarlsso 2:298679fff37c 3361 }
mkarlsso 2:298679fff37c 3362 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && (tmpVar2 != NULL)) { //random +/- number
mkarlsso 2:298679fff37c 3363 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 2:298679fff37c 3364
mkarlsso 2:298679fff37c 3365 if (highVal > 0) {
mkarlsso 3:ae33b7f5a7c1 3366
mkarlsso 3:ae33b7f5a7c1 3367
mkarlsso 2:298679fff37c 3368 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3369 if (tmpOp2 == NULL) {
mkarlsso 2:298679fff37c 3370 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3371 tmpAction->release();
mkarlsso 2:298679fff37c 3372 return NULL;
mkarlsso 2:298679fff37c 3373 } else {
mkarlsso 3:ae33b7f5a7c1 3374 tmpOp2->set(highVal, multiplier.data(), tmpVar2);
mkarlsso 3:ae33b7f5a7c1 3375 }
mkarlsso 3:ae33b7f5a7c1 3376 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 3:ae33b7f5a7c1 3377 if (tmpOp == NULL) {
mkarlsso 3:ae33b7f5a7c1 3378 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 3:ae33b7f5a7c1 3379 tmpOp2->release();
mkarlsso 3:ae33b7f5a7c1 3380 tmpAction->release();
mkarlsso 3:ae33b7f5a7c1 3381 return NULL;
mkarlsso 3:ae33b7f5a7c1 3382 } else {
mkarlsso 2:298679fff37c 3383 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 2:298679fff37c 3384 }
mkarlsso 2:298679fff37c 3385 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3386 //pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso 2:298679fff37c 3387 } else {
mkarlsso 2:298679fff37c 3388 //delete tmpAction;
mkarlsso 2:298679fff37c 3389 tmpAction->release();
mkarlsso 2:298679fff37c 3390 return NULL;
mkarlsso 2:298679fff37c 3391 }
mkarlsso 2:298679fff37c 3392 } else {
mkarlsso 2:298679fff37c 3393 pcPtr->printf("Expression not understood: %s\r\n",afterEqual.data());
mkarlsso 2:298679fff37c 3394 //delete tmpAction;
mkarlsso 2:298679fff37c 3395 tmpAction->release();
mkarlsso 2:298679fff37c 3396 return NULL;
mkarlsso 2:298679fff37c 3397 }
mkarlsso 2:298679fff37c 3398
mkarlsso 2:298679fff37c 3399 } else if (findIntVariable(afterEqual) != NULL) { //assign value of another variable
mkarlsso 2:298679fff37c 3400 //tmpOp = new intOperation(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 2:298679fff37c 3401 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 2:298679fff37c 3402 if (tmpOp == NULL) {
mkarlsso 2:298679fff37c 3403 pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso 2:298679fff37c 3404 tmpAction->release();
mkarlsso 2:298679fff37c 3405 return NULL;
mkarlsso 2:298679fff37c 3406 } else {
mkarlsso 2:298679fff37c 3407 tmpOp->set(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 2:298679fff37c 3408 }
mkarlsso 2:298679fff37c 3409 tmpAction->set(tmpOp);
mkarlsso 2:298679fff37c 3410 //pcPtr->printf("Action: set variable to value of another\r\n");
mkarlsso 2:298679fff37c 3411 } else {
mkarlsso 2:298679fff37c 3412 pcPtr->printf("Variable not found: %s\r\n",afterEqual.data());
mkarlsso 2:298679fff37c 3413 //delete tmpAction;
mkarlsso 2:298679fff37c 3414 tmpAction->release();
mkarlsso 2:298679fff37c 3415 return NULL;
mkarlsso 2:298679fff37c 3416 }
mkarlsso 2:298679fff37c 3417
mkarlsso 2:298679fff37c 3418 } else {
mkarlsso 2:298679fff37c 3419 pcPtr->printf("Variable not found\r\n");
mkarlsso 2:298679fff37c 3420 //delete tmpAction;
mkarlsso 2:298679fff37c 3421 tmpAction->release();
mkarlsso 2:298679fff37c 3422 return NULL;
mkarlsso 2:298679fff37c 3423 }
mkarlsso 2:298679fff37c 3424 return tmpAction;
mkarlsso 2:298679fff37c 3425 }
mkarlsso 2:298679fff37c 3426
mkarlsso 2:298679fff37c 3427 bool scriptStream::isOutsideParenth(string expression,std::size_t foundItem) {
mkarlsso 2:298679fff37c 3428
mkarlsso 2:298679fff37c 3429 int pDepth = 0; // How many nested parentheses
mkarlsso 2:298679fff37c 3430 //pcPtr->printf("Check outside parentheses...");
mkarlsso 2:298679fff37c 3431 if (foundItem < expression.length()) {
mkarlsso 2:298679fff37c 3432 for (int i = 0; i <= foundItem; i++) {
mkarlsso 2:298679fff37c 3433 if (expression[i] == '(') {
mkarlsso 2:298679fff37c 3434 pDepth++;
mkarlsso 2:298679fff37c 3435 } else if (expression[i] == ')') {
mkarlsso 2:298679fff37c 3436 pDepth--;
mkarlsso 2:298679fff37c 3437 }
mkarlsso 2:298679fff37c 3438 }
mkarlsso 2:298679fff37c 3439 if (pDepth<=0) {
mkarlsso 2:298679fff37c 3440 //pcPtr->printf("yes.");
mkarlsso 2:298679fff37c 3441 return true;
mkarlsso 2:298679fff37c 3442 } else {
mkarlsso 2:298679fff37c 3443 //pcPtr->printf("no.");
mkarlsso 2:298679fff37c 3444 return false;
mkarlsso 2:298679fff37c 3445 }
mkarlsso 2:298679fff37c 3446 } else {
mkarlsso 2:298679fff37c 3447 return true;
mkarlsso 2:298679fff37c 3448 }
mkarlsso 2:298679fff37c 3449
mkarlsso 2:298679fff37c 3450 }
mkarlsso 2:298679fff37c 3451
mkarlsso 2:298679fff37c 3452 std::size_t scriptStream::findFirstOrOutsideParenth(string expression) {
mkarlsso 2:298679fff37c 3453
mkarlsso 2:298679fff37c 3454 std::size_t foundItem = expression.find("||");
mkarlsso 2:298679fff37c 3455 while (foundItem != std::string::npos) {
mkarlsso 2:298679fff37c 3456 if (isOutsideParenth(expression,foundItem)) {
mkarlsso 2:298679fff37c 3457 break;
mkarlsso 2:298679fff37c 3458 }
mkarlsso 2:298679fff37c 3459 foundItem = expression.find("||",foundItem+1);
mkarlsso 2:298679fff37c 3460 }
mkarlsso 2:298679fff37c 3461 return foundItem;
mkarlsso 2:298679fff37c 3462 }
mkarlsso 2:298679fff37c 3463
mkarlsso 2:298679fff37c 3464 std::size_t scriptStream::findFirstAndOutsideParenth(string expression) {
mkarlsso 2:298679fff37c 3465
mkarlsso 2:298679fff37c 3466 std::size_t foundItem = expression.find("&&");
mkarlsso 2:298679fff37c 3467 while (foundItem != std::string::npos) {
mkarlsso 2:298679fff37c 3468 if (isOutsideParenth(expression,foundItem)){
mkarlsso 2:298679fff37c 3469 break;
mkarlsso 2:298679fff37c 3470 }
mkarlsso 2:298679fff37c 3471 foundItem = expression.find("&&",foundItem+1);
mkarlsso 2:298679fff37c 3472 }
mkarlsso 2:298679fff37c 3473 return foundItem;
mkarlsso 2:298679fff37c 3474 }
mkarlsso 2:298679fff37c 3475
mkarlsso 2:298679fff37c 3476 condition* scriptStream::parseConditions(string expression) {
mkarlsso 2:298679fff37c 3477 //This function is used to parse a condition string
mkarlsso 2:298679fff37c 3478 //such as (x < y && x != z) || (y == 2)
mkarlsso 2:298679fff37c 3479 //This function first identifies the root node of the logic tree
mkarlsso 2:298679fff37c 3480 //based on operator precedence ( () > && > || ), and then recursively calls itself
mkarlsso 2:298679fff37c 3481 //to find the nodes of the branches. The basic building blocks of
mkarlsso 2:298679fff37c 3482 //the final condition object are arithmatic comparitors (a > b) and
mkarlsso 2:298679fff37c 3483 //other condition objects.
mkarlsso 2:298679fff37c 3484
mkarlsso 2:298679fff37c 3485
mkarlsso 2:298679fff37c 3486 //pcPtr->printf("Parsing condition: %s\r\n", expression.data());
mkarlsso 2:298679fff37c 3487 condition* newCondition = NULL;
mkarlsso 2:298679fff37c 3488 bool singleCondition = false; //no compound conditions
mkarlsso 2:298679fff37c 3489 string afterComparator;
mkarlsso 2:298679fff37c 3490 string beforeComparator;
mkarlsso 2:298679fff37c 3491
mkarlsso 2:298679fff37c 3492 std::size_t found;
mkarlsso 2:298679fff37c 3493
mkarlsso 2:298679fff37c 3494 //To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso 2:298679fff37c 3495 //so we look for OR conditions first
mkarlsso 2:298679fff37c 3496 char currentOperator = OR_CONDITION;
mkarlsso 2:298679fff37c 3497 //pcPtr->printf("Looking for OR condition...");
mkarlsso 2:298679fff37c 3498 found = findFirstOrOutsideParenth(expression);
mkarlsso 2:298679fff37c 3499 if (found==std::string::npos) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso 2:298679fff37c 3500 currentOperator = AND_CONDITION;
mkarlsso 2:298679fff37c 3501 //pcPtr->printf("Looking for AND condition...");
mkarlsso 2:298679fff37c 3502 found = findFirstAndOutsideParenth(expression);
mkarlsso 2:298679fff37c 3503 }
mkarlsso 2:298679fff37c 3504 if (found==std::string::npos) { //no or/and conditions outside parentheses found
mkarlsso 2:298679fff37c 3505 //if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso 2:298679fff37c 3506 bool removedParenth = false;
mkarlsso 2:298679fff37c 3507 if ((expression[0] == '(') && (expression[expression.length()-1] == ')')) {
mkarlsso 2:298679fff37c 3508 //pcPtr->printf("Remove parentheses");
mkarlsso 2:298679fff37c 3509 expression = expression.substr(1,expression.length()-2);
mkarlsso 2:298679fff37c 3510 removedParenth = true;
mkarlsso 2:298679fff37c 3511 }
mkarlsso 2:298679fff37c 3512 if (removedParenth) { //we removed parentheses, so try again
mkarlsso 2:298679fff37c 3513 return parseConditions(expression);
mkarlsso 2:298679fff37c 3514 } else {
mkarlsso 2:298679fff37c 3515 singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso 2:298679fff37c 3516 }
mkarlsso 2:298679fff37c 3517 }
mkarlsso 2:298679fff37c 3518
mkarlsso 2:298679fff37c 3519 if (singleCondition) { //no compound conditions found
mkarlsso 2:298679fff37c 3520 //pcPtr->printf("Single condition");
mkarlsso 2:298679fff37c 3521 std::size_t equalStringInd;
mkarlsso 2:298679fff37c 3522 std::size_t greaterOrEqualStringInd;
mkarlsso 2:298679fff37c 3523 std::size_t lessThanOrEqualStringInd;
mkarlsso 2:298679fff37c 3524 std::size_t notEqualStringInd;
mkarlsso 2:298679fff37c 3525 std::size_t greaterThanStringInd;
mkarlsso 2:298679fff37c 3526 std::size_t lessThanStringInd;
mkarlsso 2:298679fff37c 3527 std::size_t generalCompareStringInd;
mkarlsso 2:298679fff37c 3528
mkarlsso 2:298679fff37c 3529
mkarlsso 2:298679fff37c 3530 string tmpCondition = expression;
mkarlsso 2:298679fff37c 3531 string compareString;
mkarlsso 2:298679fff37c 3532 //The expression might have up to three variables
mkarlsso 2:298679fff37c 3533 int* tmpVar;
mkarlsso 2:298679fff37c 3534 int* tmpVar2;
mkarlsso 2:298679fff37c 3535 int* tmpVar3;
mkarlsso 2:298679fff37c 3536
mkarlsso 2:298679fff37c 3537 int offset = 0;
mkarlsso 2:298679fff37c 3538 equalStringInd = tmpCondition.find("=="); //location of comparator
mkarlsso 2:298679fff37c 3539 greaterOrEqualStringInd = tmpCondition.find(">="); //location of comparator
mkarlsso 2:298679fff37c 3540 lessThanOrEqualStringInd = tmpCondition.find("<="); //location of comparator
mkarlsso 2:298679fff37c 3541 notEqualStringInd = tmpCondition.find("!="); //location of comparator
mkarlsso 2:298679fff37c 3542 greaterThanStringInd = tmpCondition.find_first_of(">"); //location of comparator
mkarlsso 2:298679fff37c 3543 lessThanStringInd = tmpCondition.find_first_of("<"); //location of comparator
mkarlsso 2:298679fff37c 3544
mkarlsso 2:298679fff37c 3545 if ((equalStringInd != std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3546 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3547
mkarlsso 2:298679fff37c 3548 generalCompareStringInd = equalStringInd;
mkarlsso 2:298679fff37c 3549 compareString = "==";
mkarlsso 2:298679fff37c 3550 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd != std::string::npos) &&
mkarlsso 2:298679fff37c 3551 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3552
mkarlsso 2:298679fff37c 3553 generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso 2:298679fff37c 3554 compareString = ">=";
mkarlsso 2:298679fff37c 3555 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3556 (lessThanOrEqualStringInd != std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3557
mkarlsso 2:298679fff37c 3558 generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso 2:298679fff37c 3559 compareString = "<=";
mkarlsso 2:298679fff37c 3560 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3561 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd != std::string::npos)){
mkarlsso 2:298679fff37c 3562
mkarlsso 2:298679fff37c 3563 generalCompareStringInd = notEqualStringInd;
mkarlsso 2:298679fff37c 3564 compareString = "!=";
mkarlsso 2:298679fff37c 3565 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3566 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3567 (greaterThanStringInd != std::string::npos) && (lessThanStringInd == std::string::npos)){
mkarlsso 2:298679fff37c 3568
mkarlsso 2:298679fff37c 3569 generalCompareStringInd = greaterThanStringInd;
mkarlsso 2:298679fff37c 3570 compareString = ">";
mkarlsso 2:298679fff37c 3571 offset = 1;
mkarlsso 2:298679fff37c 3572 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3573 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 2:298679fff37c 3574 (greaterThanStringInd == std::string::npos) && (lessThanStringInd != std::string::npos)){
mkarlsso 2:298679fff37c 3575
mkarlsso 2:298679fff37c 3576 generalCompareStringInd = lessThanStringInd;
mkarlsso 2:298679fff37c 3577 compareString = "<";
mkarlsso 2:298679fff37c 3578 offset = 1;
mkarlsso 2:298679fff37c 3579
mkarlsso 2:298679fff37c 3580 }else {
mkarlsso 2:298679fff37c 3581 pcPtr->printf("Condition not understood: %s\r\n", expression.data());
mkarlsso 2:298679fff37c 3582 return 0;
mkarlsso 2:298679fff37c 3583 }
mkarlsso 2:298679fff37c 3584
mkarlsso 2:298679fff37c 3585 intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso 2:298679fff37c 3586 if (newCompare == NULL) {
mkarlsso 2:298679fff37c 3587 pcPtr->printf("Error: No memory slots available.");
mkarlsso 2:298679fff37c 3588 return NULL;
mkarlsso 2:298679fff37c 3589 }
mkarlsso 2:298679fff37c 3590 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 2:298679fff37c 3591 if (newCondition == NULL) {
mkarlsso 2:298679fff37c 3592 pcPtr->printf("Error: No memory slots available.");
mkarlsso 2:298679fff37c 3593 return NULL;
mkarlsso 2:298679fff37c 3594 }
mkarlsso 2:298679fff37c 3595 afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso 2:298679fff37c 3596
mkarlsso 2:298679fff37c 3597 beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso 2:298679fff37c 3598 tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso 2:298679fff37c 3599 if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso 2:298679fff37c 3600 tmpVar2 = findIntVariable(afterComparator); //returns pointer to the variable
mkarlsso 2:298679fff37c 3601 if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso 2:298679fff37c 3602 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso 2:298679fff37c 3603 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 2:298679fff37c 3604 newCompare->set(tmpVar,compareString.data(),tmpVar2);
mkarlsso 2:298679fff37c 3605 newCondition->set(newCompare);
mkarlsso 2:298679fff37c 3606
mkarlsso 2:298679fff37c 3607 //pcPtr->printf("Var vs. Var condition added: %s\r\n", tmpCondition.data());
mkarlsso 2:298679fff37c 3608 } else if (isNumber(afterComparator)) {
mkarlsso 2:298679fff37c 3609 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 2:298679fff37c 3610 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 2:298679fff37c 3611 newCompare->set(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 2:298679fff37c 3612 newCondition->set(newCompare);
mkarlsso 2:298679fff37c 3613
mkarlsso 2:298679fff37c 3614 //pcPtr->printf("Var vs. Int condition added: %s\r\n", tmpCondition.data());
mkarlsso 2:298679fff37c 3615 } //more here
mkarlsso 2:298679fff37c 3616
mkarlsso 2:298679fff37c 3617 } else {
mkarlsso 2:298679fff37c 3618 pcPtr->printf("Condition not understood: %s\r\n", expression.data());
mkarlsso 2:298679fff37c 3619
mkarlsso 2:298679fff37c 3620 return NULL;
mkarlsso 2:298679fff37c 3621 }
mkarlsso 2:298679fff37c 3622
mkarlsso 2:298679fff37c 3623 } else { //this is a compound condition (with either && or ||)
mkarlsso 2:298679fff37c 3624 //pcPtr->printf("Compound condition");
mkarlsso 2:298679fff37c 3625 afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso 2:298679fff37c 3626 beforeComparator = expression.substr(0,found);
mkarlsso 2:298679fff37c 3627 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 2:298679fff37c 3628 if (newCondition == NULL) {
mkarlsso 2:298679fff37c 3629 pcPtr->printf("Error: No memory slots available.");
mkarlsso 2:298679fff37c 3630 return NULL;
mkarlsso 2:298679fff37c 3631 } else {
mkarlsso 2:298679fff37c 3632 newCondition->isUsed = true; //reserve the condition slot;
mkarlsso 2:298679fff37c 3633 }
mkarlsso 2:298679fff37c 3634 //recursively call this function to parse the sub conditions
mkarlsso 2:298679fff37c 3635 condition* cond1 = parseConditions(beforeComparator);
mkarlsso 2:298679fff37c 3636 if (cond1 == NULL) {
mkarlsso 2:298679fff37c 3637 newCondition->release();
mkarlsso 2:298679fff37c 3638 return NULL;
mkarlsso 2:298679fff37c 3639 }
mkarlsso 2:298679fff37c 3640 condition* cond2 = parseConditions(afterComparator);
mkarlsso 2:298679fff37c 3641 if (cond2 == NULL) {
mkarlsso 2:298679fff37c 3642 newCondition->release();
mkarlsso 2:298679fff37c 3643 cond1->release();
mkarlsso 2:298679fff37c 3644 return NULL;
mkarlsso 2:298679fff37c 3645 }
mkarlsso 2:298679fff37c 3646 newCondition->set(cond1,currentOperator, cond2);
mkarlsso 2:298679fff37c 3647
mkarlsso 2:298679fff37c 3648 }
mkarlsso 2:298679fff37c 3649
mkarlsso 2:298679fff37c 3650 return newCondition; //all went well, so return the newly made condition
mkarlsso 2:298679fff37c 3651
mkarlsso 2:298679fff37c 3652 }
mkarlsso 2:298679fff37c 3653
mkarlsso 2:298679fff37c 3654 bool scriptStream::evaluateConditions(string expression, event* currentEvent) {
mkarlsso 2:298679fff37c 3655 //calls the function to parse the condition string. The condition pointer is then
mkarlsso 2:298679fff37c 3656 //attached to the event
mkarlsso 2:298679fff37c 3657
mkarlsso 2:298679fff37c 3658 condition* newCondition = NULL;
mkarlsso 2:298679fff37c 3659 newCondition = parseConditions(expression);
mkarlsso 2:298679fff37c 3660 if (newCondition == NULL) {
mkarlsso 2:298679fff37c 3661 return false;
mkarlsso 2:298679fff37c 3662 } else {
mkarlsso 2:298679fff37c 3663 currentEvent->addCondition(newCondition);
mkarlsso 2:298679fff37c 3664 return true;
mkarlsso 2:298679fff37c 3665 }
mkarlsso 2:298679fff37c 3666 }
mkarlsso 2:298679fff37c 3667
mkarlsso 2:298679fff37c 3668 int scriptStream::getRandomParam(string expression) {
mkarlsso 2:298679fff37c 3669
mkarlsso 2:298679fff37c 3670 int pos1 = expression.find("random(")+7;
mkarlsso 2:298679fff37c 3671 int pos2 = expression.find_first_of(")",pos1);
mkarlsso 2:298679fff37c 3672 int highVal = atoi(expression.substr(pos1,pos2-pos1).data());
mkarlsso 2:298679fff37c 3673
mkarlsso 2:298679fff37c 3674 if ((highVal > 0)) {
mkarlsso 2:298679fff37c 3675 return highVal;
mkarlsso 2:298679fff37c 3676 } else {
mkarlsso 2:298679fff37c 3677 pcPtr->printf("Error: random parameter must be 1 or more\r\n");
mkarlsso 2:298679fff37c 3678 return 0;
mkarlsso 2:298679fff37c 3679 }
mkarlsso 2:298679fff37c 3680 }
mkarlsso 2:298679fff37c 3681
mkarlsso 2:298679fff37c 3682
mkarlsso 2:298679fff37c 3683 outputStream::outputStream(int bufferSizeIn):
mkarlsso 2:298679fff37c 3684 readHead(0),
mkarlsso 2:298679fff37c 3685 writeHead(0),
mkarlsso 2:298679fff37c 3686 totalWriteHead(0),
mkarlsso 2:298679fff37c 3687 totalReadHead(0),
mkarlsso 2:298679fff37c 3688 bufferSize(bufferSizeIn),
mkarlsso 2:298679fff37c 3689 unsentData(false) {
mkarlsso 2:298679fff37c 3690
mkarlsso 2:298679fff37c 3691 outputBuffer = new char[bufferSize];
mkarlsso 2:298679fff37c 3692
mkarlsso 2:298679fff37c 3693 }
mkarlsso 2:298679fff37c 3694
mkarlsso 2:298679fff37c 3695 outputStream::~outputStream() {
mkarlsso 2:298679fff37c 3696 delete[] outputBuffer;
mkarlsso 2:298679fff37c 3697 }
mkarlsso 2:298679fff37c 3698
mkarlsso 2:298679fff37c 3699 //adds text to the buffer
mkarlsso 2:298679fff37c 3700 void outputStream::send(string outputString) {
mkarlsso 2:298679fff37c 3701 int strLen = outputString.size();
mkarlsso 2:298679fff37c 3702
mkarlsso 2:298679fff37c 3703 int total = 0;
mkarlsso 2:298679fff37c 3704 int chunk = 0;
mkarlsso 2:298679fff37c 3705 if (!(totalWriteHead+strLen > (totalReadHead + bufferSize))) {
mkarlsso 2:298679fff37c 3706 while (strLen - total > 0) {
mkarlsso 2:298679fff37c 3707 chunk = min((bufferSize - writeHead), strLen - total);
mkarlsso 2:298679fff37c 3708 outputString.copy(outputBuffer + writeHead, chunk, total);
mkarlsso 2:298679fff37c 3709 writeHead = (writeHead + chunk) % bufferSize;
mkarlsso 2:298679fff37c 3710 totalWriteHead += chunk;
mkarlsso 2:298679fff37c 3711 total += chunk;
mkarlsso 2:298679fff37c 3712 }
mkarlsso 2:298679fff37c 3713 if (total > 0) {
mkarlsso 2:298679fff37c 3714 unsentData = true;
mkarlsso 2:298679fff37c 3715 }
mkarlsso 2:298679fff37c 3716 }
mkarlsso 2:298679fff37c 3717 }
mkarlsso 2:298679fff37c 3718
mkarlsso 2:298679fff37c 3719 //the main loop gets one character per loop and write it to the serial port
mkarlsso 2:298679fff37c 3720 char outputStream::getNextChar() {
mkarlsso 2:298679fff37c 3721
mkarlsso 2:298679fff37c 3722
mkarlsso 2:298679fff37c 3723 if (totalReadHead < totalWriteHead) {
mkarlsso 2:298679fff37c 3724 tmpOut = *(outputBuffer+readHead);
mkarlsso 2:298679fff37c 3725 readHead = (readHead+1) % bufferSize;
mkarlsso 2:298679fff37c 3726 totalReadHead++;
mkarlsso 2:298679fff37c 3727 if (totalReadHead >= totalWriteHead) {
mkarlsso 2:298679fff37c 3728 unsentData = false;
mkarlsso 2:298679fff37c 3729 }
mkarlsso 2:298679fff37c 3730 }
mkarlsso 2:298679fff37c 3731 return tmpOut;
mkarlsso 2:298679fff37c 3732
mkarlsso 2:298679fff37c 3733 }
mkarlsso 2:298679fff37c 3734