Andy Lustig / Mbed 2 deprecated stateScript_v2_karpovalab

Karpova Lab fork of stateScript

Dependencies:   SMARTWAV SOMO_II mbed

Fork of stateScript_v2_karpova by Andy Lustig

behave.cpp@7:42aa1e804047, 2016-01-27 (annotated)

Committer:
alustig3
Date:
Wed Jan 27 20:17:16 2016 +0000
Revision:
7:42aa1e804047
Parent:
6:67d67d452545
Parent:
4:b019c133a8fb
Child:
9:f15ad8d18881
send "kaboom" command to reset mbed

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mkarlsso 0:8dbd6bd9167f 1 #include "behave.h"
mkarlsso 0:8dbd6bd9167f 2 #include "hardwareInterface.h"
mkarlsso 0:8dbd6bd9167f 3 #include <ctype.h>
mkarlsso 0:8dbd6bd9167f 4 #include <sstream>
mkarlsso 3:d7b0a0890d96 5 //#include <string.h>
mkarlsso 3:d7b0a0890d96 6 //#include <cstdlib>
mkarlsso 0:8dbd6bd9167f 7
mkarlsso 0:8dbd6bd9167f 8 using namespace std;
mkarlsso 0:8dbd6bd9167f 9
mkarlsso 0:8dbd6bd9167f 10 int16_t randomSeedCounter; //used for seeding random numbers
mkarlsso 0:8dbd6bd9167f 11
mkarlsso 0:8dbd6bd9167f 12 //digitalPort* portVector[NUMPORTS+1]; //a list of pointers to the digital ports
mkarlsso 0:8dbd6bd9167f 13
mkarlsso 0:8dbd6bd9167f 14 //Main event queue
mkarlsso 0:8dbd6bd9167f 15 eventQueue mainQueue;
mkarlsso 0:8dbd6bd9167f 16
mkarlsso 0:8dbd6bd9167f 17 //The script parser
mkarlsso 0:8dbd6bd9167f 18 //scriptStream parser(portVector, NUMPORTS, &mainQueue);
mkarlsso 0:8dbd6bd9167f 19
mkarlsso 0:8dbd6bd9167f 20 //globals defined in hardwareInterface.cpp
mkarlsso 0:8dbd6bd9167f 21 extern uint32_t timeKeeper; //the master clock
mkarlsso 0:8dbd6bd9167f 22 extern bool resetTimer;
mkarlsso 0:8dbd6bd9167f 23 extern bool clockSlave;
mkarlsso 0:8dbd6bd9167f 24 extern bool changeToSlave;
mkarlsso 0:8dbd6bd9167f 25 extern bool changeToStandAlone;
mkarlsso 0:8dbd6bd9167f 26 extern outputStream textDisplay;
mkarlsso 0:8dbd6bd9167f 27
mkarlsso 0:8dbd6bd9167f 28 //extern int currentDIOstate[2];
mkarlsso 0:8dbd6bd9167f 29 bool broadCastStateChanges;
mkarlsso 0:8dbd6bd9167f 30 bool textStreaming;
mkarlsso 0:8dbd6bd9167f 31
mkarlsso 0:8dbd6bd9167f 32
mkarlsso 0:8dbd6bd9167f 33
mkarlsso 0:8dbd6bd9167f 34 //These items may be placed in hardware-specific parts of memory
mkarlsso 0:8dbd6bd9167f 35
mkarlsso 0:8dbd6bd9167f 36 #ifdef MBEDHARDWARE
mkarlsso 0:8dbd6bd9167f 37 //__attribute((section("AHBSRAM0"),aligned)) outputStream textDisplay(512);
mkarlsso 0:8dbd6bd9167f 38 __attribute((section("AHBSRAM0"),aligned)) char buffer[256];
mkarlsso 0:8dbd6bd9167f 39 __attribute((section("AHBSRAM1"),aligned)) event eventBlock[NUMEVENTS];
mkarlsso 0:8dbd6bd9167f 40 __attribute((section("AHBSRAM1"),aligned)) condition conditionBlock[NUMCONDITIONS];
mkarlsso 0:8dbd6bd9167f 41 __attribute((section("AHBSRAM1"),aligned)) intCompare intCompareBlock[NUMINTCOMPARE];
mkarlsso 0:8dbd6bd9167f 42 __attribute((section("AHBSRAM0"),aligned)) action actionBlock[NUMACTIONS];
mkarlsso 0:8dbd6bd9167f 43 __attribute((section("AHBSRAM0"),aligned)) portMessage portMessageBlock[NUMPORTMESSAGES];
mkarlsso 0:8dbd6bd9167f 44 //__attribute((section("AHBSRAM1"),aligned)) intVariable intVariableBlock[10];
mkarlsso 0:8dbd6bd9167f 45 __attribute((section("AHBSRAM0"),aligned)) intOperation intOperationBlock[NUMINTOPERATIONS];
mkarlsso 0:8dbd6bd9167f 46 __attribute((section("AHBSRAM0"),aligned)) displayAction displayActionBlock[NUMDISPLAYACTIONS];
mkarlsso 0:8dbd6bd9167f 47 __attribute((section("AHBSRAM0"),aligned)) triggerFunctionAction triggerFunctionActionBlock[NUMTRIGGERACTIONS];
mkarlsso 0:8dbd6bd9167f 48 #endif
mkarlsso 0:8dbd6bd9167f 49
mkarlsso 0:8dbd6bd9167f 50 #ifdef FPGAHARDWARE
mkarlsso 0:8dbd6bd9167f 51
mkarlsso 0:8dbd6bd9167f 52 char buffer[256];
mkarlsso 0:8dbd6bd9167f 53 event eventBlock[NUMEVENTS];
mkarlsso 0:8dbd6bd9167f 54 condition conditionBlock[NUMCONDITIONS];
mkarlsso 0:8dbd6bd9167f 55 intCompare intCompareBlock[NUMINTCOMPARE];
mkarlsso 0:8dbd6bd9167f 56 action actionBlock[NUMACTIONS];
mkarlsso 0:8dbd6bd9167f 57 portMessage portMessageBlock[NUMPORTMESSAGES];
mkarlsso 0:8dbd6bd9167f 58 intOperation intOperationBlock[NUMINTOPERATIONS];
mkarlsso 0:8dbd6bd9167f 59 displayAction displayActionBlock[NUMDISPLAYACTIONS];
mkarlsso 0:8dbd6bd9167f 60 triggerFunctionAction triggerFunctionActionBlock[NUMTRIGGERACTIONS];
mkarlsso 0:8dbd6bd9167f 61 #endif
mkarlsso 0:8dbd6bd9167f 62
mkarlsso 0:8dbd6bd9167f 63
mkarlsso 0:8dbd6bd9167f 64 event* functionEventArray[NUMFUNCTIONS];
mkarlsso 0:8dbd6bd9167f 65 bool functionSpotTaken[NUMFUNCTIONS];
mkarlsso 0:8dbd6bd9167f 66
mkarlsso 0:8dbd6bd9167f 67
mkarlsso 0:8dbd6bd9167f 68 //-----------------------------------------------
mkarlsso 0:8dbd6bd9167f 69 //This is the main loop of the program
mkarlsso 0:8dbd6bd9167f 70 mainLoop::mainLoop(){
mkarlsso 0:8dbd6bd9167f 71
mkarlsso 0:8dbd6bd9167f 72
mkarlsso 0:8dbd6bd9167f 73 }
mkarlsso 0:8dbd6bd9167f 74
mkarlsso 0:8dbd6bd9167f 75 void mainLoop::init() {
mkarlsso 0:8dbd6bd9167f 76 currentDIOstate[0] = 0;
mkarlsso 0:8dbd6bd9167f 77 currentDIOstate[1] = 0;
mkarlsso 0:8dbd6bd9167f 78 digitalInChanged = false;
mkarlsso 0:8dbd6bd9167f 79 digitalOutChanged = false;
mkarlsso 0:8dbd6bd9167f 80 textStreaming = true;
mkarlsso 0:8dbd6bd9167f 81 eraseBuffer();
mkarlsso 0:8dbd6bd9167f 82 broadCastStateChanges = true;
mkarlsso 0:8dbd6bd9167f 83
mkarlsso 0:8dbd6bd9167f 84
mkarlsso 0:8dbd6bd9167f 85
mkarlsso 0:8dbd6bd9167f 86 //section for MBED hardware
mkarlsso 0:8dbd6bd9167f 87 #ifdef MBEDHARDWARE
mkarlsso 0:8dbd6bd9167f 88 hardware = new MBEDSystem();
mkarlsso 0:8dbd6bd9167f 89 hardware->timerinit();
mkarlsso 0:8dbd6bd9167f 90 pc = new MBEDSerialPort();
mkarlsso 0:8dbd6bd9167f 91 pc->init();
mkarlsso 0:8dbd6bd9167f 92 textDisplay.setSerial(pc);
mkarlsso 0:8dbd6bd9167f 93
mkarlsso 0:8dbd6bd9167f 94 #endif
mkarlsso 0:8dbd6bd9167f 95
mkarlsso 0:8dbd6bd9167f 96 #ifdef FPGAHARDWARE
mkarlsso 0:8dbd6bd9167f 97 pc = new FPGASerialPort();
mkarlsso 0:8dbd6bd9167f 98 pc->init();
mkarlsso 0:8dbd6bd9167f 99
mkarlsso 0:8dbd6bd9167f 100 hardware = new FPGASystem();
mkarlsso 0:8dbd6bd9167f 101 hardware->timerinit();
mkarlsso 0:8dbd6bd9167f 102
mkarlsso 0:8dbd6bd9167f 103 textDisplay.setSerial(pc);
mkarlsso 0:8dbd6bd9167f 104
mkarlsso 0:8dbd6bd9167f 105 DIO_DCR = DIO_DCR_IE; // enable DIO edge interrupts
mkarlsso 0:8dbd6bd9167f 106 #endif
mkarlsso 0:8dbd6bd9167f 107
mkarlsso 0:8dbd6bd9167f 108 for (int i = 0; i < NUMPORTS; i++) {
mkarlsso 0:8dbd6bd9167f 109 //Set up the ports. Each has two pointers to the harware implementations
mkarlsso 0:8dbd6bd9167f 110 //of a digital out and digital in.
mkarlsso 0:8dbd6bd9167f 111 ports[i].init(hardware->getDigitalOutPtr(i),hardware->getDigitalInPtr(i));
mkarlsso 0:8dbd6bd9167f 112 }
mkarlsso 0:8dbd6bd9167f 113
mkarlsso 0:8dbd6bd9167f 114
mkarlsso 0:8dbd6bd9167f 115 parser = new scriptStream(ports, NUMPORTS, &mainQueue, hardware);
mkarlsso 0:8dbd6bd9167f 116
mkarlsso 0:8dbd6bd9167f 117 }
mkarlsso 0:8dbd6bd9167f 118
mkarlsso 0:8dbd6bd9167f 119 void mainLoop::exec() {
mkarlsso 0:8dbd6bd9167f 120 bool digitalInChanged = false;
mkarlsso 0:8dbd6bd9167f 121 bool digitalOutChanged = false;
mkarlsso 3:d7b0a0890d96 122 bool *ignoreUpdatePorts = hardware->getIgnoreUpdates();
mkarlsso 0:8dbd6bd9167f 123 uint32_t changeTime;
mkarlsso 0:8dbd6bd9167f 124 timeKeeper = 0; //set main clock to 0;
mkarlsso 0:8dbd6bd9167f 125
mkarlsso 0:8dbd6bd9167f 126 int bufferPos = 0;
mkarlsso 0:8dbd6bd9167f 127
mkarlsso 6:67d67d452545 128 //ostringstream timeConvert; // stream used for the conversion
mkarlsso 6:67d67d452545 129 //ostringstream stateConvert;
mkarlsso 0:8dbd6bd9167f 130 int tmpChar;
mkarlsso 0:8dbd6bd9167f 131 int junkChar;
mkarlsso 0:8dbd6bd9167f 132
mkarlsso 0:8dbd6bd9167f 133 uint16_t shortcutTriggers[PENDINGTRIGGERBUFFERSIZE];
mkarlsso 0:8dbd6bd9167f 134 int numTriggersToProcess;
mkarlsso 0:8dbd6bd9167f 135
mkarlsso 0:8dbd6bd9167f 136 while (pc->readable()) {
mkarlsso 0:8dbd6bd9167f 137 junkChar = pc->readChar();
mkarlsso 0:8dbd6bd9167f 138 }
mkarlsso 0:8dbd6bd9167f 139
mkarlsso 0:8dbd6bd9167f 140 #ifdef MBEDHARDWARE
mkarlsso 0:8dbd6bd9167f 141 LocalFileSystem local("local");
mkarlsso 0:8dbd6bd9167f 142
mkarlsso 0:8dbd6bd9167f 143 FILE *fp = fopen("/local/STARTUP.TXT", "r");
mkarlsso 0:8dbd6bd9167f 144 if (fp != NULL) {
mkarlsso 0:8dbd6bd9167f 145
mkarlsso 0:8dbd6bd9167f 146 textDisplay.send("Executing startup script...\r\n");
mkarlsso 0:8dbd6bd9167f 147
mkarlsso 0:8dbd6bd9167f 148 do {
mkarlsso 0:8dbd6bd9167f 149 tmpChar = fgetc(fp);
mkarlsso 0:8dbd6bd9167f 150 if ((tmpChar >= 32) && (tmpChar <= 126)) {
mkarlsso 0:8dbd6bd9167f 151 buffer[bufferPos] = tmpChar;
mkarlsso 0:8dbd6bd9167f 152 bufferPos++;
mkarlsso 0:8dbd6bd9167f 153 }
mkarlsso 0:8dbd6bd9167f 154 if ((tmpChar == 13) || (tmpChar == 10)) { //carrriage return
mkarlsso 0:8dbd6bd9167f 155 parser->addLineToCurrentBlock(buffer);
mkarlsso 0:8dbd6bd9167f 156 bufferPos = 0;
mkarlsso 0:8dbd6bd9167f 157 eraseBuffer();
mkarlsso 0:8dbd6bd9167f 158 }
mkarlsso 0:8dbd6bd9167f 159 //pc.putc(tmpChar);
mkarlsso 0:8dbd6bd9167f 160 } while (tmpChar != EOF);
mkarlsso 0:8dbd6bd9167f 161
mkarlsso 0:8dbd6bd9167f 162 buffer[bufferPos] = 59;
mkarlsso 0:8dbd6bd9167f 163 parser->addLineToCurrentBlock(buffer);
mkarlsso 0:8dbd6bd9167f 164 eraseBuffer();
mkarlsso 0:8dbd6bd9167f 165 fclose(fp);
mkarlsso 0:8dbd6bd9167f 166 } else {
mkarlsso 0:8dbd6bd9167f 167 textDisplay.send("No startup script found.\r\n");
mkarlsso 0:8dbd6bd9167f 168 }
mkarlsso 0:8dbd6bd9167f 169 #endif
mkarlsso 0:8dbd6bd9167f 170
mkarlsso 0:8dbd6bd9167f 171 //Get the initial state of all input pins
mkarlsso 0:8dbd6bd9167f 172 for (int i = 0; i < NUMPORTS; i++) {
mkarlsso 0:8dbd6bd9167f 173
mkarlsso 0:8dbd6bd9167f 174 if (ports[i].getDigitalIn() == 1) {
mkarlsso 0:8dbd6bd9167f 175 currentDIOstate[0] |= (1 << i);
mkarlsso 0:8dbd6bd9167f 176 } else {
mkarlsso 0:8dbd6bd9167f 177 currentDIOstate[0] &= ~(1 << i);
mkarlsso 0:8dbd6bd9167f 178 }
mkarlsso 0:8dbd6bd9167f 179 }
mkarlsso 0:8dbd6bd9167f 180
mkarlsso 0:8dbd6bd9167f 181
mkarlsso 0:8dbd6bd9167f 182 //main loop
mkarlsso 0:8dbd6bd9167f 183 while(1) {
mkarlsso 0:8dbd6bd9167f 184 //check the main event queue to see if anything needs to be done
mkarlsso 0:8dbd6bd9167f 185
mkarlsso 0:8dbd6bd9167f 186 mainQueue.check();
mkarlsso 0:8dbd6bd9167f 187
mkarlsso 0:8dbd6bd9167f 188 //check if anything has been written to the serial input
mkarlsso 0:8dbd6bd9167f 189 while (pc->readable()) {
mkarlsso 0:8dbd6bd9167f 190
mkarlsso 0:8dbd6bd9167f 191 buffer[bufferPos] = pc->readChar();
mkarlsso 0:8dbd6bd9167f 192 bufferPos++;
mkarlsso 0:8dbd6bd9167f 193
mkarlsso 0:8dbd6bd9167f 194
mkarlsso 0:8dbd6bd9167f 195 //'Return' key pressed
mkarlsso 0:8dbd6bd9167f 196 if ((buffer[bufferPos-1] == 13) || (buffer[bufferPos-1] == 10)) {
mkarlsso 0:8dbd6bd9167f 197
mkarlsso 0:8dbd6bd9167f 198 buffer[bufferPos-1] = '\0';
mkarlsso 0:8dbd6bd9167f 199
mkarlsso 0:8dbd6bd9167f 200 parser->addLineToCurrentBlock(buffer);
mkarlsso 0:8dbd6bd9167f 201 bufferPos = 0;
mkarlsso 0:8dbd6bd9167f 202 eraseBuffer();
mkarlsso 0:8dbd6bd9167f 203
mkarlsso 0:8dbd6bd9167f 204 } else {
mkarlsso 0:8dbd6bd9167f 205
mkarlsso 0:8dbd6bd9167f 206 //Backspace was pressed
mkarlsso 0:8dbd6bd9167f 207 if (((buffer[bufferPos-1] == 127)||(buffer[bufferPos-1] == 8))) {
mkarlsso 0:8dbd6bd9167f 208 if (bufferPos > 1) {
mkarlsso 0:8dbd6bd9167f 209 bufferPos = bufferPos-2; //erase the backspace char plus the one before
mkarlsso 0:8dbd6bd9167f 210 } else {
mkarlsso 0:8dbd6bd9167f 211 bufferPos = bufferPos-1; //beginning of line, so nothing to erase
mkarlsso 0:8dbd6bd9167f 212 }
mkarlsso 0:8dbd6bd9167f 213 }
mkarlsso 0:8dbd6bd9167f 214 }
mkarlsso 0:8dbd6bd9167f 215 }
mkarlsso 0:8dbd6bd9167f 216
mkarlsso 0:8dbd6bd9167f 217 //Check all the digital ports to see if anything has changed. In the update routine, the port's
mkarlsso 0:8dbd6bd9167f 218 //script callbacks are called if the port was triggered
mkarlsso 0:8dbd6bd9167f 219 digitalInChanged = false;
mkarlsso 0:8dbd6bd9167f 220 digitalOutChanged = false;
mkarlsso 0:8dbd6bd9167f 221 changeTime = timeKeeper;
mkarlsso 3:d7b0a0890d96 222
mkarlsso 0:8dbd6bd9167f 223 for (int i = 0; i < NUMPORTS; i++) {
mkarlsso 0:8dbd6bd9167f 224
mkarlsso 0:8dbd6bd9167f 225 if (ports[i].update()) {
mkarlsso 0:8dbd6bd9167f 226
mkarlsso 3:d7b0a0890d96 227 if (!ignoreUpdatePorts[i]) {
mkarlsso 3:d7b0a0890d96 228 //Only trigger an output update to the serial port if ignore is false
mkarlsso 3:d7b0a0890d96 229 digitalInChanged = true;
mkarlsso 3:d7b0a0890d96 230 }
mkarlsso 0:8dbd6bd9167f 231 changeTime = min(changeTime,ports[i].lastChangeTime);
mkarlsso 0:8dbd6bd9167f 232
mkarlsso 0:8dbd6bd9167f 233
mkarlsso 0:8dbd6bd9167f 234 //The input state of all the ports in condensed into one number (each bit contains the info)
mkarlsso 0:8dbd6bd9167f 235 if (ports[i].getLastChangeState() == 1) {
mkarlsso 0:8dbd6bd9167f 236 currentDIOstate[0] |= (1 << i);
mkarlsso 0:8dbd6bd9167f 237 } else {
mkarlsso 0:8dbd6bd9167f 238 currentDIOstate[0] &= ~(1 << i);
mkarlsso 0:8dbd6bd9167f 239 }
mkarlsso 0:8dbd6bd9167f 240 }
mkarlsso 0:8dbd6bd9167f 241 if (ports[i].outStateChanged) {
mkarlsso 6:67d67d452545 242 if (!ignoreUpdatePorts[i]) {
mkarlsso 6:67d67d452545 243 //Only trigger an output update to the serial port if ignore is false
mkarlsso 6:67d67d452545 244 digitalOutChanged = true;
mkarlsso 6:67d67d452545 245 }
mkarlsso 0:8dbd6bd9167f 246 changeTime = min(changeTime,ports[i].lastOutChangeTime);
mkarlsso 0:8dbd6bd9167f 247 //The out state of all the ports is condensed into one number (each bit contains the info)
mkarlsso 0:8dbd6bd9167f 248 if (ports[i].outState == 1) {
mkarlsso 0:8dbd6bd9167f 249 currentDIOstate[1] |= (1 << i);
mkarlsso 0:8dbd6bd9167f 250 } else {
mkarlsso 0:8dbd6bd9167f 251 currentDIOstate[1] &= ~(1 << i);
mkarlsso 0:8dbd6bd9167f 252 }
mkarlsso 0:8dbd6bd9167f 253 ports[i].outStateChanged = false;
mkarlsso 0:8dbd6bd9167f 254 }
mkarlsso 0:8dbd6bd9167f 255 }
mkarlsso 0:8dbd6bd9167f 256
mkarlsso 0:8dbd6bd9167f 257 //If anything changed, we write the new values to the serial port (this can be turned off
mkarlsso 0:8dbd6bd9167f 258 //with broadCastStateChanges)
mkarlsso 0:8dbd6bd9167f 259 if ( (digitalInChanged||digitalOutChanged) && broadCastStateChanges) {
mkarlsso 0:8dbd6bd9167f 260 textDisplay << changeTime << " " << currentDIOstate[0] << " " << currentDIOstate[1] << "\r\n";
mkarlsso 0:8dbd6bd9167f 261
mkarlsso 0:8dbd6bd9167f 262 /*
mkarlsso 0:8dbd6bd9167f 263 timeConvert << changeTime; //broadcast the earliest timestamp when a change occured
mkarlsso 0:8dbd6bd9167f 264 //stateConvert << currentDIOstate[0] << " " << currentDIOstate[1];
mkarlsso 0:8dbd6bd9167f 265 stateConvert << currentDIOstate[0] << " " << currentDIOstate[1] << " ";
mkarlsso 0:8dbd6bd9167f 266
mkarlsso 0:8dbd6bd9167f 267 textDisplay.send(timeConvert.str() + " " + stateConvert.str() + "\r\n");
mkarlsso 0:8dbd6bd9167f 268 timeConvert.clear();
mkarlsso 0:8dbd6bd9167f 269 timeConvert.seekp(0);
mkarlsso 0:8dbd6bd9167f 270 stateConvert.clear();
mkarlsso 0:8dbd6bd9167f 271 stateConvert.seekp(0);
mkarlsso 0:8dbd6bd9167f 272 */
mkarlsso 0:8dbd6bd9167f 273 digitalInChanged = false;
mkarlsso 0:8dbd6bd9167f 274 digitalOutChanged = false;
mkarlsso 0:8dbd6bd9167f 275 }
mkarlsso 0:8dbd6bd9167f 276
mkarlsso 0:8dbd6bd9167f 277 //We use a buffer to send text via the serial port. For every loop
mkarlsso 0:8dbd6bd9167f 278 //in the main loop, we send one character if there is enything to send.
mkarlsso 0:8dbd6bd9167f 279 //This way, outputting text to serial does not hold up other time-sensitive
mkarlsso 0:8dbd6bd9167f 280 //things in the event queue
mkarlsso 0:8dbd6bd9167f 281 if ((textDisplay.unsentData) && (textStreaming)) {
mkarlsso 0:8dbd6bd9167f 282 pc->writeChar(textDisplay.getNextChar());
mkarlsso 0:8dbd6bd9167f 283 }
mkarlsso 0:8dbd6bd9167f 284
mkarlsso 0:8dbd6bd9167f 285 //Here is how we toggle between standalone and slave mode for the clock updating.
mkarlsso 0:8dbd6bd9167f 286 if (changeToSlave) {
mkarlsso 0:8dbd6bd9167f 287 hardware->setSlaveClock();
mkarlsso 0:8dbd6bd9167f 288 } else if (changeToStandAlone) {
mkarlsso 0:8dbd6bd9167f 289 hardware->setStandAloneClock();
mkarlsso 0:8dbd6bd9167f 290 }
mkarlsso 0:8dbd6bd9167f 291
mkarlsso 0:8dbd6bd9167f 292 //anything extra to do, defined by the hardware
mkarlsso 0:8dbd6bd9167f 293 hardware->mainLoopToDo();
mkarlsso 0:8dbd6bd9167f 294
mkarlsso 0:8dbd6bd9167f 295 //check for shortcut triggers
mkarlsso 0:8dbd6bd9167f 296 numTriggersToProcess = hardware->getPendingFunctionTriggers(shortcutTriggers);
mkarlsso 0:8dbd6bd9167f 297 for (int i = 0; i < numTriggersToProcess; i++) {
mkarlsso 3:d7b0a0890d96 298 textDisplay << "Trigger function " << shortcutTriggers[i]+1 << "\r\n";
mkarlsso 5:abee20c0bf2a 299 if ((shortcutTriggers[i] < NUMTRIGGERACTIONS) && functionSpotTaken[shortcutTriggers[i]] && functionEventArray[i]->isUsed) {
mkarlsso 3:d7b0a0890d96 300 //textDisplay << "Executing function array index " << shortcutTriggers[i] << "\r\n";
mkarlsso 3:d7b0a0890d96 301 functionEventArray[shortcutTriggers[i]]->execute();
mkarlsso 0:8dbd6bd9167f 302 }
mkarlsso 0:8dbd6bd9167f 303 }
mkarlsso 0:8dbd6bd9167f 304
mkarlsso 0:8dbd6bd9167f 305 }
mkarlsso 0:8dbd6bd9167f 306
mkarlsso 0:8dbd6bd9167f 307 }
mkarlsso 0:8dbd6bd9167f 308
mkarlsso 0:8dbd6bd9167f 309 void mainLoop::eraseBuffer() {
mkarlsso 0:8dbd6bd9167f 310 for (int i = 0; i < 256; i++) {
mkarlsso 0:8dbd6bd9167f 311 buffer[i] = NULL;
mkarlsso 0:8dbd6bd9167f 312 }
mkarlsso 0:8dbd6bd9167f 313 }
mkarlsso 0:8dbd6bd9167f 314
mkarlsso 0:8dbd6bd9167f 315 //-------------------------------------------------
mkarlsso 0:8dbd6bd9167f 316
mkarlsso 0:8dbd6bd9167f 317 //used to find the first available object in the staticly defined pools of memory
mkarlsso 0:8dbd6bd9167f 318 template<class T> T* findFirstUnUsed(T a[], const int arrayLength) {
mkarlsso 0:8dbd6bd9167f 319
mkarlsso 0:8dbd6bd9167f 320 T* returnPtr = NULL;
mkarlsso 0:8dbd6bd9167f 321 for (int i = 0; i < arrayLength; i++) {
mkarlsso 0:8dbd6bd9167f 322 if (!a[i].isUsed) {
mkarlsso 0:8dbd6bd9167f 323 returnPtr = &a[i];
mkarlsso 0:8dbd6bd9167f 324 break;
mkarlsso 0:8dbd6bd9167f 325 }
mkarlsso 0:8dbd6bd9167f 326 }
mkarlsso 0:8dbd6bd9167f 327 return returnPtr;
mkarlsso 0:8dbd6bd9167f 328 }
mkarlsso 0:8dbd6bd9167f 329
mkarlsso 0:8dbd6bd9167f 330 //used to count the number of available objects in the memory pool
mkarlsso 0:8dbd6bd9167f 331 template<class T> int countUnUsed(T a[], const int arrayLength) {
mkarlsso 0:8dbd6bd9167f 332
mkarlsso 0:8dbd6bd9167f 333 int count = 0;
mkarlsso 0:8dbd6bd9167f 334 for (int i = 0; i < arrayLength; i++) {
mkarlsso 0:8dbd6bd9167f 335 if (!a[i].isUsed) {
mkarlsso 0:8dbd6bd9167f 336 count++;
mkarlsso 0:8dbd6bd9167f 337 }
mkarlsso 0:8dbd6bd9167f 338 }
mkarlsso 0:8dbd6bd9167f 339 return count;
mkarlsso 0:8dbd6bd9167f 340 }
mkarlsso 0:8dbd6bd9167f 341
mkarlsso 0:8dbd6bd9167f 342
mkarlsso 0:8dbd6bd9167f 343 void displayMemoryLeft(void) {
mkarlsso 0:8dbd6bd9167f 344 textDisplay << "Available slots left in memory\r\n";
mkarlsso 0:8dbd6bd9167f 345 textDisplay << " Blocks: " << countUnUsed(eventBlock, NUMEVENTS) << "\r\n";
mkarlsso 0:8dbd6bd9167f 346 textDisplay << " Condition containers: " << countUnUsed(conditionBlock, NUMCONDITIONS) << "\r\n";
mkarlsso 0:8dbd6bd9167f 347 textDisplay << " Int compare conditions: " << countUnUsed(intCompareBlock, NUMINTCOMPARE) << "\r\n";
mkarlsso 0:8dbd6bd9167f 348 textDisplay << " Command containers: " << countUnUsed(actionBlock, NUMACTIONS) << "\r\n";
mkarlsso 0:8dbd6bd9167f 349 textDisplay << " Port commands: "<< countUnUsed(portMessageBlock, NUMPORTMESSAGES) << "\r\n";
mkarlsso 0:8dbd6bd9167f 350 textDisplay << " Integer operater commands: " << countUnUsed(intOperationBlock, NUMINTOPERATIONS) << "\r\n";
mkarlsso 0:8dbd6bd9167f 351 textDisplay << " Text display commands: " << countUnUsed(displayActionBlock, NUMDISPLAYACTIONS) << "\r\n";
mkarlsso 0:8dbd6bd9167f 352 }
mkarlsso 0:8dbd6bd9167f 353
mkarlsso 0:8dbd6bd9167f 354 bool isNumber(const std::string& s) {
mkarlsso 0:8dbd6bd9167f 355 std::string::const_iterator it = s.begin();
mkarlsso 0:8dbd6bd9167f 356 while (it != s.end() && isdigit(*it)) ++it;
mkarlsso 0:8dbd6bd9167f 357 return !s.empty() && it == s.end();
mkarlsso 0:8dbd6bd9167f 358 }
mkarlsso 0:8dbd6bd9167f 359
mkarlsso 0:8dbd6bd9167f 360 void tokenize(const string& str,
mkarlsso 0:8dbd6bd9167f 361 vector<string>& tokens,
mkarlsso 0:8dbd6bd9167f 362 const string& delimiters = " ")
mkarlsso 0:8dbd6bd9167f 363 {
mkarlsso 0:8dbd6bd9167f 364 // Skip delimiters at beginning.
mkarlsso 0:8dbd6bd9167f 365 string::size_type lastPos = str.find_first_not_of(delimiters, 0);
mkarlsso 0:8dbd6bd9167f 366 // Find first "non-delimiter".
mkarlsso 0:8dbd6bd9167f 367 string::size_type pos = str.find_first_of(delimiters, lastPos);
mkarlsso 0:8dbd6bd9167f 368
mkarlsso 0:8dbd6bd9167f 369 while (string::npos != pos || string::npos != lastPos)
mkarlsso 0:8dbd6bd9167f 370 {
mkarlsso 0:8dbd6bd9167f 371 // Found a token, add it to the vector.
mkarlsso 0:8dbd6bd9167f 372 tokens.push_back(str.substr(lastPos, pos - lastPos));
mkarlsso 0:8dbd6bd9167f 373 // Skip delimiters. Note the "not_of"
mkarlsso 0:8dbd6bd9167f 374 lastPos = str.find_first_not_of(delimiters, pos);
mkarlsso 0:8dbd6bd9167f 375 // Find next "non-delimiter"
mkarlsso 0:8dbd6bd9167f 376 pos = str.find_first_of(delimiters, lastPos);
mkarlsso 0:8dbd6bd9167f 377 }
mkarlsso 0:8dbd6bd9167f 378 }
mkarlsso 0:8dbd6bd9167f 379
mkarlsso 0:8dbd6bd9167f 380
mkarlsso 0:8dbd6bd9167f 381 digitalPort::digitalPort():
mkarlsso 0:8dbd6bd9167f 382 outPin(NULL),
mkarlsso 0:8dbd6bd9167f 383 inPin(NULL),
mkarlsso 0:8dbd6bd9167f 384 outState(0){
mkarlsso 0:8dbd6bd9167f 385
mkarlsso 0:8dbd6bd9167f 386 }
mkarlsso 0:8dbd6bd9167f 387
mkarlsso 0:8dbd6bd9167f 388 void digitalPort::init(sDigitalOut *DOP, sDigitalIn *DIP) {
mkarlsso 0:8dbd6bd9167f 389 outPin = DOP;
mkarlsso 0:8dbd6bd9167f 390 inPin = DIP;
mkarlsso 0:8dbd6bd9167f 391 lastInState = getDigitalIn();
mkarlsso 0:8dbd6bd9167f 392 inState = getDigitalIn();
mkarlsso 0:8dbd6bd9167f 393 lastChangeTime = 0;
mkarlsso 0:8dbd6bd9167f 394 lastOutChangeTime = 0;
mkarlsso 0:8dbd6bd9167f 395 lastChangeInterval = 0;
mkarlsso 0:8dbd6bd9167f 396 triggerUpEventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 397 triggerDownEventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 398 outStateChanged = false;
mkarlsso 0:8dbd6bd9167f 399
mkarlsso 0:8dbd6bd9167f 400 }
mkarlsso 0:8dbd6bd9167f 401
mkarlsso 0:8dbd6bd9167f 402
mkarlsso 0:8dbd6bd9167f 403 void digitalPort::setTriggerUpEvent(event* eventInput) {
mkarlsso 0:8dbd6bd9167f 404 if (triggerUpEventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 405 //delete triggerUpEventPtr;
mkarlsso 0:8dbd6bd9167f 406 triggerUpEventPtr->release();
mkarlsso 0:8dbd6bd9167f 407 }
mkarlsso 0:8dbd6bd9167f 408 triggerUpEventPtr = eventInput;
mkarlsso 0:8dbd6bd9167f 409 }
mkarlsso 0:8dbd6bd9167f 410
mkarlsso 0:8dbd6bd9167f 411 void digitalPort::setTriggerDownEvent(event* eventInput) {
mkarlsso 0:8dbd6bd9167f 412 if (triggerDownEventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 413 //delete triggerDownEventPtr;
mkarlsso 0:8dbd6bd9167f 414 triggerDownEventPtr->release();
mkarlsso 0:8dbd6bd9167f 415
mkarlsso 0:8dbd6bd9167f 416 }
mkarlsso 0:8dbd6bd9167f 417 triggerDownEventPtr = eventInput;
mkarlsso 0:8dbd6bd9167f 418 }
mkarlsso 0:8dbd6bd9167f 419
mkarlsso 0:8dbd6bd9167f 420
mkarlsso 0:8dbd6bd9167f 421 int digitalPort::getDigitalIn() {
mkarlsso 0:8dbd6bd9167f 422 return inPin->read();
mkarlsso 0:8dbd6bd9167f 423 }
mkarlsso 0:8dbd6bd9167f 424
mkarlsso 0:8dbd6bd9167f 425
mkarlsso 0:8dbd6bd9167f 426 void digitalPort::setDigitalOut(int outVal) {
mkarlsso 0:8dbd6bd9167f 427 if (outVal == -1) {
mkarlsso 0:8dbd6bd9167f 428 outVal = 1-outState;
mkarlsso 0:8dbd6bd9167f 429 }
mkarlsso 0:8dbd6bd9167f 430 outPin->write(outVal);
mkarlsso 0:8dbd6bd9167f 431 if (outState != outVal) {
mkarlsso 0:8dbd6bd9167f 432 outStateChanged = true;
mkarlsso 0:8dbd6bd9167f 433 lastOutChangeTime = timeKeeper;
mkarlsso 0:8dbd6bd9167f 434 }
mkarlsso 0:8dbd6bd9167f 435 outState = outVal;
mkarlsso 0:8dbd6bd9167f 436 }
mkarlsso 0:8dbd6bd9167f 437
mkarlsso 0:8dbd6bd9167f 438 //called when a digital in gets triggered
mkarlsso 0:8dbd6bd9167f 439 /*
mkarlsso 0:8dbd6bd9167f 440 void digitalPort::addStateChange(int newState, uint32_t timeStamp) {
mkarlsso 0:8dbd6bd9167f 441
mkarlsso 0:8dbd6bd9167f 442 if ((newState == 0) && (!lastDownEvent.triggered)){
mkarlsso 0:8dbd6bd9167f 443 lastDownEvent.timeStamp = timeStamp;
mkarlsso 0:8dbd6bd9167f 444 lastDownEvent.triggered = true;
mkarlsso 0:8dbd6bd9167f 445 } else if ((newState == 1) && (!lastUpEvent.triggered)) {
mkarlsso 0:8dbd6bd9167f 446 lastUpEvent.timeStamp = timeStamp;
mkarlsso 0:8dbd6bd9167f 447 lastUpEvent.triggered = true;
mkarlsso 0:8dbd6bd9167f 448 }
mkarlsso 0:8dbd6bd9167f 449 }*/
mkarlsso 0:8dbd6bd9167f 450
mkarlsso 0:8dbd6bd9167f 451 bool digitalPort::update() {
mkarlsso 0:8dbd6bd9167f 452
mkarlsso 0:8dbd6bd9167f 453 bool changed = false;
mkarlsso 2:35266b266eaa 454 bool execUp = false;
mkarlsso 2:35266b266eaa 455 bool execDown = false;
mkarlsso 0:8dbd6bd9167f 456 if ((timeKeeper - lastChangeTime) > 1) { //prevents flutter triggers when button is pressed
mkarlsso 0:8dbd6bd9167f 457
mkarlsso 0:8dbd6bd9167f 458 //changed = (lastInState != inState);
mkarlsso 0:8dbd6bd9167f 459
mkarlsso 0:8dbd6bd9167f 460 changed = (inPin->lastUpEvent.triggered || inPin->lastDownEvent.triggered);
mkarlsso 0:8dbd6bd9167f 461 if (changed) {
mkarlsso 2:35266b266eaa 462 inPin->setUpdate(true); //Once we get the state of the pin, we buffer any pin changes until we are done checking
mkarlsso 2:35266b266eaa 463
mkarlsso 0:8dbd6bd9167f 464 inState = getDigitalIn();
mkarlsso 0:8dbd6bd9167f 465
mkarlsso 0:8dbd6bd9167f 466 //We need to ignore flutter when levers/beam breaks are triggered. So
mkarlsso 0:8dbd6bd9167f 467 //if the current state if different than the last logged state, we only
mkarlsso 0:8dbd6bd9167f 468 //consider the first edge that brough us to the current state
mkarlsso 0:8dbd6bd9167f 469 if (lastInState != inState) {
mkarlsso 0:8dbd6bd9167f 470
mkarlsso 0:8dbd6bd9167f 471 if (inState == 1) {
mkarlsso 0:8dbd6bd9167f 472
mkarlsso 0:8dbd6bd9167f 473 lastChangeInterval = inPin->lastUpEvent.timeStamp - lastChangeTime;
mkarlsso 0:8dbd6bd9167f 474 lastChangeTime = inPin->lastUpEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 475
mkarlsso 0:8dbd6bd9167f 476 /*
mkarlsso 0:8dbd6bd9167f 477 if (inPin->lastUpEvent.triggered) {
mkarlsso 0:8dbd6bd9167f 478 //there were hardware triggers since the last main loop. We use that time
mkarlsso 0:8dbd6bd9167f 479 lastChangeInterval = inPin->lastUpEvent.timeStamp - lastChangeTime;
mkarlsso 0:8dbd6bd9167f 480 lastChangeTime = inPin->lastUpEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 481 } else {
mkarlsso 0:8dbd6bd9167f 482 //otherwise we use the current time
mkarlsso 0:8dbd6bd9167f 483 lastChangeInterval = timeKeeper - lastChangeTime;
mkarlsso 0:8dbd6bd9167f 484 lastChangeTime = timeKeeper;
mkarlsso 0:8dbd6bd9167f 485 }
mkarlsso 0:8dbd6bd9167f 486 */
mkarlsso 5:abee20c0bf2a 487 if (triggerUpEventPtr != NULL && triggerUpEventPtr->isUsed) {triggerUpEventPtr->execute();}
mkarlsso 0:8dbd6bd9167f 488 } else if (inState == 0) {
mkarlsso 0:8dbd6bd9167f 489
mkarlsso 0:8dbd6bd9167f 490 lastChangeInterval = inPin->lastDownEvent.timeStamp - lastChangeTime;
mkarlsso 0:8dbd6bd9167f 491 lastChangeTime = inPin->lastDownEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 492
mkarlsso 0:8dbd6bd9167f 493 /*
mkarlsso 0:8dbd6bd9167f 494 if (inPin->lastDownEvent.triggered) {
mkarlsso 0:8dbd6bd9167f 495 lastChangeInterval = inPin->lastDownEvent.timeStamp - lastChangeTime;
mkarlsso 0:8dbd6bd9167f 496 lastChangeTime = inPin->lastDownEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 497 } else {
mkarlsso 0:8dbd6bd9167f 498 lastChangeInterval = timeKeeper - lastChangeTime;
mkarlsso 0:8dbd6bd9167f 499 lastChangeTime = timeKeeper;
mkarlsso 0:8dbd6bd9167f 500 }*/
mkarlsso 0:8dbd6bd9167f 501
mkarlsso 5:abee20c0bf2a 502 if (triggerDownEventPtr != NULL && triggerDownEventPtr->isUsed){triggerDownEventPtr->execute();}
mkarlsso 0:8dbd6bd9167f 503 }
mkarlsso 0:8dbd6bd9167f 504 } else if (lastInState == inState) {
mkarlsso 0:8dbd6bd9167f 505
mkarlsso 0:8dbd6bd9167f 506 //Both up and down triggers must have happened, so we consider both
mkarlsso 0:8dbd6bd9167f 507 if (inState == 1) {
mkarlsso 0:8dbd6bd9167f 508
mkarlsso 0:8dbd6bd9167f 509 lastChangeInterval = inPin->lastUpEvent.timeStamp - inPin->lastDownEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 510 lastChangeTime = inPin->lastUpEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 511
mkarlsso 5:abee20c0bf2a 512 if (triggerDownEventPtr != NULL && triggerDownEventPtr->isUsed) {triggerDownEventPtr->execute();}
mkarlsso 5:abee20c0bf2a 513 if (triggerUpEventPtr != NULL && triggerUpEventPtr->isUsed) {triggerUpEventPtr->execute();}
mkarlsso 0:8dbd6bd9167f 514 } else if (inState == 0) {
mkarlsso 0:8dbd6bd9167f 515
mkarlsso 0:8dbd6bd9167f 516 lastChangeInterval = inPin->lastDownEvent.timeStamp - inPin->lastUpEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 517 lastChangeTime = inPin->lastDownEvent.timeStamp;
mkarlsso 0:8dbd6bd9167f 518
mkarlsso 5:abee20c0bf2a 519 if (triggerUpEventPtr != NULL && triggerUpEventPtr->isUsed) {triggerUpEventPtr->execute();}
mkarlsso 5:abee20c0bf2a 520 if (triggerDownEventPtr != NULL && triggerDownEventPtr->isUsed) {triggerDownEventPtr->execute();}
mkarlsso 0:8dbd6bd9167f 521 }
mkarlsso 0:8dbd6bd9167f 522 }
mkarlsso 3:d7b0a0890d96 523
mkarlsso 2:35266b266eaa 524 lastInState = inState;
mkarlsso 2:35266b266eaa 525 inPin->lastUpEvent.triggered = false;
mkarlsso 2:35266b266eaa 526 inPin->lastDownEvent.triggered = false;
mkarlsso 3:d7b0a0890d96 527
mkarlsso 2:35266b266eaa 528 inPin->setUpdate(false); //This also checks if there were any buffered changes that occured
mkarlsso 0:8dbd6bd9167f 529
mkarlsso 3:d7b0a0890d96 530
mkarlsso 0:8dbd6bd9167f 531 }
mkarlsso 0:8dbd6bd9167f 532
mkarlsso 3:d7b0a0890d96 533
mkarlsso 0:8dbd6bd9167f 534
mkarlsso 0:8dbd6bd9167f 535 }
mkarlsso 0:8dbd6bd9167f 536
mkarlsso 0:8dbd6bd9167f 537 return changed;
mkarlsso 0:8dbd6bd9167f 538 }
mkarlsso 0:8dbd6bd9167f 539
mkarlsso 0:8dbd6bd9167f 540 int digitalPort::getLastChangeState() {
mkarlsso 0:8dbd6bd9167f 541 return lastInState;
mkarlsso 0:8dbd6bd9167f 542 }
mkarlsso 0:8dbd6bd9167f 543 uint32_t digitalPort::getTimeSinceLastChange() {
mkarlsso 0:8dbd6bd9167f 544 return lastChangeInterval;
mkarlsso 0:8dbd6bd9167f 545
mkarlsso 0:8dbd6bd9167f 546 }
mkarlsso 0:8dbd6bd9167f 547
mkarlsso 0:8dbd6bd9167f 548 intVariable::intVariable():
mkarlsso 0:8dbd6bd9167f 549 value(0) {
mkarlsso 0:8dbd6bd9167f 550 isUsed = false;
mkarlsso 0:8dbd6bd9167f 551 }
mkarlsso 0:8dbd6bd9167f 552
mkarlsso 0:8dbd6bd9167f 553 intVariable::intVariable(std::string& tagInput, int initialValue):
mkarlsso 0:8dbd6bd9167f 554 value(initialValue)
mkarlsso 0:8dbd6bd9167f 555 {
mkarlsso 0:8dbd6bd9167f 556 strncpy(tag,tagInput.data(),MAXVARNAMESIZE);
mkarlsso 0:8dbd6bd9167f 557 isUsed = true;
mkarlsso 0:8dbd6bd9167f 558 }
mkarlsso 0:8dbd6bd9167f 559
mkarlsso 0:8dbd6bd9167f 560 void intVariable::set(std::string& tagInput, int initialValue) {
mkarlsso 0:8dbd6bd9167f 561 value = initialValue;
mkarlsso 0:8dbd6bd9167f 562 //tag = string(tagInput);
mkarlsso 0:8dbd6bd9167f 563 strncpy(tag,tagInput.data(),MAXVARNAMESIZE);
mkarlsso 0:8dbd6bd9167f 564 isUsed = true;
mkarlsso 0:8dbd6bd9167f 565 }
mkarlsso 0:8dbd6bd9167f 566
mkarlsso 0:8dbd6bd9167f 567 displayAction::displayAction():
mkarlsso 0:8dbd6bd9167f 568 dText(string("--------------------------------------------------")){
mkarlsso 0:8dbd6bd9167f 569 dVariable = NULL;
mkarlsso 0:8dbd6bd9167f 570 isUsed = false;
mkarlsso 0:8dbd6bd9167f 571 }
mkarlsso 0:8dbd6bd9167f 572
mkarlsso 0:8dbd6bd9167f 573 void displayAction::release() {
mkarlsso 0:8dbd6bd9167f 574 dText = "--------------------------------------------------";
mkarlsso 0:8dbd6bd9167f 575 dVariable = NULL;
mkarlsso 0:8dbd6bd9167f 576 isUsed = false;
mkarlsso 0:8dbd6bd9167f 577 }
mkarlsso 0:8dbd6bd9167f 578
mkarlsso 0:8dbd6bd9167f 579
mkarlsso 0:8dbd6bd9167f 580 void displayAction::set(int* variable, string varNameInput) {
mkarlsso 0:8dbd6bd9167f 581 dVariable = variable;
mkarlsso 0:8dbd6bd9167f 582 dText = varNameInput;
mkarlsso 0:8dbd6bd9167f 583 isUsed = true;
mkarlsso 0:8dbd6bd9167f 584
mkarlsso 0:8dbd6bd9167f 585 }
mkarlsso 0:8dbd6bd9167f 586
mkarlsso 0:8dbd6bd9167f 587 void displayAction::set(string text) {
mkarlsso 0:8dbd6bd9167f 588 dText = text;
mkarlsso 0:8dbd6bd9167f 589 dVariable = NULL;
mkarlsso 0:8dbd6bd9167f 590 isUsed = true;
mkarlsso 0:8dbd6bd9167f 591 }
mkarlsso 0:8dbd6bd9167f 592
mkarlsso 0:8dbd6bd9167f 593 void displayAction::execute() {
mkarlsso 0:8dbd6bd9167f 594
mkarlsso 0:8dbd6bd9167f 595 if (dVariable != NULL) {
mkarlsso 3:d7b0a0890d96 596 textDisplay << timeKeeper << " " << dText.c_str() << " = " << *dVariable << "\r\n";
mkarlsso 0:8dbd6bd9167f 597 } else {
mkarlsso 3:d7b0a0890d96 598 textDisplay << timeKeeper << " " << dText.c_str() << "\r\n";
mkarlsso 0:8dbd6bd9167f 599 }
mkarlsso 0:8dbd6bd9167f 600 }
mkarlsso 0:8dbd6bd9167f 601
mkarlsso 0:8dbd6bd9167f 602 triggerFunctionAction::triggerFunctionAction():
mkarlsso 0:8dbd6bd9167f 603 functionNum(0) {
mkarlsso 0:8dbd6bd9167f 604 isUsed = false;
mkarlsso 0:8dbd6bd9167f 605 }
mkarlsso 0:8dbd6bd9167f 606
mkarlsso 0:8dbd6bd9167f 607 triggerFunctionAction::triggerFunctionAction(int funcNum):
mkarlsso 0:8dbd6bd9167f 608 functionNum(funcNum) {
mkarlsso 0:8dbd6bd9167f 609
mkarlsso 0:8dbd6bd9167f 610 isUsed = true;
mkarlsso 0:8dbd6bd9167f 611
mkarlsso 0:8dbd6bd9167f 612 }
mkarlsso 0:8dbd6bd9167f 613
mkarlsso 0:8dbd6bd9167f 614 void triggerFunctionAction::set(int funcNum) {
mkarlsso 0:8dbd6bd9167f 615 functionNum = funcNum;
mkarlsso 0:8dbd6bd9167f 616 isUsed = true;
mkarlsso 0:8dbd6bd9167f 617 }
mkarlsso 0:8dbd6bd9167f 618
mkarlsso 0:8dbd6bd9167f 619 void triggerFunctionAction::execute() {
mkarlsso 0:8dbd6bd9167f 620
mkarlsso 5:abee20c0bf2a 621 if (functionSpotTaken[functionNum] && functionEventArray[functionNum]->isUsed) {
mkarlsso 0:8dbd6bd9167f 622 functionEventArray[functionNum]->execute();
mkarlsso 0:8dbd6bd9167f 623 }
mkarlsso 0:8dbd6bd9167f 624
mkarlsso 0:8dbd6bd9167f 625 }
mkarlsso 0:8dbd6bd9167f 626
mkarlsso 0:8dbd6bd9167f 627 void triggerFunctionAction::release() {
mkarlsso 0:8dbd6bd9167f 628 isUsed = false;
mkarlsso 0:8dbd6bd9167f 629 }
mkarlsso 0:8dbd6bd9167f 630
mkarlsso 0:8dbd6bd9167f 631
mkarlsso 0:8dbd6bd9167f 632
mkarlsso 0:8dbd6bd9167f 633 intCompare::intCompare():
mkarlsso 0:8dbd6bd9167f 634 port(NULL) {
mkarlsso 0:8dbd6bd9167f 635 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 636 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 637 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 638 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 639 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 640 isUsed = false;
mkarlsso 0:8dbd6bd9167f 641
mkarlsso 0:8dbd6bd9167f 642 }
mkarlsso 0:8dbd6bd9167f 643 intCompare::intCompare(digitalPort* portInput, const char* cmpString, int cmpValInput, int whichToUse):
mkarlsso 0:8dbd6bd9167f 644 port(portInput) {
mkarlsso 0:8dbd6bd9167f 645 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 646 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 647 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 648 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 649 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 650 isUsed = true;
mkarlsso 0:8dbd6bd9167f 651 if (whichToUse == 1) {
mkarlsso 0:8dbd6bd9167f 652 portValPtr = &port->inState;
mkarlsso 0:8dbd6bd9167f 653 } else {
mkarlsso 0:8dbd6bd9167f 654 portValPtr = &port->outState;
mkarlsso 0:8dbd6bd9167f 655 }
mkarlsso 0:8dbd6bd9167f 656 }
mkarlsso 0:8dbd6bd9167f 657
mkarlsso 0:8dbd6bd9167f 658 intCompare::intCompare(digitalPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse):
mkarlsso 0:8dbd6bd9167f 659 port(portInput),
mkarlsso 0:8dbd6bd9167f 660 cmpVal(cmpIntVarInput) {
mkarlsso 0:8dbd6bd9167f 661 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 662 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 663 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 664 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 665 isUsed = true;
mkarlsso 0:8dbd6bd9167f 666 if (whichToUse == 1) {
mkarlsso 0:8dbd6bd9167f 667 portValPtr = &port->inState;
mkarlsso 0:8dbd6bd9167f 668 } else {
mkarlsso 0:8dbd6bd9167f 669 portValPtr = &port->outState;
mkarlsso 0:8dbd6bd9167f 670 }
mkarlsso 0:8dbd6bd9167f 671 }
mkarlsso 0:8dbd6bd9167f 672
mkarlsso 0:8dbd6bd9167f 673 intCompare::intCompare(int* intVarInput, const char* cmpString, int* cmpIntVarInput):
mkarlsso 0:8dbd6bd9167f 674 cmpVal(cmpIntVarInput),
mkarlsso 0:8dbd6bd9167f 675 intVal(intVarInput) {
mkarlsso 0:8dbd6bd9167f 676 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 677 port = NULL;
mkarlsso 0:8dbd6bd9167f 678 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 679 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 680 isUsed = true;
mkarlsso 0:8dbd6bd9167f 681 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 682 }
mkarlsso 0:8dbd6bd9167f 683
mkarlsso 0:8dbd6bd9167f 684 intCompare::intCompare(int* intVarInput, const char* cmpString, int cmpValInput):
mkarlsso 0:8dbd6bd9167f 685 intVal(intVarInput){
mkarlsso 0:8dbd6bd9167f 686 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 687 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 688 port = NULL;
mkarlsso 0:8dbd6bd9167f 689 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 690 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 691 isUsed = true;
mkarlsso 0:8dbd6bd9167f 692 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 693 }
mkarlsso 0:8dbd6bd9167f 694
mkarlsso 0:8dbd6bd9167f 695 intCompare::intCompare(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput):
mkarlsso 0:8dbd6bd9167f 696 intVal(intVarInput) {
mkarlsso 0:8dbd6bd9167f 697 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 698 port = NULL;
mkarlsso 0:8dbd6bd9167f 699 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 700 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 701 intOp = cmpIntOpInput;
mkarlsso 0:8dbd6bd9167f 702 isUsed = true;
mkarlsso 0:8dbd6bd9167f 703 setPointer_operation(cmpString);
mkarlsso 0:8dbd6bd9167f 704 }
mkarlsso 0:8dbd6bd9167f 705
mkarlsso 0:8dbd6bd9167f 706 intCompare::intCompare(digitalPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse):
mkarlsso 0:8dbd6bd9167f 707 port(portInput) {
mkarlsso 0:8dbd6bd9167f 708 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 709 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 710 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 711 intOp = cmpIntOpInput;
mkarlsso 0:8dbd6bd9167f 712 setPointer_operation(cmpString);
mkarlsso 0:8dbd6bd9167f 713 isUsed = true;
mkarlsso 0:8dbd6bd9167f 714 if (whichToUse == 1) {
mkarlsso 0:8dbd6bd9167f 715 portValPtr = &port->inState;
mkarlsso 0:8dbd6bd9167f 716 } else {
mkarlsso 0:8dbd6bd9167f 717 portValPtr = &port->outState;
mkarlsso 0:8dbd6bd9167f 718 }
mkarlsso 0:8dbd6bd9167f 719 }
mkarlsso 0:8dbd6bd9167f 720
mkarlsso 0:8dbd6bd9167f 721
mkarlsso 0:8dbd6bd9167f 722
mkarlsso 0:8dbd6bd9167f 723 void intCompare::set(digitalPort* portInput, const char* cmpString, int cmpValInput, int whichToUse) {
mkarlsso 0:8dbd6bd9167f 724 port = portInput;
mkarlsso 0:8dbd6bd9167f 725 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 726 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 727 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 728 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 729 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 730 isUsed = true;
mkarlsso 0:8dbd6bd9167f 731 if (whichToUse == 1) {
mkarlsso 0:8dbd6bd9167f 732 portValPtr = &port->inState;
mkarlsso 0:8dbd6bd9167f 733 } else {
mkarlsso 0:8dbd6bd9167f 734 portValPtr = &port->outState;
mkarlsso 0:8dbd6bd9167f 735 }
mkarlsso 0:8dbd6bd9167f 736 }
mkarlsso 0:8dbd6bd9167f 737
mkarlsso 0:8dbd6bd9167f 738 void intCompare::set(digitalPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse) {
mkarlsso 0:8dbd6bd9167f 739 port = portInput;
mkarlsso 0:8dbd6bd9167f 740 cmpVal = cmpIntVarInput;
mkarlsso 0:8dbd6bd9167f 741 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 742 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 743 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 744 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 745 isUsed = true;
mkarlsso 0:8dbd6bd9167f 746 if (whichToUse == 1) {
mkarlsso 0:8dbd6bd9167f 747 portValPtr = &port->inState;
mkarlsso 0:8dbd6bd9167f 748 } else {
mkarlsso 0:8dbd6bd9167f 749 portValPtr = &port->outState;
mkarlsso 0:8dbd6bd9167f 750 }
mkarlsso 0:8dbd6bd9167f 751 }
mkarlsso 0:8dbd6bd9167f 752
mkarlsso 0:8dbd6bd9167f 753 void intCompare::set(int* intVarInput, const char* cmpString, int* cmpIntVarInput) {
mkarlsso 0:8dbd6bd9167f 754 cmpVal = cmpIntVarInput;
mkarlsso 0:8dbd6bd9167f 755 intVal = intVarInput;
mkarlsso 0:8dbd6bd9167f 756 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 757 port = NULL;
mkarlsso 0:8dbd6bd9167f 758 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 759 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 760 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 761 isUsed = true;
mkarlsso 0:8dbd6bd9167f 762 }
mkarlsso 0:8dbd6bd9167f 763
mkarlsso 0:8dbd6bd9167f 764 void intCompare::set(int* intVarInput, const char* cmpString, int cmpValInput) {
mkarlsso 0:8dbd6bd9167f 765 intVal = intVarInput;
mkarlsso 0:8dbd6bd9167f 766 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 767 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 768 port = NULL;
mkarlsso 0:8dbd6bd9167f 769 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 770 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 771 setPointer(cmpString);
mkarlsso 0:8dbd6bd9167f 772 isUsed = true;
mkarlsso 0:8dbd6bd9167f 773 }
mkarlsso 0:8dbd6bd9167f 774
mkarlsso 0:8dbd6bd9167f 775 void intCompare::set(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput) {
mkarlsso 0:8dbd6bd9167f 776 intVal = intVarInput;
mkarlsso 0:8dbd6bd9167f 777 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 778 port = NULL;
mkarlsso 0:8dbd6bd9167f 779 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 780 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 781 intOp = cmpIntOpInput;
mkarlsso 0:8dbd6bd9167f 782 setPointer_operation(cmpString);
mkarlsso 0:8dbd6bd9167f 783 isUsed = true;
mkarlsso 0:8dbd6bd9167f 784 }
mkarlsso 0:8dbd6bd9167f 785
mkarlsso 0:8dbd6bd9167f 786 void intCompare::set(digitalPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse) {
mkarlsso 0:8dbd6bd9167f 787 port = portInput;
mkarlsso 0:8dbd6bd9167f 788 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 789 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 790 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 791 intOp = cmpIntOpInput;
mkarlsso 0:8dbd6bd9167f 792 setPointer_operation(cmpString);
mkarlsso 0:8dbd6bd9167f 793 isUsed = true;
mkarlsso 0:8dbd6bd9167f 794 if (whichToUse == 1) {
mkarlsso 0:8dbd6bd9167f 795 portValPtr = &port->inState;
mkarlsso 0:8dbd6bd9167f 796 } else {
mkarlsso 0:8dbd6bd9167f 797 portValPtr = &port->outState;
mkarlsso 0:8dbd6bd9167f 798 }
mkarlsso 0:8dbd6bd9167f 799 }
mkarlsso 0:8dbd6bd9167f 800
mkarlsso 0:8dbd6bd9167f 801
mkarlsso 0:8dbd6bd9167f 802
mkarlsso 0:8dbd6bd9167f 803 intCompare::~intCompare() {
mkarlsso 0:8dbd6bd9167f 804 if (!cmpValGlobal) delete cmpVal; //we only delete the intCompare object if it was created locally
mkarlsso 0:8dbd6bd9167f 805 delete intOp;
mkarlsso 0:8dbd6bd9167f 806 }
mkarlsso 0:8dbd6bd9167f 807
mkarlsso 0:8dbd6bd9167f 808 void intCompare::release() {
mkarlsso 0:8dbd6bd9167f 809 if (!cmpValGlobal) delete cmpVal; //we only delete the intCompare object if it was created locally
mkarlsso 0:8dbd6bd9167f 810 if (intOp != NULL) {
mkarlsso 0:8dbd6bd9167f 811 intOp->release();
mkarlsso 0:8dbd6bd9167f 812 }
mkarlsso 0:8dbd6bd9167f 813 port = NULL;
mkarlsso 0:8dbd6bd9167f 814 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 815 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 816 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 817 intOp = NULL;
mkarlsso 0:8dbd6bd9167f 818 portValPtr = NULL;
mkarlsso 0:8dbd6bd9167f 819 isUsed = false;
mkarlsso 0:8dbd6bd9167f 820 }
mkarlsso 0:8dbd6bd9167f 821
mkarlsso 0:8dbd6bd9167f 822
mkarlsso 0:8dbd6bd9167f 823 void intCompare::setPointer(const char* cmpString) {
mkarlsso 0:8dbd6bd9167f 824 if (strcmp(cmpString, ">") == 0) {
mkarlsso 0:8dbd6bd9167f 825 isTruePtr = &intCompare::greaterThan;
mkarlsso 0:8dbd6bd9167f 826 }else if (strcmp(cmpString, ">=") == 0) {
mkarlsso 0:8dbd6bd9167f 827 isTruePtr = &intCompare::greaterOrEqual;
mkarlsso 0:8dbd6bd9167f 828 }else if (strcmp(cmpString, "<") == 0) {
mkarlsso 0:8dbd6bd9167f 829 isTruePtr = &intCompare::lessThan;
mkarlsso 0:8dbd6bd9167f 830 }else if (strcmp(cmpString, "<=") == 0) {
mkarlsso 0:8dbd6bd9167f 831 isTruePtr = &intCompare::lessOrEqual;
mkarlsso 0:8dbd6bd9167f 832 }else if (strcmp(cmpString, "==") == 0) {
mkarlsso 0:8dbd6bd9167f 833 isTruePtr = &intCompare::equal;
mkarlsso 0:8dbd6bd9167f 834 }else if (strcmp(cmpString, "!=") == 0) {
mkarlsso 0:8dbd6bd9167f 835 isTruePtr = &intCompare::notEqual;
mkarlsso 0:8dbd6bd9167f 836 }
mkarlsso 0:8dbd6bd9167f 837 }
mkarlsso 0:8dbd6bd9167f 838
mkarlsso 0:8dbd6bd9167f 839 void intCompare::setPointer_operation(const char* cmpString) {
mkarlsso 0:8dbd6bd9167f 840 if (strcmp(cmpString, ">") == 0) {
mkarlsso 0:8dbd6bd9167f 841 isTruePtr = &intCompare::greaterThan_op;
mkarlsso 0:8dbd6bd9167f 842 }else if (strcmp(cmpString, ">=") == 0) {
mkarlsso 0:8dbd6bd9167f 843 isTruePtr = &intCompare::greaterOrEqual_op;
mkarlsso 0:8dbd6bd9167f 844 }else if (strcmp(cmpString, "<") == 0) {
mkarlsso 0:8dbd6bd9167f 845 isTruePtr = &intCompare::lessThan_op;
mkarlsso 0:8dbd6bd9167f 846 }else if (strcmp(cmpString, "<=") == 0) {
mkarlsso 0:8dbd6bd9167f 847 isTruePtr = &intCompare::lessOrEqual_op;
mkarlsso 0:8dbd6bd9167f 848 }else if (strcmp(cmpString, "==") == 0) {
mkarlsso 0:8dbd6bd9167f 849 isTruePtr = &intCompare::equal_op;
mkarlsso 0:8dbd6bd9167f 850 }else if (strcmp(cmpString, "!=") == 0) {
mkarlsso 0:8dbd6bd9167f 851 isTruePtr = &intCompare::notEqual_op;
mkarlsso 0:8dbd6bd9167f 852 }
mkarlsso 0:8dbd6bd9167f 853 }
mkarlsso 0:8dbd6bd9167f 854
mkarlsso 0:8dbd6bd9167f 855 bool intCompare::isTrue() {
mkarlsso 0:8dbd6bd9167f 856 return (this->*isTruePtr)();
mkarlsso 0:8dbd6bd9167f 857
mkarlsso 0:8dbd6bd9167f 858 }
mkarlsso 0:8dbd6bd9167f 859
mkarlsso 0:8dbd6bd9167f 860 bool intCompare::notEqual() {
mkarlsso 0:8dbd6bd9167f 861 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 862 return (*intVal != *cmpVal);
mkarlsso 0:8dbd6bd9167f 863 } else {
mkarlsso 0:8dbd6bd9167f 864 return (*portValPtr != *cmpVal);
mkarlsso 0:8dbd6bd9167f 865 }
mkarlsso 0:8dbd6bd9167f 866 }
mkarlsso 0:8dbd6bd9167f 867
mkarlsso 0:8dbd6bd9167f 868 bool intCompare::greaterThan() {
mkarlsso 0:8dbd6bd9167f 869 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 870 return (*intVal > *cmpVal);
mkarlsso 0:8dbd6bd9167f 871 } else {
mkarlsso 0:8dbd6bd9167f 872 return (*portValPtr > *cmpVal);
mkarlsso 0:8dbd6bd9167f 873 }
mkarlsso 0:8dbd6bd9167f 874 }
mkarlsso 0:8dbd6bd9167f 875
mkarlsso 0:8dbd6bd9167f 876 bool intCompare::greaterOrEqual() {
mkarlsso 0:8dbd6bd9167f 877 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 878 return (*intVal >= *cmpVal);
mkarlsso 0:8dbd6bd9167f 879 } else {
mkarlsso 0:8dbd6bd9167f 880 return (*portValPtr >= *cmpVal);
mkarlsso 0:8dbd6bd9167f 881 }
mkarlsso 0:8dbd6bd9167f 882 }
mkarlsso 0:8dbd6bd9167f 883
mkarlsso 0:8dbd6bd9167f 884 bool intCompare::lessThan() {
mkarlsso 0:8dbd6bd9167f 885 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 886 return (*intVal < *cmpVal);
mkarlsso 0:8dbd6bd9167f 887 } else {
mkarlsso 0:8dbd6bd9167f 888 return (*portValPtr < *cmpVal);
mkarlsso 0:8dbd6bd9167f 889 }
mkarlsso 0:8dbd6bd9167f 890 }
mkarlsso 0:8dbd6bd9167f 891
mkarlsso 0:8dbd6bd9167f 892 bool intCompare::lessOrEqual() {
mkarlsso 0:8dbd6bd9167f 893 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 894 return (*intVal <= *cmpVal);
mkarlsso 0:8dbd6bd9167f 895 } else {
mkarlsso 0:8dbd6bd9167f 896 return (*portValPtr <= *cmpVal);
mkarlsso 0:8dbd6bd9167f 897 }
mkarlsso 0:8dbd6bd9167f 898 }
mkarlsso 0:8dbd6bd9167f 899
mkarlsso 0:8dbd6bd9167f 900 bool intCompare::equal() {
mkarlsso 0:8dbd6bd9167f 901 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 902 return (*intVal == *cmpVal);
mkarlsso 0:8dbd6bd9167f 903 } else {
mkarlsso 0:8dbd6bd9167f 904 return (*portValPtr == *cmpVal);
mkarlsso 0:8dbd6bd9167f 905 }
mkarlsso 0:8dbd6bd9167f 906 }
mkarlsso 0:8dbd6bd9167f 907
mkarlsso 0:8dbd6bd9167f 908 bool intCompare::notEqual_op() {
mkarlsso 0:8dbd6bd9167f 909 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 910 return (*intVal != intOp->execute());
mkarlsso 0:8dbd6bd9167f 911 } else {
mkarlsso 0:8dbd6bd9167f 912 return (*portValPtr != intOp->execute());
mkarlsso 0:8dbd6bd9167f 913 }
mkarlsso 0:8dbd6bd9167f 914 }
mkarlsso 0:8dbd6bd9167f 915
mkarlsso 0:8dbd6bd9167f 916 bool intCompare::greaterThan_op() {
mkarlsso 0:8dbd6bd9167f 917 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 918 return (*intVal > intOp->execute());
mkarlsso 0:8dbd6bd9167f 919 } else {
mkarlsso 0:8dbd6bd9167f 920 return (*portValPtr > intOp->execute());
mkarlsso 0:8dbd6bd9167f 921 }
mkarlsso 0:8dbd6bd9167f 922 }
mkarlsso 0:8dbd6bd9167f 923
mkarlsso 0:8dbd6bd9167f 924 bool intCompare::greaterOrEqual_op() {
mkarlsso 0:8dbd6bd9167f 925 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 926 return (*intVal >= intOp->execute());
mkarlsso 0:8dbd6bd9167f 927 } else {
mkarlsso 0:8dbd6bd9167f 928 return (*portValPtr >= intOp->execute());
mkarlsso 0:8dbd6bd9167f 929 }
mkarlsso 0:8dbd6bd9167f 930 }
mkarlsso 0:8dbd6bd9167f 931
mkarlsso 0:8dbd6bd9167f 932 bool intCompare::lessThan_op() {
mkarlsso 0:8dbd6bd9167f 933 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 934 return (*intVal < intOp->execute());
mkarlsso 0:8dbd6bd9167f 935 } else {
mkarlsso 0:8dbd6bd9167f 936 return (*portValPtr < intOp->execute());
mkarlsso 0:8dbd6bd9167f 937 }
mkarlsso 0:8dbd6bd9167f 938 }
mkarlsso 0:8dbd6bd9167f 939
mkarlsso 0:8dbd6bd9167f 940 bool intCompare::lessOrEqual_op() {
mkarlsso 0:8dbd6bd9167f 941 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 942 return (*intVal <= intOp->execute());
mkarlsso 0:8dbd6bd9167f 943 } else {
mkarlsso 0:8dbd6bd9167f 944 return (*portValPtr <= intOp->execute());
mkarlsso 0:8dbd6bd9167f 945 }
mkarlsso 0:8dbd6bd9167f 946 }
mkarlsso 0:8dbd6bd9167f 947
mkarlsso 0:8dbd6bd9167f 948 bool intCompare::equal_op() {
mkarlsso 0:8dbd6bd9167f 949 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 950 return (*intVal == intOp->execute());
mkarlsso 0:8dbd6bd9167f 951 } else {
mkarlsso 0:8dbd6bd9167f 952 return (*portValPtr == intOp->execute());
mkarlsso 0:8dbd6bd9167f 953 }
mkarlsso 0:8dbd6bd9167f 954 }
mkarlsso 0:8dbd6bd9167f 955
mkarlsso 0:8dbd6bd9167f 956 intOperation::intOperation():
mkarlsso 0:8dbd6bd9167f 957 randHigh(-1) {
mkarlsso 0:8dbd6bd9167f 958 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 959 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 960 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 961 executePtr = NULL;
mkarlsso 0:8dbd6bd9167f 962 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 963 isUsed = false;
mkarlsso 0:8dbd6bd9167f 964 isClockAssign = false;
mkarlsso 0:8dbd6bd9167f 965 inputsFlipped = false;
mkarlsso 0:8dbd6bd9167f 966
mkarlsso 0:8dbd6bd9167f 967 }
mkarlsso 0:8dbd6bd9167f 968
mkarlsso 0:8dbd6bd9167f 969 /*
mkarlsso 0:8dbd6bd9167f 970 intOperation::intOperation(int randParam, const char* cmpString, int cmpValInput):
mkarlsso 0:8dbd6bd9167f 971 randHigh(randParam) {
mkarlsso 0:8dbd6bd9167f 972 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 973 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 974 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 975 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 976 isUsed = true;
mkarlsso 0:8dbd6bd9167f 977 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 978 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 979 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 980 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 981 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 0:8dbd6bd9167f 982 executePtr = &intOperation::addAndStore;
mkarlsso 0:8dbd6bd9167f 983 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 0:8dbd6bd9167f 984 executePtr = &intOperation::subtractAndStore;
mkarlsso 0:8dbd6bd9167f 985 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 986 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 987 }
mkarlsso 0:8dbd6bd9167f 988
mkarlsso 0:8dbd6bd9167f 989 }
mkarlsso 0:8dbd6bd9167f 990
mkarlsso 0:8dbd6bd9167f 991 intOperation::intOperation(int randParam, const char* cmpString, int* cmpIntVarInput):
mkarlsso 0:8dbd6bd9167f 992 randHigh(randParam),
mkarlsso 0:8dbd6bd9167f 993 cmpVal(cmpIntVarInput) {
mkarlsso 0:8dbd6bd9167f 994 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 995 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 996 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 997 isUsed = true;
mkarlsso 0:8dbd6bd9167f 998 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 999 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1000 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1001 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1002 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 0:8dbd6bd9167f 1003 executePtr = &intOperation::addAndStore;
mkarlsso 0:8dbd6bd9167f 1004 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 0:8dbd6bd9167f 1005 executePtr = &intOperation::subtractAndStore;
mkarlsso 0:8dbd6bd9167f 1006 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1007 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1008 }
mkarlsso 0:8dbd6bd9167f 1009 }
mkarlsso 0:8dbd6bd9167f 1010
mkarlsso 0:8dbd6bd9167f 1011 intOperation::intOperation(int* intVarInput, const char* cmpString, int cmpValInput):
mkarlsso 0:8dbd6bd9167f 1012 intVal(intVarInput) {
mkarlsso 0:8dbd6bd9167f 1013 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 1014 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1015 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1016 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 1017 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1018 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1019 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1020 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1021 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1022 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 0:8dbd6bd9167f 1023 executePtr = &intOperation::addAndStore;
mkarlsso 0:8dbd6bd9167f 1024 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 0:8dbd6bd9167f 1025 executePtr = &intOperation::subtractAndStore;
mkarlsso 0:8dbd6bd9167f 1026 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1027 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1028 }
mkarlsso 0:8dbd6bd9167f 1029 }
mkarlsso 0:8dbd6bd9167f 1030
mkarlsso 0:8dbd6bd9167f 1031 intOperation::intOperation(int* intVarInput, const char* cmpString, int* cmpIntVarInput):
mkarlsso 0:8dbd6bd9167f 1032 cmpVal(cmpIntVarInput),
mkarlsso 0:8dbd6bd9167f 1033 intVal(intVarInput) {
mkarlsso 0:8dbd6bd9167f 1034 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1035 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1036 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 1037 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1038 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1039 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1040 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1041 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1042 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 0:8dbd6bd9167f 1043 executePtr = &intOperation::addAndStore;
mkarlsso 0:8dbd6bd9167f 1044 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 0:8dbd6bd9167f 1045 executePtr = &intOperation::subtractAndStore;
mkarlsso 0:8dbd6bd9167f 1046 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1047 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1048 }
mkarlsso 0:8dbd6bd9167f 1049 }
mkarlsso 0:8dbd6bd9167f 1050
mkarlsso 0:8dbd6bd9167f 1051 intOperation::intOperation(int* intVarInput, intOperation* operationInput):
mkarlsso 0:8dbd6bd9167f 1052 intVal(intVarInput) {
mkarlsso 0:8dbd6bd9167f 1053 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 1054 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1055 opPtr = operationInput;
mkarlsso 0:8dbd6bd9167f 1056 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1057 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1058 }
mkarlsso 0:8dbd6bd9167f 1059 */
mkarlsso 0:8dbd6bd9167f 1060
mkarlsso 0:8dbd6bd9167f 1061 void intOperation::setRandOp(int randParam, const char* cmpString, int cmpValInput, bool flipped) {
mkarlsso 0:8dbd6bd9167f 1062 randHigh = randParam;
mkarlsso 0:8dbd6bd9167f 1063 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 1064 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 1065 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1066 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 1067 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1068 inputsFlipped = flipped;
mkarlsso 0:8dbd6bd9167f 1069 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1070 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1071 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1072 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1073 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1074 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1075 }
mkarlsso 0:8dbd6bd9167f 1076
mkarlsso 0:8dbd6bd9167f 1077 }
mkarlsso 0:8dbd6bd9167f 1078
mkarlsso 0:8dbd6bd9167f 1079 void intOperation::setRandOp(int randParam, const char* cmpString, int* cmpIntVarInput, bool flipped) {
mkarlsso 0:8dbd6bd9167f 1080 randHigh = randParam;
mkarlsso 0:8dbd6bd9167f 1081 cmpVal = cmpIntVarInput;
mkarlsso 0:8dbd6bd9167f 1082 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 1083 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1084 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 1085 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1086 inputsFlipped = flipped;
mkarlsso 0:8dbd6bd9167f 1087 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1088 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1089 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1090 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1091 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1092 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1093 }
mkarlsso 0:8dbd6bd9167f 1094 }
mkarlsso 0:8dbd6bd9167f 1095
mkarlsso 0:8dbd6bd9167f 1096 void intOperation::set(int* intVarInput, const char* cmpString, int cmpValInput) {
mkarlsso 0:8dbd6bd9167f 1097
mkarlsso 0:8dbd6bd9167f 1098 intVal = intVarInput;
mkarlsso 0:8dbd6bd9167f 1099 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 1100 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1101 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1102 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 1103 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1104 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1105 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1106 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1107 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1108 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 0:8dbd6bd9167f 1109 executePtr = &intOperation::addAndStore;
mkarlsso 0:8dbd6bd9167f 1110 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 0:8dbd6bd9167f 1111 executePtr = &intOperation::subtractAndStore;
mkarlsso 0:8dbd6bd9167f 1112 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1113 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1114 }
mkarlsso 0:8dbd6bd9167f 1115 }
mkarlsso 0:8dbd6bd9167f 1116
mkarlsso 0:8dbd6bd9167f 1117 void intOperation::set(int* intVarInput, const char* cmpString, int* cmpIntVarInput) {
mkarlsso 0:8dbd6bd9167f 1118 cmpVal = cmpIntVarInput;
mkarlsso 0:8dbd6bd9167f 1119 intVal =intVarInput;
mkarlsso 0:8dbd6bd9167f 1120 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1121 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1122 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 1123 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1124 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1125 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1126 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1127 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1128 }else if (strcmp(cmpString, "+=") == 0) {
mkarlsso 0:8dbd6bd9167f 1129 executePtr = &intOperation::addAndStore;
mkarlsso 0:8dbd6bd9167f 1130 }else if (strcmp(cmpString, "-=") == 0) {
mkarlsso 0:8dbd6bd9167f 1131 executePtr = &intOperation::subtractAndStore;
mkarlsso 0:8dbd6bd9167f 1132 }else if (strcmp(cmpString, "=") == 0) {
mkarlsso 0:8dbd6bd9167f 1133 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1134 }
mkarlsso 0:8dbd6bd9167f 1135 }
mkarlsso 0:8dbd6bd9167f 1136
mkarlsso 0:8dbd6bd9167f 1137 void intOperation::set(int* intVarInput, intOperation* operationInput) {
mkarlsso 0:8dbd6bd9167f 1138
mkarlsso 0:8dbd6bd9167f 1139 intVal = intVarInput;
mkarlsso 0:8dbd6bd9167f 1140 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 1141 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1142 opPtr = operationInput;
mkarlsso 0:8dbd6bd9167f 1143 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1144 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1145
mkarlsso 0:8dbd6bd9167f 1146 }
mkarlsso 0:8dbd6bd9167f 1147
mkarlsso 0:8dbd6bd9167f 1148 void intOperation::setClockOp(int* intVarInput) {
mkarlsso 0:8dbd6bd9167f 1149 //used to assign current clock to variable
mkarlsso 0:8dbd6bd9167f 1150 intVal = intVarInput;
mkarlsso 0:8dbd6bd9167f 1151 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 1152 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1153 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1154 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 1155 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1156 isClockAssign = true;
mkarlsso 0:8dbd6bd9167f 1157 executePtr = &intOperation::equals;
mkarlsso 0:8dbd6bd9167f 1158
mkarlsso 0:8dbd6bd9167f 1159 }
mkarlsso 0:8dbd6bd9167f 1160
mkarlsso 0:8dbd6bd9167f 1161 void intOperation::setClockOp(const char* cmpString, int cmpValInput, bool flip) {
mkarlsso 0:8dbd6bd9167f 1162 //used to add an integer to the current clock value
mkarlsso 0:8dbd6bd9167f 1163
mkarlsso 0:8dbd6bd9167f 1164 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 1165 cmpVal = new int(cmpValInput);
mkarlsso 0:8dbd6bd9167f 1166 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1167 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1168 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 1169 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1170 isClockAssign = true;
mkarlsso 0:8dbd6bd9167f 1171 inputsFlipped = flip;
mkarlsso 0:8dbd6bd9167f 1172 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1173 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1174 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1175 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1176 }
mkarlsso 0:8dbd6bd9167f 1177 }
mkarlsso 0:8dbd6bd9167f 1178
mkarlsso 0:8dbd6bd9167f 1179 void intOperation::setClockOp(const char* cmpString, int* cmpIntVarInput, bool flip) {
mkarlsso 0:8dbd6bd9167f 1180 //used to add a variable to the current clock value
mkarlsso 0:8dbd6bd9167f 1181
mkarlsso 0:8dbd6bd9167f 1182 cmpVal = cmpIntVarInput;
mkarlsso 0:8dbd6bd9167f 1183 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 1184 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1185 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1186 isClockAssign = true;
mkarlsso 0:8dbd6bd9167f 1187 cmpValGlobal = true;
mkarlsso 0:8dbd6bd9167f 1188 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1189 inputsFlipped = flip;
mkarlsso 0:8dbd6bd9167f 1190 if (strcmp(cmpString, "+") == 0) {
mkarlsso 0:8dbd6bd9167f 1191 executePtr = &intOperation::add;
mkarlsso 0:8dbd6bd9167f 1192 }else if (strcmp(cmpString, "-") == 0) {
mkarlsso 0:8dbd6bd9167f 1193 executePtr = &intOperation::subtract;
mkarlsso 0:8dbd6bd9167f 1194 }
mkarlsso 0:8dbd6bd9167f 1195 }
mkarlsso 0:8dbd6bd9167f 1196
mkarlsso 0:8dbd6bd9167f 1197
mkarlsso 0:8dbd6bd9167f 1198 intOperation::~intOperation() {
mkarlsso 0:8dbd6bd9167f 1199 if (!cmpValGlobal) delete cmpVal;
mkarlsso 0:8dbd6bd9167f 1200 delete opPtr;
mkarlsso 0:8dbd6bd9167f 1201 }
mkarlsso 0:8dbd6bd9167f 1202
mkarlsso 0:8dbd6bd9167f 1203 void intOperation::release() {
mkarlsso 0:8dbd6bd9167f 1204 if (!cmpValGlobal) delete cmpVal;
mkarlsso 0:8dbd6bd9167f 1205 if (opPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 1206 opPtr->release();
mkarlsso 0:8dbd6bd9167f 1207 }
mkarlsso 0:8dbd6bd9167f 1208 randHigh = -1;
mkarlsso 0:8dbd6bd9167f 1209 cmpVal = NULL;
mkarlsso 0:8dbd6bd9167f 1210 intVal = NULL;
mkarlsso 0:8dbd6bd9167f 1211 opPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1212 executePtr = NULL;
mkarlsso 0:8dbd6bd9167f 1213 isClockAssign = false;
mkarlsso 0:8dbd6bd9167f 1214 cmpValGlobal = false;
mkarlsso 0:8dbd6bd9167f 1215 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1216 }
mkarlsso 0:8dbd6bd9167f 1217
mkarlsso 0:8dbd6bd9167f 1218
mkarlsso 0:8dbd6bd9167f 1219 int intOperation::execute() {
mkarlsso 0:8dbd6bd9167f 1220
mkarlsso 0:8dbd6bd9167f 1221 return (this->*executePtr)();
mkarlsso 0:8dbd6bd9167f 1222
mkarlsso 0:8dbd6bd9167f 1223
mkarlsso 0:8dbd6bd9167f 1224 }
mkarlsso 0:8dbd6bd9167f 1225
mkarlsso 0:8dbd6bd9167f 1226 int intOperation::add() {
mkarlsso 0:8dbd6bd9167f 1227
mkarlsso 0:8dbd6bd9167f 1228 if ((intVal != NULL) && (!isClockAssign)) {
mkarlsso 0:8dbd6bd9167f 1229 return (*intVal + *cmpVal);
mkarlsso 0:8dbd6bd9167f 1230 } else if ((intVal == NULL) && (isClockAssign)) {
mkarlsso 0:8dbd6bd9167f 1231 return (timeKeeper + *cmpVal);
mkarlsso 0:8dbd6bd9167f 1232 } else {
mkarlsso 0:8dbd6bd9167f 1233 //srand(time(NULL));
mkarlsso 0:8dbd6bd9167f 1234 srand(timeKeeper);
mkarlsso 0:8dbd6bd9167f 1235 return (rand() % (randHigh+1)) + *cmpVal;
mkarlsso 0:8dbd6bd9167f 1236 //return (port->getState() + *cmpVal);
mkarlsso 0:8dbd6bd9167f 1237 }
mkarlsso 0:8dbd6bd9167f 1238 }
mkarlsso 0:8dbd6bd9167f 1239
mkarlsso 0:8dbd6bd9167f 1240 int intOperation::subtract() {
mkarlsso 0:8dbd6bd9167f 1241 if ((intVal != NULL) && (!isClockAssign)) {
mkarlsso 0:8dbd6bd9167f 1242 return (*intVal - *cmpVal);
mkarlsso 0:8dbd6bd9167f 1243 } else if ((intVal == NULL) && (isClockAssign)) {
mkarlsso 0:8dbd6bd9167f 1244 if (inputsFlipped) {
mkarlsso 0:8dbd6bd9167f 1245 return (*cmpVal-timeKeeper);
mkarlsso 0:8dbd6bd9167f 1246 } else {
mkarlsso 0:8dbd6bd9167f 1247 return (timeKeeper - *cmpVal);
mkarlsso 0:8dbd6bd9167f 1248 }
mkarlsso 0:8dbd6bd9167f 1249 } else {
mkarlsso 0:8dbd6bd9167f 1250 srand(timeKeeper);
mkarlsso 0:8dbd6bd9167f 1251 if (inputsFlipped) {
mkarlsso 0:8dbd6bd9167f 1252 return (*cmpVal-(rand() % (randHigh+1)));
mkarlsso 0:8dbd6bd9167f 1253 } else {
mkarlsso 0:8dbd6bd9167f 1254 return (rand() % (randHigh+1)) - *cmpVal;
mkarlsso 0:8dbd6bd9167f 1255 }
mkarlsso 0:8dbd6bd9167f 1256 //return (port->getState() - *cmpVal);
mkarlsso 0:8dbd6bd9167f 1257 }
mkarlsso 0:8dbd6bd9167f 1258 }
mkarlsso 0:8dbd6bd9167f 1259
mkarlsso 0:8dbd6bd9167f 1260 int intOperation::addAndStore() {
mkarlsso 0:8dbd6bd9167f 1261 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 1262 *intVal = *intVal + *cmpVal;
mkarlsso 0:8dbd6bd9167f 1263 return *intVal;
mkarlsso 0:8dbd6bd9167f 1264 }
mkarlsso 0:8dbd6bd9167f 1265 else {
mkarlsso 0:8dbd6bd9167f 1266
mkarlsso 0:8dbd6bd9167f 1267 //Doesn't happen
mkarlsso 0:8dbd6bd9167f 1268 return 0;
mkarlsso 0:8dbd6bd9167f 1269 //port->setState(port->getState() + *cmpVal);
mkarlsso 0:8dbd6bd9167f 1270 //return port->getState();
mkarlsso 0:8dbd6bd9167f 1271 }
mkarlsso 0:8dbd6bd9167f 1272
mkarlsso 0:8dbd6bd9167f 1273 }
mkarlsso 0:8dbd6bd9167f 1274
mkarlsso 0:8dbd6bd9167f 1275 int intOperation::subtractAndStore() {
mkarlsso 0:8dbd6bd9167f 1276 if (intVal != NULL) {
mkarlsso 0:8dbd6bd9167f 1277 *intVal = *intVal - *cmpVal;
mkarlsso 0:8dbd6bd9167f 1278 return *intVal;
mkarlsso 0:8dbd6bd9167f 1279 } else {
mkarlsso 0:8dbd6bd9167f 1280 //doesn't happen
mkarlsso 0:8dbd6bd9167f 1281 return 0;
mkarlsso 0:8dbd6bd9167f 1282 //port->setState(port->getState() - *cmpVal);
mkarlsso 0:8dbd6bd9167f 1283 //return port->getState();
mkarlsso 0:8dbd6bd9167f 1284 }
mkarlsso 0:8dbd6bd9167f 1285 }
mkarlsso 0:8dbd6bd9167f 1286
mkarlsso 0:8dbd6bd9167f 1287 int intOperation::equals() {
mkarlsso 0:8dbd6bd9167f 1288 if ((intVal != NULL) && (opPtr == NULL) && (!isClockAssign)) {
mkarlsso 0:8dbd6bd9167f 1289 *intVal = *cmpVal;
mkarlsso 0:8dbd6bd9167f 1290 return *intVal;
mkarlsso 0:8dbd6bd9167f 1291 } else if ((intVal != NULL) && (opPtr != NULL)) {
mkarlsso 0:8dbd6bd9167f 1292
mkarlsso 0:8dbd6bd9167f 1293 *intVal = opPtr->execute();
mkarlsso 0:8dbd6bd9167f 1294 return *intVal;
mkarlsso 0:8dbd6bd9167f 1295 } else if ((intVal != NULL) && (opPtr == NULL) && (isClockAssign)) {
mkarlsso 0:8dbd6bd9167f 1296 *intVal = timeKeeper; //assign the current time to the variable
mkarlsso 0:8dbd6bd9167f 1297 return *intVal;
mkarlsso 0:8dbd6bd9167f 1298 } else if ((cmpVal != NULL)&& (!isClockAssign)){
mkarlsso 0:8dbd6bd9167f 1299
mkarlsso 0:8dbd6bd9167f 1300 srand(timeKeeper+randomSeedCounter);
mkarlsso 0:8dbd6bd9167f 1301 randomSeedCounter++; //for seeding the next rand call, just in case it happens before the clock advances
mkarlsso 0:8dbd6bd9167f 1302 *cmpVal = (rand() % (randHigh+1)); //this is how we assign a random number to variable
mkarlsso 0:8dbd6bd9167f 1303 return *cmpVal;
mkarlsso 0:8dbd6bd9167f 1304
mkarlsso 0:8dbd6bd9167f 1305 }
mkarlsso 0:8dbd6bd9167f 1306 return -1;
mkarlsso 0:8dbd6bd9167f 1307 }
mkarlsso 0:8dbd6bd9167f 1308
mkarlsso 0:8dbd6bd9167f 1309 condition::condition() {
mkarlsso 0:8dbd6bd9167f 1310 intCmp = NULL;
mkarlsso 0:8dbd6bd9167f 1311 conditionPtrs[0] = NULL;
mkarlsso 0:8dbd6bd9167f 1312 conditionPtrs[1] = NULL;
mkarlsso 0:8dbd6bd9167f 1313 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1314 conditionType = ARITHMATIC_CONDITION;
mkarlsso 0:8dbd6bd9167f 1315 }
mkarlsso 0:8dbd6bd9167f 1316
mkarlsso 0:8dbd6bd9167f 1317 condition::condition(intCompare* compareInput) {
mkarlsso 0:8dbd6bd9167f 1318
mkarlsso 0:8dbd6bd9167f 1319 intCmp = compareInput;
mkarlsso 0:8dbd6bd9167f 1320 conditionPtrs[0] = NULL;
mkarlsso 0:8dbd6bd9167f 1321 conditionPtrs[1] = NULL;
mkarlsso 0:8dbd6bd9167f 1322
mkarlsso 0:8dbd6bd9167f 1323 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1324 conditionType = ARITHMATIC_CONDITION;
mkarlsso 0:8dbd6bd9167f 1325
mkarlsso 0:8dbd6bd9167f 1326 }
mkarlsso 0:8dbd6bd9167f 1327
mkarlsso 0:8dbd6bd9167f 1328 condition::condition(condition* condition1, char condType, condition* condition2) {
mkarlsso 0:8dbd6bd9167f 1329 intCmp = NULL;
mkarlsso 0:8dbd6bd9167f 1330 conditionPtrs[0] = condition1;
mkarlsso 0:8dbd6bd9167f 1331 conditionPtrs[1] = condition2;
mkarlsso 0:8dbd6bd9167f 1332 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1333 conditionType = condType;
mkarlsso 0:8dbd6bd9167f 1334 }
mkarlsso 0:8dbd6bd9167f 1335
mkarlsso 0:8dbd6bd9167f 1336 condition::~condition() {
mkarlsso 0:8dbd6bd9167f 1337 if (intCmp != NULL) {
mkarlsso 0:8dbd6bd9167f 1338 delete intCmp;
mkarlsso 0:8dbd6bd9167f 1339 }
mkarlsso 0:8dbd6bd9167f 1340 }
mkarlsso 0:8dbd6bd9167f 1341
mkarlsso 0:8dbd6bd9167f 1342 void condition::release() {
mkarlsso 0:8dbd6bd9167f 1343 if (intCmp != NULL) {
mkarlsso 0:8dbd6bd9167f 1344 intCmp->release();
mkarlsso 0:8dbd6bd9167f 1345 intCmp=NULL;
mkarlsso 0:8dbd6bd9167f 1346 }
mkarlsso 0:8dbd6bd9167f 1347 if (conditionPtrs[0] != NULL) {
mkarlsso 0:8dbd6bd9167f 1348 conditionPtrs[0]->release();
mkarlsso 0:8dbd6bd9167f 1349 conditionPtrs[1]->release();
mkarlsso 0:8dbd6bd9167f 1350 conditionPtrs[0]=NULL;
mkarlsso 0:8dbd6bd9167f 1351 conditionPtrs[1]=NULL;
mkarlsso 0:8dbd6bd9167f 1352 }
mkarlsso 0:8dbd6bd9167f 1353 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1354 }
mkarlsso 0:8dbd6bd9167f 1355
mkarlsso 0:8dbd6bd9167f 1356 void condition::set(intCompare* compareInput) {
mkarlsso 0:8dbd6bd9167f 1357 release();
mkarlsso 0:8dbd6bd9167f 1358 intCmp = compareInput;
mkarlsso 0:8dbd6bd9167f 1359 conditionPtrs[0] = NULL;
mkarlsso 0:8dbd6bd9167f 1360 conditionPtrs[1] = NULL;
mkarlsso 0:8dbd6bd9167f 1361 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1362 conditionType = ARITHMATIC_CONDITION;
mkarlsso 0:8dbd6bd9167f 1363 }
mkarlsso 0:8dbd6bd9167f 1364
mkarlsso 0:8dbd6bd9167f 1365 void condition::set(condition* condition1, char condType, condition* condition2) {
mkarlsso 0:8dbd6bd9167f 1366 release();
mkarlsso 0:8dbd6bd9167f 1367 intCmp = NULL;
mkarlsso 0:8dbd6bd9167f 1368 conditionPtrs[0] = condition1;
mkarlsso 0:8dbd6bd9167f 1369 conditionPtrs[1] = condition2;
mkarlsso 0:8dbd6bd9167f 1370 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1371 conditionType = condType;
mkarlsso 0:8dbd6bd9167f 1372 }
mkarlsso 0:8dbd6bd9167f 1373
mkarlsso 0:8dbd6bd9167f 1374 bool condition::isTrue() {
mkarlsso 0:8dbd6bd9167f 1375
mkarlsso 0:8dbd6bd9167f 1376
mkarlsso 0:8dbd6bd9167f 1377 bool result = true;
mkarlsso 0:8dbd6bd9167f 1378 if (conditionType == ARITHMATIC_CONDITION) {
mkarlsso 0:8dbd6bd9167f 1379
mkarlsso 0:8dbd6bd9167f 1380 result = (intCmp->isTrue)();
mkarlsso 0:8dbd6bd9167f 1381 } else if (conditionType == AND_CONDITION) {
mkarlsso 0:8dbd6bd9167f 1382
mkarlsso 0:8dbd6bd9167f 1383 result = conditionPtrs[0]->isTrue() && conditionPtrs[1]->isTrue();
mkarlsso 0:8dbd6bd9167f 1384 } else if (conditionType == OR_CONDITION) {
mkarlsso 0:8dbd6bd9167f 1385
mkarlsso 0:8dbd6bd9167f 1386 result = conditionPtrs[0]->isTrue() || conditionPtrs[1]->isTrue();
mkarlsso 0:8dbd6bd9167f 1387 }
mkarlsso 0:8dbd6bd9167f 1388 return result;
mkarlsso 0:8dbd6bd9167f 1389
mkarlsso 0:8dbd6bd9167f 1390 }
mkarlsso 0:8dbd6bd9167f 1391
mkarlsso 0:8dbd6bd9167f 1392 portMessage::portMessage():
mkarlsso 0:8dbd6bd9167f 1393 whichToSet(0),
mkarlsso 0:8dbd6bd9167f 1394 value(0),
mkarlsso 0:8dbd6bd9167f 1395 port(NULL) {
mkarlsso 0:8dbd6bd9167f 1396 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1397 }
mkarlsso 0:8dbd6bd9167f 1398
mkarlsso 0:8dbd6bd9167f 1399 void portMessage::release() {
mkarlsso 0:8dbd6bd9167f 1400
mkarlsso 0:8dbd6bd9167f 1401 whichToSet = 0;
mkarlsso 0:8dbd6bd9167f 1402 value = 0;
mkarlsso 0:8dbd6bd9167f 1403 port = NULL;
mkarlsso 0:8dbd6bd9167f 1404 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1405 }
mkarlsso 0:8dbd6bd9167f 1406
mkarlsso 0:8dbd6bd9167f 1407 /*
mkarlsso 0:8dbd6bd9167f 1408 portMessage::portMessage(digitalPort* portIn, int whichToSetIn, int valueIn):
mkarlsso 0:8dbd6bd9167f 1409 whichToSet(whichToSetIn),
mkarlsso 0:8dbd6bd9167f 1410 value(valueIn),
mkarlsso 0:8dbd6bd9167f 1411 port(portIn) {
mkarlsso 0:8dbd6bd9167f 1412 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1413 }
mkarlsso 0:8dbd6bd9167f 1414
mkarlsso 0:8dbd6bd9167f 1415 void portMessage::setMessage(digitalPort* portIn, int whichToSetIn, int valueIn) {
mkarlsso 0:8dbd6bd9167f 1416 whichToSet = whichToSetIn;
mkarlsso 0:8dbd6bd9167f 1417 value = valueIn;
mkarlsso 0:8dbd6bd9167f 1418 port = portIn;
mkarlsso 0:8dbd6bd9167f 1419 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1420 }*/
mkarlsso 0:8dbd6bd9167f 1421
mkarlsso 0:8dbd6bd9167f 1422 /*
mkarlsso 0:8dbd6bd9167f 1423 portMessage::portMessage(int* portIn, int whichToSetIn, int valueIn):
mkarlsso 0:8dbd6bd9167f 1424 whichToSet(whichToSetIn),
mkarlsso 0:8dbd6bd9167f 1425 value(valueIn),
mkarlsso 0:8dbd6bd9167f 1426 port(portIn) {
mkarlsso 0:8dbd6bd9167f 1427 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1428 }*/
mkarlsso 0:8dbd6bd9167f 1429
mkarlsso 0:8dbd6bd9167f 1430 void portMessage::setMessage(int* portIn, int whichToSetIn, int valueIn, digitalPort* portVectorIn) {
mkarlsso 0:8dbd6bd9167f 1431 whichToSet = whichToSetIn;
mkarlsso 0:8dbd6bd9167f 1432 value = valueIn;
mkarlsso 0:8dbd6bd9167f 1433 port = portIn;
mkarlsso 0:8dbd6bd9167f 1434 portVector = portVectorIn;
mkarlsso 0:8dbd6bd9167f 1435 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1436 }
mkarlsso 0:8dbd6bd9167f 1437
mkarlsso 0:8dbd6bd9167f 1438 void portMessage::execute() {
mkarlsso 0:8dbd6bd9167f 1439
mkarlsso 0:8dbd6bd9167f 1440 if (port != NULL) {
mkarlsso 0:8dbd6bd9167f 1441 if ((*port > 0) && (*port <= NUMPORTS)) {
mkarlsso 0:8dbd6bd9167f 1442 portVector[*port-1].setDigitalOut(value);
mkarlsso 0:8dbd6bd9167f 1443 } else {
mkarlsso 0:8dbd6bd9167f 1444 textDisplay << "Error: port index assigned by variable does not exist.\r\n";
mkarlsso 0:8dbd6bd9167f 1445 }
mkarlsso 0:8dbd6bd9167f 1446 } else {
mkarlsso 0:8dbd6bd9167f 1447 portVector[whichToSet-1].setDigitalOut(value);
mkarlsso 0:8dbd6bd9167f 1448 }
mkarlsso 0:8dbd6bd9167f 1449
mkarlsso 0:8dbd6bd9167f 1450 }
mkarlsso 0:8dbd6bd9167f 1451
mkarlsso 0:8dbd6bd9167f 1452 action::action():
mkarlsso 0:8dbd6bd9167f 1453 actionType(0) {
mkarlsso 0:8dbd6bd9167f 1454 op = NULL;
mkarlsso 0:8dbd6bd9167f 1455 message = NULL;
mkarlsso 0:8dbd6bd9167f 1456 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1457 displayActionPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1458 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1459 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1460 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1461 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1462 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1463
mkarlsso 0:8dbd6bd9167f 1464 }
mkarlsso 0:8dbd6bd9167f 1465
mkarlsso 0:8dbd6bd9167f 1466 action::~action() {
mkarlsso 0:8dbd6bd9167f 1467 if (eventToCreate != NULL) delete eventToCreate;
mkarlsso 0:8dbd6bd9167f 1468 if (op != NULL) delete op;
mkarlsso 0:8dbd6bd9167f 1469 if (message != NULL) delete message;
mkarlsso 0:8dbd6bd9167f 1470 delete displayActionPtr;
mkarlsso 0:8dbd6bd9167f 1471 delete sound;
mkarlsso 0:8dbd6bd9167f 1472 }
mkarlsso 0:8dbd6bd9167f 1473
mkarlsso 0:8dbd6bd9167f 1474 void action::release() {
mkarlsso 0:8dbd6bd9167f 1475 if (eventToCreate != NULL) eventToCreate->release();
mkarlsso 0:8dbd6bd9167f 1476 if (op != NULL) op->release();
mkarlsso 0:8dbd6bd9167f 1477 if (message != NULL) message->release();
mkarlsso 0:8dbd6bd9167f 1478 if (displayActionPtr != NULL) displayActionPtr->release();
mkarlsso 0:8dbd6bd9167f 1479 if (triggerFunc != NULL) triggerFunc->release();
mkarlsso 0:8dbd6bd9167f 1480 delete sound; //still need to make a static soundControl array
mkarlsso 0:8dbd6bd9167f 1481
mkarlsso 0:8dbd6bd9167f 1482 actionType = 0;
mkarlsso 0:8dbd6bd9167f 1483 op = NULL;
mkarlsso 0:8dbd6bd9167f 1484 message = NULL;
mkarlsso 0:8dbd6bd9167f 1485 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1486 displayActionPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1487 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1488 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1489 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1490 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1491 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1492 }
mkarlsso 0:8dbd6bd9167f 1493
mkarlsso 0:8dbd6bd9167f 1494 action::action(intOperation* opInput):
mkarlsso 0:8dbd6bd9167f 1495 actionType(1) {
mkarlsso 0:8dbd6bd9167f 1496 op = opInput;
mkarlsso 0:8dbd6bd9167f 1497 message = NULL;
mkarlsso 0:8dbd6bd9167f 1498 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1499 displayActionPtr= NULL;
mkarlsso 0:8dbd6bd9167f 1500 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1501 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1502 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1503 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1504 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1505 }
mkarlsso 0:8dbd6bd9167f 1506
mkarlsso 0:8dbd6bd9167f 1507 action::action(portMessage* messageInput):
mkarlsso 0:8dbd6bd9167f 1508 actionType(2) {
mkarlsso 0:8dbd6bd9167f 1509 op = NULL;
mkarlsso 0:8dbd6bd9167f 1510 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1511 message = messageInput;
mkarlsso 0:8dbd6bd9167f 1512 displayActionPtr= NULL;
mkarlsso 0:8dbd6bd9167f 1513 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1514 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1515 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1516 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1517 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1518
mkarlsso 0:8dbd6bd9167f 1519 }
mkarlsso 0:8dbd6bd9167f 1520
mkarlsso 0:8dbd6bd9167f 1521 action::action(event* eventInput):
mkarlsso 0:8dbd6bd9167f 1522 actionType(3) {
mkarlsso 0:8dbd6bd9167f 1523 op = NULL;
mkarlsso 0:8dbd6bd9167f 1524 message = NULL;
mkarlsso 0:8dbd6bd9167f 1525 eventToCreate = eventInput;
mkarlsso 0:8dbd6bd9167f 1526 displayActionPtr= NULL;
mkarlsso 0:8dbd6bd9167f 1527 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1528 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1529
mkarlsso 0:8dbd6bd9167f 1530 //eventDelay = eventInput->timeLag;
mkarlsso 0:8dbd6bd9167f 1531
mkarlsso 0:8dbd6bd9167f 1532
mkarlsso 0:8dbd6bd9167f 1533 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1534 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1535 }
mkarlsso 0:8dbd6bd9167f 1536
mkarlsso 0:8dbd6bd9167f 1537 /*
mkarlsso 0:8dbd6bd9167f 1538 action::action(event* eventInput, uint32_t delay):
mkarlsso 0:8dbd6bd9167f 1539 actionType(3) {
mkarlsso 0:8dbd6bd9167f 1540 op = NULL;
mkarlsso 0:8dbd6bd9167f 1541 message = NULL;
mkarlsso 0:8dbd6bd9167f 1542 eventToCreate = eventInput;
mkarlsso 0:8dbd6bd9167f 1543 displayActionPtr= NULL;
mkarlsso 0:8dbd6bd9167f 1544 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1545 eventDelay = delay;
mkarlsso 0:8dbd6bd9167f 1546 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1547 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1548
mkarlsso 0:8dbd6bd9167f 1549 }*/
mkarlsso 0:8dbd6bd9167f 1550
mkarlsso 0:8dbd6bd9167f 1551
mkarlsso 0:8dbd6bd9167f 1552
mkarlsso 0:8dbd6bd9167f 1553 action::action(displayAction* displayInput):
mkarlsso 0:8dbd6bd9167f 1554 actionType(4) {
mkarlsso 0:8dbd6bd9167f 1555 op = NULL;
mkarlsso 0:8dbd6bd9167f 1556 message = NULL;
mkarlsso 0:8dbd6bd9167f 1557 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1558 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1559 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1560 displayActionPtr = displayInput;
mkarlsso 0:8dbd6bd9167f 1561 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1562 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1563 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1564 }
mkarlsso 0:8dbd6bd9167f 1565
mkarlsso 0:8dbd6bd9167f 1566 action::action(sSound* soundInput):
mkarlsso 0:8dbd6bd9167f 1567 actionType(5) {
mkarlsso 0:8dbd6bd9167f 1568 op = NULL;
mkarlsso 0:8dbd6bd9167f 1569 message = NULL;
mkarlsso 0:8dbd6bd9167f 1570 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1571 sound = soundInput;
mkarlsso 0:8dbd6bd9167f 1572 triggerFunc = NULL;
mkarlsso 0:8dbd6bd9167f 1573 displayActionPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1574 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1575 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1576 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1577 }
mkarlsso 0:8dbd6bd9167f 1578
mkarlsso 0:8dbd6bd9167f 1579 action::action(triggerFunctionAction* triggerFuncInput):
mkarlsso 0:8dbd6bd9167f 1580 actionType(7) {
mkarlsso 0:8dbd6bd9167f 1581 op = NULL;
mkarlsso 0:8dbd6bd9167f 1582 message = NULL;
mkarlsso 0:8dbd6bd9167f 1583 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1584 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1585 triggerFunc = triggerFuncInput;
mkarlsso 0:8dbd6bd9167f 1586 displayActionPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1587 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1588 sysCommand = -1;
mkarlsso 0:8dbd6bd9167f 1589 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1590 }
mkarlsso 0:8dbd6bd9167f 1591
mkarlsso 0:8dbd6bd9167f 1592 action::action(int8_t sysCommandInput):
mkarlsso 0:8dbd6bd9167f 1593 actionType(6) {
mkarlsso 0:8dbd6bd9167f 1594 op = NULL;
mkarlsso 0:8dbd6bd9167f 1595 message = NULL;
mkarlsso 0:8dbd6bd9167f 1596 eventToCreate = NULL;
mkarlsso 0:8dbd6bd9167f 1597 sound = NULL;
mkarlsso 0:8dbd6bd9167f 1598 displayActionPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1599 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1600 sysCommand = sysCommandInput;
mkarlsso 0:8dbd6bd9167f 1601 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1602 }
mkarlsso 0:8dbd6bd9167f 1603
mkarlsso 0:8dbd6bd9167f 1604 void action::set(intOperation* opInput) {
mkarlsso 0:8dbd6bd9167f 1605 actionType = 1;
mkarlsso 0:8dbd6bd9167f 1606 op = opInput;
mkarlsso 0:8dbd6bd9167f 1607 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1608 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1609
mkarlsso 0:8dbd6bd9167f 1610 }
mkarlsso 0:8dbd6bd9167f 1611
mkarlsso 0:8dbd6bd9167f 1612 void action::set(portMessage* messageInput) {
mkarlsso 0:8dbd6bd9167f 1613 actionType = 2;
mkarlsso 0:8dbd6bd9167f 1614 message = messageInput;
mkarlsso 0:8dbd6bd9167f 1615 //eventDelay = 0;
mkarlsso 0:8dbd6bd9167f 1616 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1617
mkarlsso 0:8dbd6bd9167f 1618 }
mkarlsso 0:8dbd6bd9167f 1619
mkarlsso 0:8dbd6bd9167f 1620 void action::set(event* eventInput) {
mkarlsso 0:8dbd6bd9167f 1621 actionType = 3;
mkarlsso 0:8dbd6bd9167f 1622 eventToCreate = eventInput;
mkarlsso 0:8dbd6bd9167f 1623 //eventDelay = eventInput->timeLag;
mkarlsso 0:8dbd6bd9167f 1624
mkarlsso 0:8dbd6bd9167f 1625 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1626
mkarlsso 0:8dbd6bd9167f 1627 }
mkarlsso 0:8dbd6bd9167f 1628
mkarlsso 0:8dbd6bd9167f 1629 /*
mkarlsso 0:8dbd6bd9167f 1630 void action::set(event* eventInput, uint32_t delay) {
mkarlsso 0:8dbd6bd9167f 1631 actionType = 3;
mkarlsso 0:8dbd6bd9167f 1632 eventToCreate = eventInput;
mkarlsso 0:8dbd6bd9167f 1633 eventDelay = delay;
mkarlsso 0:8dbd6bd9167f 1634 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1635
mkarlsso 0:8dbd6bd9167f 1636 }*/
mkarlsso 0:8dbd6bd9167f 1637
mkarlsso 0:8dbd6bd9167f 1638
mkarlsso 0:8dbd6bd9167f 1639
mkarlsso 0:8dbd6bd9167f 1640 void action::set(displayAction* displayInput) {
mkarlsso 0:8dbd6bd9167f 1641 actionType = 4;
mkarlsso 0:8dbd6bd9167f 1642 displayActionPtr = displayInput;
mkarlsso 0:8dbd6bd9167f 1643 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1644 }
mkarlsso 0:8dbd6bd9167f 1645
mkarlsso 0:8dbd6bd9167f 1646 void action::set(sSound* soundInput) {
mkarlsso 0:8dbd6bd9167f 1647 actionType = 5;
mkarlsso 0:8dbd6bd9167f 1648 sound = soundInput;
mkarlsso 0:8dbd6bd9167f 1649 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1650 }
mkarlsso 0:8dbd6bd9167f 1651
mkarlsso 0:8dbd6bd9167f 1652 void action::set(triggerFunctionAction* triggerFuncInput) {
mkarlsso 0:8dbd6bd9167f 1653
mkarlsso 0:8dbd6bd9167f 1654 actionType = 7;
mkarlsso 0:8dbd6bd9167f 1655 triggerFunc = triggerFuncInput;
mkarlsso 0:8dbd6bd9167f 1656 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1657 }
mkarlsso 0:8dbd6bd9167f 1658
mkarlsso 0:8dbd6bd9167f 1659 void action::set(int8_t sysCommandInput) {
mkarlsso 0:8dbd6bd9167f 1660 actionType = 6;
mkarlsso 0:8dbd6bd9167f 1661 sysCommand = sysCommandInput;
mkarlsso 0:8dbd6bd9167f 1662 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1663 }
mkarlsso 0:8dbd6bd9167f 1664
mkarlsso 0:8dbd6bd9167f 1665 void action::execute() {
mkarlsso 0:8dbd6bd9167f 1666
mkarlsso 0:8dbd6bd9167f 1667 if (actionType == 1) {
mkarlsso 0:8dbd6bd9167f 1668 op->execute();
mkarlsso 0:8dbd6bd9167f 1669 } else if (actionType == 2) {
mkarlsso 0:8dbd6bd9167f 1670 message->execute();
mkarlsso 0:8dbd6bd9167f 1671 } else if (actionType == 3) {
mkarlsso 0:8dbd6bd9167f 1672 this->execute(timeKeeper); //route to the other overloaded method
mkarlsso 0:8dbd6bd9167f 1673 } else if (actionType == 4) {
mkarlsso 0:8dbd6bd9167f 1674 displayActionPtr->execute(); //send text via serial
mkarlsso 0:8dbd6bd9167f 1675 } else if (actionType == 5) {
mkarlsso 0:8dbd6bd9167f 1676 sound->execute(); //operate sound device
mkarlsso 0:8dbd6bd9167f 1677 } else if (actionType == 6) {
mkarlsso 0:8dbd6bd9167f 1678 switch(sysCommand) {
mkarlsso 0:8dbd6bd9167f 1679 case 0:
mkarlsso 0:8dbd6bd9167f 1680 mainQueue.eraseQueue();
mkarlsso 0:8dbd6bd9167f 1681 break;
mkarlsso 0:8dbd6bd9167f 1682 case 1:
mkarlsso 0:8dbd6bd9167f 1683 textStreaming = true;
mkarlsso 0:8dbd6bd9167f 1684 break;
mkarlsso 0:8dbd6bd9167f 1685 case 2:
mkarlsso 0:8dbd6bd9167f 1686 textStreaming = false;
mkarlsso 0:8dbd6bd9167f 1687 break;
mkarlsso 0:8dbd6bd9167f 1688 case 3:
mkarlsso 0:8dbd6bd9167f 1689 broadCastStateChanges = true;
mkarlsso 0:8dbd6bd9167f 1690 break;
mkarlsso 0:8dbd6bd9167f 1691 case 4:
mkarlsso 0:8dbd6bd9167f 1692 broadCastStateChanges = false;
mkarlsso 0:8dbd6bd9167f 1693 break;
mkarlsso 0:8dbd6bd9167f 1694 }
mkarlsso 0:8dbd6bd9167f 1695
mkarlsso 0:8dbd6bd9167f 1696 } else if (actionType == 7) {
mkarlsso 0:8dbd6bd9167f 1697 triggerFunc->execute(); //execute function
mkarlsso 0:8dbd6bd9167f 1698 }
mkarlsso 0:8dbd6bd9167f 1699 }
mkarlsso 0:8dbd6bd9167f 1700
mkarlsso 0:8dbd6bd9167f 1701 void action::execute(uint32_t blockExecTime) {
mkarlsso 0:8dbd6bd9167f 1702
mkarlsso 0:8dbd6bd9167f 1703 if (actionType == 1) {
mkarlsso 0:8dbd6bd9167f 1704 op->execute();
mkarlsso 0:8dbd6bd9167f 1705 } else if (actionType == 2) {
mkarlsso 0:8dbd6bd9167f 1706 message->execute();
mkarlsso 0:8dbd6bd9167f 1707 } else if (actionType == 3) { //an event block
mkarlsso 0:8dbd6bd9167f 1708 //Because time will pass from the begining of the block, any defined delays should be updated
mkarlsso 0:8dbd6bd9167f 1709
mkarlsso 0:8dbd6bd9167f 1710 //int newDelay = eventDelay-(*globalTimeKeeperPtr-blockExecTime);
mkarlsso 0:8dbd6bd9167f 1711 int newDelay;
mkarlsso 0:8dbd6bd9167f 1712 if (eventToCreate->timeLagIsConstant) {
mkarlsso 0:8dbd6bd9167f 1713 newDelay = eventToCreate->timeLag - (timeKeeper-blockExecTime);
mkarlsso 0:8dbd6bd9167f 1714 } else {
mkarlsso 0:8dbd6bd9167f 1715 newDelay = *eventToCreate->timeLagVar - (timeKeeper-blockExecTime);
mkarlsso 0:8dbd6bd9167f 1716 }
mkarlsso 0:8dbd6bd9167f 1717 if (newDelay < 0) {newDelay = 0;}
mkarlsso 0:8dbd6bd9167f 1718 eventToCreate->addToQueue(newDelay); //add the event to the queue to be executed later
mkarlsso 0:8dbd6bd9167f 1719
mkarlsso 0:8dbd6bd9167f 1720 if (eventToCreate->hasWhileLoop) { //this is a while loop
mkarlsso 0:8dbd6bd9167f 1721 if (eventToCreate->isConditionTrue()) {
mkarlsso 0:8dbd6bd9167f 1722 //newDelay = (blockExecTime + eventToCreate->whileLoopPeriod) - *globalTimeKeeperPtr;
mkarlsso 0:8dbd6bd9167f 1723 int tmpPeriod;
mkarlsso 0:8dbd6bd9167f 1724 if (eventToCreate->whileLoopPeriodIsConstant) { //constant while loop period
mkarlsso 0:8dbd6bd9167f 1725 newDelay = (blockExecTime + eventToCreate->whileLoopPeriod);
mkarlsso 0:8dbd6bd9167f 1726 tmpPeriod = eventToCreate->whileLoopPeriod;
mkarlsso 0:8dbd6bd9167f 1727 } else {
mkarlsso 0:8dbd6bd9167f 1728 tmpPeriod = *eventToCreate->whileLoopPeriodVar;
mkarlsso 0:8dbd6bd9167f 1729 if (tmpPeriod < 0) {
mkarlsso 0:8dbd6bd9167f 1730 tmpPeriod = 0;
mkarlsso 0:8dbd6bd9167f 1731 }
mkarlsso 0:8dbd6bd9167f 1732 newDelay = (blockExecTime + tmpPeriod);
mkarlsso 0:8dbd6bd9167f 1733 }
mkarlsso 0:8dbd6bd9167f 1734 while ( (newDelay-timeKeeper < 0) && (eventToCreate->isConditionTrue()) ) {
mkarlsso 0:8dbd6bd9167f 1735 eventToCreate->execute();
mkarlsso 0:8dbd6bd9167f 1736 newDelay = newDelay + tmpPeriod;
mkarlsso 0:8dbd6bd9167f 1737
mkarlsso 0:8dbd6bd9167f 1738 }
mkarlsso 0:8dbd6bd9167f 1739 newDelay = newDelay-timeKeeper;
mkarlsso 0:8dbd6bd9167f 1740 if (newDelay > 0) {
mkarlsso 0:8dbd6bd9167f 1741 eventToCreate->addToQueue(newDelay);
mkarlsso 0:8dbd6bd9167f 1742 } else {
mkarlsso 0:8dbd6bd9167f 1743 eventToCreate->addToQueue(1);
mkarlsso 0:8dbd6bd9167f 1744 }
mkarlsso 0:8dbd6bd9167f 1745 } else if (eventToCreate->nextElseEventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 1746 eventToCreate->nextElseEventPtr->addToQueue();
mkarlsso 0:8dbd6bd9167f 1747
mkarlsso 0:8dbd6bd9167f 1748 }
mkarlsso 0:8dbd6bd9167f 1749 }
mkarlsso 0:8dbd6bd9167f 1750 } else if (actionType == 4) {
mkarlsso 0:8dbd6bd9167f 1751 displayActionPtr->execute(); //send text via serial
mkarlsso 0:8dbd6bd9167f 1752 } else if (actionType == 5) {
mkarlsso 0:8dbd6bd9167f 1753 sound->execute(); //operate sound device
mkarlsso 0:8dbd6bd9167f 1754 } else if (actionType == 6) {
mkarlsso 0:8dbd6bd9167f 1755 switch(sysCommand) {
mkarlsso 0:8dbd6bd9167f 1756 case 0:
mkarlsso 0:8dbd6bd9167f 1757 mainQueue.eraseQueue();
mkarlsso 0:8dbd6bd9167f 1758 break;
mkarlsso 0:8dbd6bd9167f 1759 case 1:
mkarlsso 0:8dbd6bd9167f 1760 textStreaming = true;
mkarlsso 0:8dbd6bd9167f 1761 break;
mkarlsso 0:8dbd6bd9167f 1762 case 2:
mkarlsso 0:8dbd6bd9167f 1763 textStreaming = false;
mkarlsso 0:8dbd6bd9167f 1764 break;
mkarlsso 0:8dbd6bd9167f 1765 case 3:
mkarlsso 0:8dbd6bd9167f 1766 broadCastStateChanges = true;
mkarlsso 0:8dbd6bd9167f 1767 break;
mkarlsso 0:8dbd6bd9167f 1768 case 4:
mkarlsso 0:8dbd6bd9167f 1769 broadCastStateChanges = false;
mkarlsso 0:8dbd6bd9167f 1770 break;
mkarlsso 0:8dbd6bd9167f 1771 }
mkarlsso 0:8dbd6bd9167f 1772 } else if (actionType == 7) {
mkarlsso 0:8dbd6bd9167f 1773
mkarlsso 0:8dbd6bd9167f 1774 textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 1775 triggerFunc->execute(); //operate sound device
mkarlsso 0:8dbd6bd9167f 1776 }
mkarlsso 0:8dbd6bd9167f 1777 }
mkarlsso 0:8dbd6bd9167f 1778
mkarlsso 0:8dbd6bd9167f 1779 eventQueue::eventQueue() {
mkarlsso 0:8dbd6bd9167f 1780
mkarlsso 0:8dbd6bd9167f 1781 queueItem blankEvent;
mkarlsso 0:8dbd6bd9167f 1782 blankEvent.timeToExecute = 0;
mkarlsso 0:8dbd6bd9167f 1783 blankEvent.eventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1784 queueSize = 100;
mkarlsso 0:8dbd6bd9167f 1785 events.resize(queueSize,blankEvent);
mkarlsso 0:8dbd6bd9167f 1786
mkarlsso 0:8dbd6bd9167f 1787
mkarlsso 0:8dbd6bd9167f 1788 }
mkarlsso 0:8dbd6bd9167f 1789
mkarlsso 0:8dbd6bd9167f 1790 void eventQueue::addEventToQueue(event* eventInput, uint32_t delay) {
mkarlsso 0:8dbd6bd9167f 1791 //*updateSlavePtr = false;
mkarlsso 0:8dbd6bd9167f 1792 uint32_t eventTime = timeKeeper + delay;
mkarlsso 0:8dbd6bd9167f 1793 //*updateSlavePtr = true;
mkarlsso 0:8dbd6bd9167f 1794 //std::vector<queueItem>::size_type sz = events.size();
mkarlsso 0:8dbd6bd9167f 1795 //Look for the first empty slot in the queue and place the event there.
mkarlsso 0:8dbd6bd9167f 1796 //This means that the events in the queue are out of order, but
mkarlsso 0:8dbd6bd9167f 1797 //it prevents us from having to push_pack and pop off all the time.
mkarlsso 0:8dbd6bd9167f 1798 for (unsigned i = 0; i < queueSize; i++) {
mkarlsso 0:8dbd6bd9167f 1799 if (events[i].eventPtr == NULL) {
mkarlsso 0:8dbd6bd9167f 1800 events[i].eventPtr = eventInput;
mkarlsso 0:8dbd6bd9167f 1801 events[i].timeToExecute = eventTime;
mkarlsso 0:8dbd6bd9167f 1802 break;
mkarlsso 0:8dbd6bd9167f 1803 }
mkarlsso 0:8dbd6bd9167f 1804 }
mkarlsso 0:8dbd6bd9167f 1805 }
mkarlsso 0:8dbd6bd9167f 1806
mkarlsso 0:8dbd6bd9167f 1807 void eventQueue::eraseQueue() {
mkarlsso 0:8dbd6bd9167f 1808 //Erase all events in the queue
mkarlsso 0:8dbd6bd9167f 1809 std::vector<queueItem>::size_type sz = events.size();
mkarlsso 0:8dbd6bd9167f 1810 for (unsigned i = 0; i < sz; i++) {
mkarlsso 0:8dbd6bd9167f 1811 events[i].eventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1812
mkarlsso 0:8dbd6bd9167f 1813 }
mkarlsso 0:8dbd6bd9167f 1814 }
mkarlsso 0:8dbd6bd9167f 1815
mkarlsso 0:8dbd6bd9167f 1816
mkarlsso 0:8dbd6bd9167f 1817 //check if any of the events in the queue are up for execution
mkarlsso 0:8dbd6bd9167f 1818 void eventQueue::check(void) {
mkarlsso 0:8dbd6bd9167f 1819
mkarlsso 0:8dbd6bd9167f 1820 //*updateSlavePtr = false;
mkarlsso 0:8dbd6bd9167f 1821 uint32_t currentTime = timeKeeper;
mkarlsso 0:8dbd6bd9167f 1822 //*updateSlavePtr = true;
mkarlsso 0:8dbd6bd9167f 1823 //std::vector<queueItem>::size_type sz = events.size();
mkarlsso 0:8dbd6bd9167f 1824 for (unsigned i = 0; i < queueSize; i++) {
mkarlsso 0:8dbd6bd9167f 1825 if (events[i].eventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 1826 if(events[i].timeToExecute <= currentTime) {
mkarlsso 0:8dbd6bd9167f 1827 if (!events[i].eventPtr->hasWhileLoop) {
mkarlsso 0:8dbd6bd9167f 1828 //this is not a while loop, so no need to check if the condition is still true
mkarlsso 0:8dbd6bd9167f 1829 events[i].eventPtr->execute();
mkarlsso 0:8dbd6bd9167f 1830 } else if (events[i].eventPtr->isConditionTrue()){
mkarlsso 0:8dbd6bd9167f 1831 //The event is part of a while loop, so recheck the condition before executing
mkarlsso 0:8dbd6bd9167f 1832 events[i].eventPtr->execute();
mkarlsso 0:8dbd6bd9167f 1833 //if (events[i].eventPtr->isConditionTrue()) { //is the condition still true?
mkarlsso 0:8dbd6bd9167f 1834 int nextTime;
mkarlsso 0:8dbd6bd9167f 1835 int tmpPeriod;
mkarlsso 0:8dbd6bd9167f 1836 if (events[i].eventPtr->whileLoopPeriodIsConstant) {
mkarlsso 0:8dbd6bd9167f 1837 nextTime = (events[i].timeToExecute + events[i].eventPtr->whileLoopPeriod);
mkarlsso 0:8dbd6bd9167f 1838 tmpPeriod = events[i].eventPtr->whileLoopPeriod;
mkarlsso 0:8dbd6bd9167f 1839 } else {
mkarlsso 0:8dbd6bd9167f 1840 tmpPeriod = *events[i].eventPtr->whileLoopPeriodVar;
mkarlsso 0:8dbd6bd9167f 1841 if (tmpPeriod < 0) {
mkarlsso 0:8dbd6bd9167f 1842 tmpPeriod = 0;
mkarlsso 0:8dbd6bd9167f 1843 }
mkarlsso 0:8dbd6bd9167f 1844 nextTime = (events[i].timeToExecute + tmpPeriod);
mkarlsso 0:8dbd6bd9167f 1845
mkarlsso 0:8dbd6bd9167f 1846 }
mkarlsso 0:8dbd6bd9167f 1847 //Just in case we are not keeping up, execute the event until we have cought up
mkarlsso 0:8dbd6bd9167f 1848 while ((nextTime-timeKeeper <= 0) && (events[i].eventPtr->isConditionTrue())) {
mkarlsso 0:8dbd6bd9167f 1849 events[i].eventPtr->execute();
mkarlsso 0:8dbd6bd9167f 1850 nextTime = nextTime+tmpPeriod;
mkarlsso 0:8dbd6bd9167f 1851
mkarlsso 0:8dbd6bd9167f 1852 }
mkarlsso 0:8dbd6bd9167f 1853 nextTime = nextTime - timeKeeper;
mkarlsso 0:8dbd6bd9167f 1854 if (nextTime > 0) {
mkarlsso 0:8dbd6bd9167f 1855 //we add the event to the queue (but the condition is rechecked first)
mkarlsso 0:8dbd6bd9167f 1856 //if the condition is false, the 'then' statement is added to the queue instead
mkarlsso 0:8dbd6bd9167f 1857 events[i].eventPtr->addToQueue(nextTime);
mkarlsso 0:8dbd6bd9167f 1858 } else {
mkarlsso 0:8dbd6bd9167f 1859 //if we are having trouble keeping up, just add the next event in 1 ms
mkarlsso 0:8dbd6bd9167f 1860 events[i].eventPtr->addToQueue(1);
mkarlsso 0:8dbd6bd9167f 1861 }
mkarlsso 0:8dbd6bd9167f 1862 /*
mkarlsso 0:8dbd6bd9167f 1863 } else {
mkarlsso 0:8dbd6bd9167f 1864 if (events[i].eventPtr->nextElseEventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 1865 events[i].eventPtr->nextElseEventPtr->addToQueue();
mkarlsso 0:8dbd6bd9167f 1866 }
mkarlsso 0:8dbd6bd9167f 1867 }*/
mkarlsso 0:8dbd6bd9167f 1868
mkarlsso 0:8dbd6bd9167f 1869 } else {
mkarlsso 0:8dbd6bd9167f 1870 if (events[i].eventPtr->nextElseEventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 1871 events[i].eventPtr->nextElseEventPtr->addToQueue();
mkarlsso 0:8dbd6bd9167f 1872 }
mkarlsso 0:8dbd6bd9167f 1873 }
mkarlsso 0:8dbd6bd9167f 1874 events[i].eventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1875 }
mkarlsso 0:8dbd6bd9167f 1876 }
mkarlsso 0:8dbd6bd9167f 1877 }
mkarlsso 0:8dbd6bd9167f 1878 }
mkarlsso 0:8dbd6bd9167f 1879
mkarlsso 0:8dbd6bd9167f 1880
mkarlsso 0:8dbd6bd9167f 1881 event::event():
mkarlsso 0:8dbd6bd9167f 1882 timeLag(0),
mkarlsso 0:8dbd6bd9167f 1883 queuePtr(&mainQueue) {
mkarlsso 0:8dbd6bd9167f 1884
mkarlsso 0:8dbd6bd9167f 1885 nextElseEventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1886 conditionToCheck = NULL;
mkarlsso 0:8dbd6bd9167f 1887 blockType = 0;
mkarlsso 0:8dbd6bd9167f 1888 whileLoopPeriod = 0;
mkarlsso 0:8dbd6bd9167f 1889 numConditions = 0;
mkarlsso 0:8dbd6bd9167f 1890 numActions = 0;
mkarlsso 0:8dbd6bd9167f 1891 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1892 timeLagVar = NULL;
mkarlsso 0:8dbd6bd9167f 1893 timeLagIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1894 whileLoopPeriodIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1895 hasWhileLoop = false;
mkarlsso 0:8dbd6bd9167f 1896 whileLoopPeriodVar = NULL;
mkarlsso 0:8dbd6bd9167f 1897
mkarlsso 0:8dbd6bd9167f 1898 }
mkarlsso 0:8dbd6bd9167f 1899
mkarlsso 0:8dbd6bd9167f 1900 event::event(eventQueue* queueInput):
mkarlsso 0:8dbd6bd9167f 1901 timeLag(0),
mkarlsso 0:8dbd6bd9167f 1902 queuePtr(&mainQueue) {
mkarlsso 0:8dbd6bd9167f 1903
mkarlsso 0:8dbd6bd9167f 1904 nextElseEventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1905 conditionToCheck = NULL;
mkarlsso 0:8dbd6bd9167f 1906 blockType = 0;
mkarlsso 0:8dbd6bd9167f 1907 whileLoopPeriod = 0;
mkarlsso 0:8dbd6bd9167f 1908 numConditions = 0;
mkarlsso 0:8dbd6bd9167f 1909 numActions = 0;
mkarlsso 0:8dbd6bd9167f 1910 isUsed = true;
mkarlsso 0:8dbd6bd9167f 1911 timeLagVar = NULL;
mkarlsso 0:8dbd6bd9167f 1912 timeLagIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1913 whileLoopPeriodIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1914 hasWhileLoop = false;
mkarlsso 0:8dbd6bd9167f 1915 whileLoopPeriodVar = NULL;
mkarlsso 0:8dbd6bd9167f 1916
mkarlsso 0:8dbd6bd9167f 1917 }
mkarlsso 0:8dbd6bd9167f 1918
mkarlsso 0:8dbd6bd9167f 1919 event::~event() {
mkarlsso 0:8dbd6bd9167f 1920 /*
mkarlsso 0:8dbd6bd9167f 1921 while (!conditionArray.empty())
mkarlsso 0:8dbd6bd9167f 1922 {
mkarlsso 0:8dbd6bd9167f 1923 delete conditionArray.back();
mkarlsso 0:8dbd6bd9167f 1924 conditionArray.pop_back();
mkarlsso 0:8dbd6bd9167f 1925 }
mkarlsso 0:8dbd6bd9167f 1926
mkarlsso 0:8dbd6bd9167f 1927 while (!actionArray.empty())
mkarlsso 0:8dbd6bd9167f 1928 {
mkarlsso 0:8dbd6bd9167f 1929 delete actionArray.back();
mkarlsso 0:8dbd6bd9167f 1930 actionArray.pop_back();
mkarlsso 0:8dbd6bd9167f 1931 }
mkarlsso 0:8dbd6bd9167f 1932
mkarlsso 0:8dbd6bd9167f 1933 delete nextElseEventPtr;
mkarlsso 0:8dbd6bd9167f 1934 */
mkarlsso 0:8dbd6bd9167f 1935
mkarlsso 0:8dbd6bd9167f 1936 }
mkarlsso 0:8dbd6bd9167f 1937
mkarlsso 0:8dbd6bd9167f 1938 void event::release() {
mkarlsso 0:8dbd6bd9167f 1939
mkarlsso 0:8dbd6bd9167f 1940 for (int i = 0; i < numActions; i++) {
mkarlsso 0:8dbd6bd9167f 1941 actionArray[i]->release();
mkarlsso 0:8dbd6bd9167f 1942 }
mkarlsso 0:8dbd6bd9167f 1943
mkarlsso 0:8dbd6bd9167f 1944 if (conditionToCheck != NULL) {
mkarlsso 0:8dbd6bd9167f 1945 conditionToCheck->release();
mkarlsso 0:8dbd6bd9167f 1946 conditionToCheck = NULL;
mkarlsso 0:8dbd6bd9167f 1947 }
mkarlsso 0:8dbd6bd9167f 1948
mkarlsso 0:8dbd6bd9167f 1949 if (nextElseEventPtr != NULL) {
mkarlsso 0:8dbd6bd9167f 1950 nextElseEventPtr->release();
mkarlsso 0:8dbd6bd9167f 1951 }
mkarlsso 0:8dbd6bd9167f 1952 timeLag = 0;
mkarlsso 0:8dbd6bd9167f 1953 nextElseEventPtr = NULL;
mkarlsso 0:8dbd6bd9167f 1954 blockType = 0;
mkarlsso 0:8dbd6bd9167f 1955 whileLoopPeriod = 0;
mkarlsso 0:8dbd6bd9167f 1956 numConditions = 0;
mkarlsso 0:8dbd6bd9167f 1957 numActions = 0;
mkarlsso 0:8dbd6bd9167f 1958 isUsed = false;
mkarlsso 0:8dbd6bd9167f 1959 timeLagVar = NULL;
mkarlsso 0:8dbd6bd9167f 1960 timeLagIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1961 whileLoopPeriodIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1962 hasWhileLoop = false;
mkarlsso 0:8dbd6bd9167f 1963 whileLoopPeriodVar = NULL;
mkarlsso 0:8dbd6bd9167f 1964 }
mkarlsso 0:8dbd6bd9167f 1965
mkarlsso 0:8dbd6bd9167f 1966 void event::setTimeLag(uint32_t timeLagInput) {
mkarlsso 0:8dbd6bd9167f 1967 timeLag = timeLagInput;
mkarlsso 0:8dbd6bd9167f 1968 timeLagIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1969 }
mkarlsso 0:8dbd6bd9167f 1970
mkarlsso 0:8dbd6bd9167f 1971 void event::setTimeLag(int* timeLagInput) {
mkarlsso 0:8dbd6bd9167f 1972 timeLagVar = timeLagInput;
mkarlsso 0:8dbd6bd9167f 1973 timeLagIsConstant = false; //time lag is not defined by a constant
mkarlsso 0:8dbd6bd9167f 1974 }
mkarlsso 0:8dbd6bd9167f 1975
mkarlsso 0:8dbd6bd9167f 1976 void event::setWhileLoopPeriod(uint32_t period) {
mkarlsso 0:8dbd6bd9167f 1977 whileLoopPeriodIsConstant = true;
mkarlsso 0:8dbd6bd9167f 1978 hasWhileLoop = true;
mkarlsso 0:8dbd6bd9167f 1979 whileLoopPeriod = period;
mkarlsso 0:8dbd6bd9167f 1980
mkarlsso 0:8dbd6bd9167f 1981 }
mkarlsso 0:8dbd6bd9167f 1982
mkarlsso 0:8dbd6bd9167f 1983 void event::setWhileLoopPeriod(int* period) {
mkarlsso 0:8dbd6bd9167f 1984 whileLoopPeriodIsConstant = false;
mkarlsso 0:8dbd6bd9167f 1985 hasWhileLoop = true;
mkarlsso 0:8dbd6bd9167f 1986 whileLoopPeriodVar = period;
mkarlsso 0:8dbd6bd9167f 1987
mkarlsso 0:8dbd6bd9167f 1988 }
mkarlsso 0:8dbd6bd9167f 1989
mkarlsso 0:8dbd6bd9167f 1990 void event::addCondition(condition* conditionInput) {
mkarlsso 0:8dbd6bd9167f 1991 if (conditionToCheck != NULL) {
mkarlsso 0:8dbd6bd9167f 1992 conditionToCheck->release();
mkarlsso 0:8dbd6bd9167f 1993 }
mkarlsso 0:8dbd6bd9167f 1994 conditionToCheck = conditionInput;
mkarlsso 0:8dbd6bd9167f 1995
mkarlsso 0:8dbd6bd9167f 1996 //conditionArray.push_back(conditionInput);
mkarlsso 0:8dbd6bd9167f 1997 }
mkarlsso 0:8dbd6bd9167f 1998
mkarlsso 0:8dbd6bd9167f 1999 void event::addAction(action* actionInput) {
mkarlsso 0:8dbd6bd9167f 2000 actionArray[numActions] = actionInput;
mkarlsso 0:8dbd6bd9167f 2001 numActions++;
mkarlsso 0:8dbd6bd9167f 2002 //actionArray.push_back(actionInput);
mkarlsso 0:8dbd6bd9167f 2003 }
mkarlsso 0:8dbd6bd9167f 2004
mkarlsso 0:8dbd6bd9167f 2005 bool event::isConditionTrue(void) {
mkarlsso 0:8dbd6bd9167f 2006 //if statement (can be left empty, which is interpreted as 'true')
mkarlsso 0:8dbd6bd9167f 2007 bool result = true;
mkarlsso 0:8dbd6bd9167f 2008
mkarlsso 0:8dbd6bd9167f 2009 if ((conditionToCheck!=NULL)&&(!conditionToCheck->isTrue())) {
mkarlsso 0:8dbd6bd9167f 2010 result = false;
mkarlsso 0:8dbd6bd9167f 2011 }
mkarlsso 0:8dbd6bd9167f 2012
mkarlsso 0:8dbd6bd9167f 2013 return result;
mkarlsso 0:8dbd6bd9167f 2014 }
mkarlsso 0:8dbd6bd9167f 2015
mkarlsso 0:8dbd6bd9167f 2016 void event::execute(void) {
mkarlsso 0:8dbd6bd9167f 2017 //called from the event queue. The condition is bypassed because it was already checked
mkarlsso 0:8dbd6bd9167f 2018
mkarlsso 0:8dbd6bd9167f 2019 uint32_t timeAtStartExec = timeKeeper;
mkarlsso 0:8dbd6bd9167f 2020 for (unsigned i = 0; i < numActions; i++) {
mkarlsso 0:8dbd6bd9167f 2021 actionArray[i]->execute(timeAtStartExec);
mkarlsso 0:8dbd6bd9167f 2022
mkarlsso 0:8dbd6bd9167f 2023 }
mkarlsso 0:8dbd6bd9167f 2024
mkarlsso 0:8dbd6bd9167f 2025 }
mkarlsso 0:8dbd6bd9167f 2026
mkarlsso 0:8dbd6bd9167f 2027 //Attach an 'else' statement to the event
mkarlsso 0:8dbd6bd9167f 2028 void event::setNextElseEvent(event* eventInput) {
mkarlsso 0:8dbd6bd9167f 2029 nextElseEventPtr = eventInput;
mkarlsso 0:8dbd6bd9167f 2030 }
mkarlsso 0:8dbd6bd9167f 2031
mkarlsso 0:8dbd6bd9167f 2032
mkarlsso 0:8dbd6bd9167f 2033 //When we we call addToQueue() the condition is checked. If true, the event is added
mkarlsso 0:8dbd6bd9167f 2034 //to the queue, otherwise we check if there was an 'else' statement attached to the event.
mkarlsso 0:8dbd6bd9167f 2035 void event::addToQueue(void) {
mkarlsso 0:8dbd6bd9167f 2036 if (isConditionTrue()) {
mkarlsso 0:8dbd6bd9167f 2037 if ((timeLagIsConstant)&&(timeLag == 0)) {
mkarlsso 0:8dbd6bd9167f 2038 execute();
mkarlsso 0:8dbd6bd9167f 2039
mkarlsso 0:8dbd6bd9167f 2040 } else if (timeLagIsConstant) {
mkarlsso 0:8dbd6bd9167f 2041 queuePtr->addEventToQueue(this, this->timeLag);
mkarlsso 0:8dbd6bd9167f 2042 } else if ((!timeLagIsConstant)&&(*timeLagVar <= 0)) {
mkarlsso 0:8dbd6bd9167f 2043 execute();
mkarlsso 0:8dbd6bd9167f 2044 } else {
mkarlsso 0:8dbd6bd9167f 2045 queuePtr->addEventToQueue(this, *timeLagVar);
mkarlsso 0:8dbd6bd9167f 2046 }
mkarlsso 0:8dbd6bd9167f 2047 } else if ((this->nextElseEventPtr != NULL)&&(whileLoopPeriod == 0)) {
mkarlsso 0:8dbd6bd9167f 2048 this->nextElseEventPtr->addToQueue();
mkarlsso 0:8dbd6bd9167f 2049 }
mkarlsso 0:8dbd6bd9167f 2050 }
mkarlsso 0:8dbd6bd9167f 2051
mkarlsso 0:8dbd6bd9167f 2052 //We can override the timeLag field and use another delay
mkarlsso 0:8dbd6bd9167f 2053 void event::addToQueue(uint32_t delay) {
mkarlsso 0:8dbd6bd9167f 2054 if (this->isConditionTrue()) {
mkarlsso 0:8dbd6bd9167f 2055 //if ((delay == 0) && (whileLoopPeriod == 0)) {
mkarlsso 0:8dbd6bd9167f 2056 if ((delay == 0)) {
mkarlsso 0:8dbd6bd9167f 2057 this->execute();
mkarlsso 0:8dbd6bd9167f 2058 } else {
mkarlsso 0:8dbd6bd9167f 2059 queuePtr->addEventToQueue(this, delay);
mkarlsso 0:8dbd6bd9167f 2060 }
mkarlsso 0:8dbd6bd9167f 2061 } else if ((this->nextElseEventPtr != NULL)) { //&&(!hasWhileLoop)) {
mkarlsso 0:8dbd6bd9167f 2062 this->nextElseEventPtr->addToQueue();
mkarlsso 0:8dbd6bd9167f 2063 }
mkarlsso 0:8dbd6bd9167f 2064 }
mkarlsso 0:8dbd6bd9167f 2065
mkarlsso 0:8dbd6bd9167f 2066
mkarlsso 0:8dbd6bd9167f 2067
mkarlsso 0:8dbd6bd9167f 2068 functionItem::functionItem(action* actionInput, string tagInput):
mkarlsso 0:8dbd6bd9167f 2069 tag(tagInput),
mkarlsso 0:8dbd6bd9167f 2070 actionPtr(actionInput) {
mkarlsso 0:8dbd6bd9167f 2071 }
mkarlsso 0:8dbd6bd9167f 2072
mkarlsso 0:8dbd6bd9167f 2073 functionItem::~functionItem() {
mkarlsso 0:8dbd6bd9167f 2074 delete actionPtr;
mkarlsso 0:8dbd6bd9167f 2075 }
mkarlsso 0:8dbd6bd9167f 2076
mkarlsso 0:8dbd6bd9167f 2077 blockBuffer::blockBuffer() {
mkarlsso 0:8dbd6bd9167f 2078 bufferWritePos = 0;
mkarlsso 0:8dbd6bd9167f 2079 bufferReadPos = 0;
mkarlsso 0:8dbd6bd9167f 2080 _linesAvailable = 0;
mkarlsso 0:8dbd6bd9167f 2081
mkarlsso 0:8dbd6bd9167f 2082 }
mkarlsso 0:8dbd6bd9167f 2083
mkarlsso 0:8dbd6bd9167f 2084 bool blockBuffer::addLine(char *input, int numChars) {
mkarlsso 0:8dbd6bd9167f 2085
mkarlsso 0:8dbd6bd9167f 2086 if (bufferWritePos+numChars >= INPUTCHARBUFFERSIZE) {
mkarlsso 0:8dbd6bd9167f 2087 return false;
mkarlsso 0:8dbd6bd9167f 2088 }
mkarlsso 0:8dbd6bd9167f 2089 for(int i=0;i<numChars;i++) {
mkarlsso 0:8dbd6bd9167f 2090 charBuffer[bufferWritePos] = input[i];
mkarlsso 0:8dbd6bd9167f 2091 bufferWritePos++;
mkarlsso 0:8dbd6bd9167f 2092 }
mkarlsso 0:8dbd6bd9167f 2093 _linesAvailable++;
mkarlsso 0:8dbd6bd9167f 2094 return true;
mkarlsso 0:8dbd6bd9167f 2095 }
mkarlsso 0:8dbd6bd9167f 2096
mkarlsso 0:8dbd6bd9167f 2097 string blockBuffer::getNextLine() {
mkarlsso 0:8dbd6bd9167f 2098
mkarlsso 0:8dbd6bd9167f 2099 string outputLine;
mkarlsso 0:8dbd6bd9167f 2100 int endOfLinePos = bufferReadPos;
mkarlsso 0:8dbd6bd9167f 2101 bool endOfLineFound = false;
mkarlsso 0:8dbd6bd9167f 2102
mkarlsso 0:8dbd6bd9167f 2103 if (_linesAvailable > 0) {
mkarlsso 0:8dbd6bd9167f 2104 //Find the end of the next line
mkarlsso 0:8dbd6bd9167f 2105
mkarlsso 0:8dbd6bd9167f 2106 while (endOfLinePos < INPUTCHARBUFFERSIZE) {
mkarlsso 0:8dbd6bd9167f 2107
mkarlsso 0:8dbd6bd9167f 2108 if (charBuffer[endOfLinePos] == '\0') {
mkarlsso 0:8dbd6bd9167f 2109 endOfLineFound = true;
mkarlsso 0:8dbd6bd9167f 2110 break;
mkarlsso 0:8dbd6bd9167f 2111 }
mkarlsso 0:8dbd6bd9167f 2112 endOfLinePos++;
mkarlsso 0:8dbd6bd9167f 2113 }
mkarlsso 0:8dbd6bd9167f 2114
mkarlsso 0:8dbd6bd9167f 2115 //If the end was found, copy to output string
mkarlsso 0:8dbd6bd9167f 2116 if (endOfLineFound) {
mkarlsso 0:8dbd6bd9167f 2117
mkarlsso 0:8dbd6bd9167f 2118 outputLine.append(charBuffer+bufferReadPos,endOfLinePos-bufferReadPos);
mkarlsso 0:8dbd6bd9167f 2119 bufferReadPos = endOfLinePos+1;
mkarlsso 0:8dbd6bd9167f 2120 _linesAvailable--;
mkarlsso 0:8dbd6bd9167f 2121 } else {
mkarlsso 0:8dbd6bd9167f 2122 textDisplay << "Error: No end of line found!";
mkarlsso 0:8dbd6bd9167f 2123 textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 2124 }
mkarlsso 0:8dbd6bd9167f 2125 }
mkarlsso 0:8dbd6bd9167f 2126 if (_linesAvailable == 0) {
mkarlsso 0:8dbd6bd9167f 2127 //we have read out all of the lines, so reset the buffer for the next block.
mkarlsso 0:8dbd6bd9167f 2128 resetBuffer();
mkarlsso 0:8dbd6bd9167f 2129 }
mkarlsso 0:8dbd6bd9167f 2130 return outputLine;
mkarlsso 0:8dbd6bd9167f 2131
mkarlsso 0:8dbd6bd9167f 2132 }
mkarlsso 0:8dbd6bd9167f 2133
mkarlsso 0:8dbd6bd9167f 2134 int16_t blockBuffer::linesAvailable() {
mkarlsso 0:8dbd6bd9167f 2135 return _linesAvailable;
mkarlsso 0:8dbd6bd9167f 2136 }
mkarlsso 0:8dbd6bd9167f 2137
mkarlsso 0:8dbd6bd9167f 2138 void blockBuffer::resetBuffer() {
mkarlsso 0:8dbd6bd9167f 2139 _linesAvailable = 0;
mkarlsso 0:8dbd6bd9167f 2140 bufferReadPos = 0;
mkarlsso 0:8dbd6bd9167f 2141 bufferWritePos = 0;
mkarlsso 0:8dbd6bd9167f 2142 }
mkarlsso 0:8dbd6bd9167f 2143
mkarlsso 0:8dbd6bd9167f 2144 bool blockBuffer::empty() {
mkarlsso 0:8dbd6bd9167f 2145 return (_linesAvailable == 0);
mkarlsso 0:8dbd6bd9167f 2146 }
mkarlsso 0:8dbd6bd9167f 2147
mkarlsso 0:8dbd6bd9167f 2148
mkarlsso 0:8dbd6bd9167f 2149 scriptStream::scriptStream(digitalPort* portVectorInput, int numPortsInput, eventQueue* queueInput, sSystem *system):
mkarlsso 0:8dbd6bd9167f 2150 portVector(portVectorInput),
mkarlsso 0:8dbd6bd9167f 2151 numPorts(numPortsInput),
mkarlsso 0:8dbd6bd9167f 2152 queuePtr(queueInput),
mkarlsso 0:8dbd6bd9167f 2153 system(system) {
mkarlsso 0:8dbd6bd9167f 2154
mkarlsso 0:8dbd6bd9167f 2155 currentPort = -1;
mkarlsso 0:8dbd6bd9167f 2156 currentTriggerPort = -1;
mkarlsso 0:8dbd6bd9167f 2157 currentTriggerDir = 1;
mkarlsso 0:8dbd6bd9167f 2158 currentFunction = -1;
mkarlsso 0:8dbd6bd9167f 2159
mkarlsso 0:8dbd6bd9167f 2160 randomSeedCounter = 0; //used for seeding random numbers
mkarlsso 0:8dbd6bd9167f 2161
mkarlsso 0:8dbd6bd9167f 2162 lineError = false;
mkarlsso 0:8dbd6bd9167f 2163 blockDepth = 0;
mkarlsso 0:8dbd6bd9167f 2164 ifBlockInit = false;
mkarlsso 0:8dbd6bd9167f 2165 whileBlockInit = false;
mkarlsso 0:8dbd6bd9167f 2166 expectingDoStatement = false;
mkarlsso 0:8dbd6bd9167f 2167 elseFlag = false;
mkarlsso 0:8dbd6bd9167f 2168 thenFlag = false;
mkarlsso 0:8dbd6bd9167f 2169 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 2170
mkarlsso 0:8dbd6bd9167f 2171 for (int i = 0; i < NUMFUNCTIONS; i++) {
mkarlsso 0:8dbd6bd9167f 2172 functionSpotTaken[i] = false;
mkarlsso 0:8dbd6bd9167f 2173 functionEventArray[i] = NULL;
mkarlsso 0:8dbd6bd9167f 2174 }
mkarlsso 0:8dbd6bd9167f 2175
mkarlsso 0:8dbd6bd9167f 2176
mkarlsso 0:8dbd6bd9167f 2177 }
mkarlsso 0:8dbd6bd9167f 2178
mkarlsso 0:8dbd6bd9167f 2179
mkarlsso 0:8dbd6bd9167f 2180 void scriptStream::addLineToCurrentBlock(char* lineInput) {
mkarlsso 0:8dbd6bd9167f 2181
mkarlsso 0:8dbd6bd9167f 2182 bool compile = false;
mkarlsso 0:8dbd6bd9167f 2183 bool keep = false;
mkarlsso 0:8dbd6bd9167f 2184 int numCharInLine = 0;
mkarlsso 0:8dbd6bd9167f 2185 //A line ending with ';' then carriage return initiates the compile sequence
mkarlsso 0:8dbd6bd9167f 2186 //Otherwise, add the line to the buffer and compile later
mkarlsso 0:8dbd6bd9167f 2187 for (int i = 0; i < 256; i++) {
mkarlsso 0:8dbd6bd9167f 2188 numCharInLine++;
mkarlsso 0:8dbd6bd9167f 2189 if (lineInput[i] == ';') {
mkarlsso 0:8dbd6bd9167f 2190 compile = true;
mkarlsso 0:8dbd6bd9167f 2191 } else if (lineInput[i] == ' ') {
mkarlsso 0:8dbd6bd9167f 2192 continue;
mkarlsso 0:8dbd6bd9167f 2193 } else if (lineInput[i] == '\0') {
mkarlsso 0:8dbd6bd9167f 2194 break;
mkarlsso 0:8dbd6bd9167f 2195 } else {
mkarlsso 0:8dbd6bd9167f 2196 keep = true;
mkarlsso 0:8dbd6bd9167f 2197 compile = false;
mkarlsso 0:8dbd6bd9167f 2198 }
mkarlsso 0:8dbd6bd9167f 2199
mkarlsso 0:8dbd6bd9167f 2200 }
mkarlsso 0:8dbd6bd9167f 2201
mkarlsso 0:8dbd6bd9167f 2202 //if (keep) currentBlock.insert(currentBlock.begin(),string(lineInput));
mkarlsso 0:8dbd6bd9167f 2203 if (keep) {
mkarlsso 0:8dbd6bd9167f 2204 if (!currentBlock.addLine(lineInput,numCharInLine)) {
mkarlsso 0:8dbd6bd9167f 2205 textDisplay << "Error: script input buffer full. The block is too long.\r\n";
mkarlsso 0:8dbd6bd9167f 2206 currentBlock.resetBuffer();
mkarlsso 0:8dbd6bd9167f 2207 compile = false;
mkarlsso 0:8dbd6bd9167f 2208 }
mkarlsso 0:8dbd6bd9167f 2209 }
mkarlsso 0:8dbd6bd9167f 2210 if (compile) {
mkarlsso 0:8dbd6bd9167f 2211 parseBlock();
mkarlsso 0:8dbd6bd9167f 2212 }
mkarlsso 0:8dbd6bd9167f 2213
mkarlsso 0:8dbd6bd9167f 2214 }
mkarlsso 0:8dbd6bd9167f 2215
mkarlsso 0:8dbd6bd9167f 2216
mkarlsso 0:8dbd6bd9167f 2217 //SCRIPT PARSING - all script commands are defined here.
mkarlsso 0:8dbd6bd9167f 2218 //-------------------------------------------------------
mkarlsso 0:8dbd6bd9167f 2219 void scriptStream::parseBlock() {
mkarlsso 0:8dbd6bd9167f 2220
mkarlsso 5:abee20c0bf2a 2221 tmpEvent = NULL;
mkarlsso 0:8dbd6bd9167f 2222 lineError = false;
mkarlsso 0:8dbd6bd9167f 2223 blockDepth = 0;
mkarlsso 0:8dbd6bd9167f 2224 ifBlockInit = false;
mkarlsso 0:8dbd6bd9167f 2225 whileBlockInit = false;
mkarlsso 0:8dbd6bd9167f 2226 expectingDoStatement = false;
mkarlsso 0:8dbd6bd9167f 2227 elseFlag = false;
mkarlsso 0:8dbd6bd9167f 2228 thenFlag = false;
mkarlsso 0:8dbd6bd9167f 2229 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 2230
mkarlsso 0:8dbd6bd9167f 2231
mkarlsso 0:8dbd6bd9167f 2232 std::size_t stringInd = 0;
mkarlsso 0:8dbd6bd9167f 2233
mkarlsso 0:8dbd6bd9167f 2234 bool wholeLineEvaluated = false;
mkarlsso 0:8dbd6bd9167f 2235
mkarlsso 0:8dbd6bd9167f 2236 while (!currentBlock.empty()) {
mkarlsso 0:8dbd6bd9167f 2237
mkarlsso 0:8dbd6bd9167f 2238 wholeLineEvaluated = false;
mkarlsso 0:8dbd6bd9167f 2239 //tmpLine = currentBlock.back();
mkarlsso 0:8dbd6bd9167f 2240 tmpLine = currentBlock.getNextLine();
mkarlsso 0:8dbd6bd9167f 2241
mkarlsso 0:8dbd6bd9167f 2242 lineError = false;
mkarlsso 0:8dbd6bd9167f 2243 //remove tabs
mkarlsso 0:8dbd6bd9167f 2244 std::size_t found = tmpLine.find_first_of(9); //tab
mkarlsso 0:8dbd6bd9167f 2245 while (found!=std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2246 tmpLine[found]= ' ';
mkarlsso 0:8dbd6bd9167f 2247 found=tmpLine.find_first_of(9,found+1);
mkarlsso 0:8dbd6bd9167f 2248 }
mkarlsso 0:8dbd6bd9167f 2249
mkarlsso 0:8dbd6bd9167f 2250 found = tmpLine.find_first_of(37); //% for commenting
mkarlsso 0:8dbd6bd9167f 2251 if (found!=std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2252 for (int p=found; p<tmpLine.size() ;p++) {
mkarlsso 0:8dbd6bd9167f 2253 tmpLine[p]= ' ';
mkarlsso 0:8dbd6bd9167f 2254 }
mkarlsso 0:8dbd6bd9167f 2255 }
mkarlsso 0:8dbd6bd9167f 2256
mkarlsso 0:8dbd6bd9167f 2257 //break up the line into tokens separated by spaces
mkarlsso 0:8dbd6bd9167f 2258 tokenize(tmpLine,tokens," ;");
mkarlsso 0:8dbd6bd9167f 2259
mkarlsso 0:8dbd6bd9167f 2260 std::vector<string>::size_type sz = tokens.size();
mkarlsso 0:8dbd6bd9167f 2261
mkarlsso 0:8dbd6bd9167f 2262 for (unsigned i = 0; i < sz; i++) {
mkarlsso 0:8dbd6bd9167f 2263
mkarlsso 0:8dbd6bd9167f 2264
mkarlsso 0:8dbd6bd9167f 2265
mkarlsso 0:8dbd6bd9167f 2266 //end statement signals the end of a block-----------------------------------------
mkarlsso 0:8dbd6bd9167f 2267 if (tokens[i].compare("end") == 0) { //ends the current block
mkarlsso 0:8dbd6bd9167f 2268
mkarlsso 0:8dbd6bd9167f 2269 if (ifBlockInit || whileBlockInit || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2270 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2271 lineError = true;
mkarlsso 0:8dbd6bd9167f 2272 }
mkarlsso 0:8dbd6bd9167f 2273
mkarlsso 0:8dbd6bd9167f 2274 ifBlockInit = false;
mkarlsso 0:8dbd6bd9167f 2275 whileBlockInit = false;
mkarlsso 0:8dbd6bd9167f 2276 expectingDoStatement = false;
mkarlsso 0:8dbd6bd9167f 2277 elseFlag = false;
mkarlsso 0:8dbd6bd9167f 2278
mkarlsso 0:8dbd6bd9167f 2279 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 2280 textDisplay.debug("End statement\r\n");
mkarlsso 0:8dbd6bd9167f 2281 if (blockDepth == 1) {
mkarlsso 0:8dbd6bd9167f 2282
mkarlsso 0:8dbd6bd9167f 2283
mkarlsso 0:8dbd6bd9167f 2284 currentTriggerPort = -1;
mkarlsso 0:8dbd6bd9167f 2285 currentFunction = -1;
mkarlsso 0:8dbd6bd9167f 2286
mkarlsso 0:8dbd6bd9167f 2287
mkarlsso 0:8dbd6bd9167f 2288
mkarlsso 0:8dbd6bd9167f 2289 blockDepth = 0;
mkarlsso 0:8dbd6bd9167f 2290 } else if (blockDepth > 1) {
mkarlsso 0:8dbd6bd9167f 2291 blockDepth = blockDepth - 1;
mkarlsso 0:8dbd6bd9167f 2292 }
mkarlsso 0:8dbd6bd9167f 2293
mkarlsso 3:d7b0a0890d96 2294 while ((tmpEventPtrArray.back()->blockType == 3) || (tmpEventPtrArray.back()->blockType == 4) || (tmpEventPtrArray.back()->blockType == 6) || (tmpEventPtrArray.back()->blockType == 7) || (tmpEventPtrArray.back()->blockType == 8)){
mkarlsso 0:8dbd6bd9167f 2295 tmpEventPtrArray.pop_back(); //recursively remove the pointers to all else blocks
mkarlsso 0:8dbd6bd9167f 2296 }
mkarlsso 0:8dbd6bd9167f 2297 tmpEventPtrArray.pop_back(); //remove the pointer to the finished block
mkarlsso 0:8dbd6bd9167f 2298
mkarlsso 0:8dbd6bd9167f 2299 } else {
mkarlsso 0:8dbd6bd9167f 2300 textDisplay << "Error: End statement without block\r\n";
mkarlsso 0:8dbd6bd9167f 2301 lineError = true;
mkarlsso 0:8dbd6bd9167f 2302 }
mkarlsso 0:8dbd6bd9167f 2303
mkarlsso 0:8dbd6bd9167f 2304
mkarlsso 0:8dbd6bd9167f 2305
mkarlsso 0:8dbd6bd9167f 2306 //sound statement used to play wave files------------------------------------------------
mkarlsso 0:8dbd6bd9167f 2307 //example: sound('soundfile')
mkarlsso 0:8dbd6bd9167f 2308 // sound(stop)
mkarlsso 0:8dbd6bd9167f 2309 } else if (tokens[i].find("sound(") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2310 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2311 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2312 lineError = true;
mkarlsso 0:8dbd6bd9167f 2313 }
mkarlsso 0:8dbd6bd9167f 2314 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2315 int pos1 = tmpLine.find("sound(")+6;
mkarlsso 0:8dbd6bd9167f 2316 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 6:67d67d452545 2317 if (pos2 == std::string::npos) {
mkarlsso 6:67d67d452545 2318 textDisplay << "Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2319 lineError = true;
mkarlsso 0:8dbd6bd9167f 2320 }
mkarlsso 6:67d67d452545 2321
mkarlsso 6:67d67d452545 2322 if (!lineError) {
mkarlsso 6:67d67d452545 2323 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 6:67d67d452545 2324
mkarlsso 6:67d67d452545 2325 int* tmpVar = findIntVariable(dispVar);
mkarlsso 6:67d67d452545 2326 bool isText = false;
mkarlsso 6:67d67d452545 2327 bool stopSignal = false;
mkarlsso 6:67d67d452545 2328 bool resetSignal = false;
mkarlsso 6:67d67d452545 2329 if (tmpVar == NULL) {
mkarlsso 6:67d67d452545 2330 if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso 6:67d67d452545 2331 isText = true;
mkarlsso 6:67d67d452545 2332 } else if (dispVar.compare("stop") == 0) {
mkarlsso 6:67d67d452545 2333 stopSignal = true;
mkarlsso 6:67d67d452545 2334 } else if (dispVar.compare("reset") == 0) {
mkarlsso 6:67d67d452545 2335 resetSignal = true;
mkarlsso 0:8dbd6bd9167f 2336 } else {
mkarlsso 6:67d67d452545 2337 textDisplay << "Error: variable input to sound() does not exist\r\n";
mkarlsso 0:8dbd6bd9167f 2338 lineError = true;
mkarlsso 0:8dbd6bd9167f 2339 }
mkarlsso 6:67d67d452545 2340 }
mkarlsso 6:67d67d452545 2341 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 6:67d67d452545 2342 if (tmpAction == NULL) {
mkarlsso 6:67d67d452545 2343 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2344 lineError = true;
mkarlsso 0:8dbd6bd9167f 2345 }
mkarlsso 6:67d67d452545 2346 if (!lineError && (blockDepth == 0)) {
mkarlsso 6:67d67d452545 2347 //we are not inside a block structure, so play sound now
mkarlsso 6:67d67d452545 2348 if (stopSignal) {
mkarlsso 6:67d67d452545 2349 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2350 S->setPlayback(false);
mkarlsso 6:67d67d452545 2351 S->execute();
mkarlsso 6:67d67d452545 2352 delete S;
mkarlsso 6:67d67d452545 2353 } else if (resetSignal) {
mkarlsso 6:67d67d452545 2354 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2355 S->setReset();
mkarlsso 6:67d67d452545 2356 S->execute();
mkarlsso 6:67d67d452545 2357 delete S;
mkarlsso 6:67d67d452545 2358 } else if (isText) {
mkarlsso 6:67d67d452545 2359
mkarlsso 6:67d67d452545 2360 if (pos2-pos1-2 <= 20) {
mkarlsso 6:67d67d452545 2361
mkarlsso 6:67d67d452545 2362 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2363 S->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 6:67d67d452545 2364 S->execute();
mkarlsso 6:67d67d452545 2365 delete S;
mkarlsso 6:67d67d452545 2366 } else {
mkarlsso 6:67d67d452545 2367 textDisplay << "Error: sound file names must be 20 characters or less.\r\n";
mkarlsso 6:67d67d452545 2368 lineError = true;
mkarlsso 6:67d67d452545 2369 }
mkarlsso 6:67d67d452545 2370 } else {
mkarlsso 6:67d67d452545 2371 textDisplay << "Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n";
mkarlsso 6:67d67d452545 2372 lineError = true;
mkarlsso 6:67d67d452545 2373 }
mkarlsso 6:67d67d452545 2374
mkarlsso 6:67d67d452545 2375 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 6:67d67d452545 2376 //the disp function was put inside a block
mkarlsso 6:67d67d452545 2377 textDisplay.debug("Sound statement\r\n");
mkarlsso 6:67d67d452545 2378 if (stopSignal) {
mkarlsso 0:8dbd6bd9167f 2379 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2380 sPtr->setPlayback(false);
mkarlsso 0:8dbd6bd9167f 2381 //action* tmpAction = new action(sPtr);
mkarlsso 0:8dbd6bd9167f 2382 tmpAction->set(sPtr);
mkarlsso 0:8dbd6bd9167f 2383 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2384 } else if (resetSignal) {
mkarlsso 6:67d67d452545 2385 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2386 sPtr->setReset();
mkarlsso 6:67d67d452545 2387 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2388 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2389 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2390 } else if (isText) {
mkarlsso 6:67d67d452545 2391
mkarlsso 6:67d67d452545 2392 if (pos2-pos1-2 <= 20) {
mkarlsso 6:67d67d452545 2393 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2394 sPtr->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 6:67d67d452545 2395 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2396 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2397 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2398 } else {
mkarlsso 6:67d67d452545 2399 textDisplay << "Error: sound file names must be 20 characters or less.\r\n";
mkarlsso 6:67d67d452545 2400 lineError = true;
mkarlsso 6:67d67d452545 2401 }
mkarlsso 0:8dbd6bd9167f 2402 } else {
mkarlsso 6:67d67d452545 2403 textDisplay << "Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n";
mkarlsso 0:8dbd6bd9167f 2404 lineError = true;
mkarlsso 0:8dbd6bd9167f 2405 }
mkarlsso 6:67d67d452545 2406
mkarlsso 6:67d67d452545 2407
mkarlsso 0:8dbd6bd9167f 2408 }
mkarlsso 0:8dbd6bd9167f 2409 }
mkarlsso 0:8dbd6bd9167f 2410
mkarlsso 0:8dbd6bd9167f 2411 } else if (tokens[i].find("volume(") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2412 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2413 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2414 lineError = true;
mkarlsso 0:8dbd6bd9167f 2415 }
mkarlsso 0:8dbd6bd9167f 2416 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2417 int pos1 = tmpLine.find("volume(")+7;
mkarlsso 0:8dbd6bd9167f 2418 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 6:67d67d452545 2419 if (pos2 == std::string::npos) {
mkarlsso 6:67d67d452545 2420 textDisplay << "Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2421 lineError = true;
mkarlsso 0:8dbd6bd9167f 2422 }
mkarlsso 6:67d67d452545 2423 if (!lineError) {
mkarlsso 6:67d67d452545 2424 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 6:67d67d452545 2425
mkarlsso 6:67d67d452545 2426 int* tmpVar = findIntVariable(dispVar);
mkarlsso 6:67d67d452545 2427 bool isText = false;
mkarlsso 6:67d67d452545 2428 if (tmpVar == NULL) {
mkarlsso 6:67d67d452545 2429 if (isNumber(dispVar)) {
mkarlsso 6:67d67d452545 2430 isText = true;
mkarlsso 0:8dbd6bd9167f 2431 } else {
mkarlsso 6:67d67d452545 2432 textDisplay << "Error: variable input to volume() does not exist\r\n";
mkarlsso 0:8dbd6bd9167f 2433 lineError = true;
mkarlsso 0:8dbd6bd9167f 2434 }
mkarlsso 6:67d67d452545 2435 }
mkarlsso 6:67d67d452545 2436 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 6:67d67d452545 2437 if (tmpAction == NULL) {
mkarlsso 6:67d67d452545 2438 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 6:67d67d452545 2439 lineError = true;
mkarlsso 0:8dbd6bd9167f 2440 }
mkarlsso 6:67d67d452545 2441 if (!lineError && (blockDepth == 0)) {
mkarlsso 6:67d67d452545 2442 //we are not inside a block structure, so play sound now
mkarlsso 6:67d67d452545 2443 if (isText) {
mkarlsso 6:67d67d452545 2444 int newVolume = atoi(dispVar.data());
mkarlsso 6:67d67d452545 2445 if ((newVolume >=0)&&(newVolume <= 255)) {
mkarlsso 6:67d67d452545 2446 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2447 S->setVolume(newVolume);
mkarlsso 6:67d67d452545 2448 S->execute();
mkarlsso 6:67d67d452545 2449 delete S;
mkarlsso 6:67d67d452545 2450 } else {
mkarlsso 6:67d67d452545 2451 textDisplay << "Error: sound volume must be between 0 and 255 .\r\n";
mkarlsso 6:67d67d452545 2452 lineError = true;
mkarlsso 6:67d67d452545 2453 }
mkarlsso 6:67d67d452545 2454 } else {
mkarlsso 6:67d67d452545 2455 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2456 S->setVolume(tmpVar);
mkarlsso 6:67d67d452545 2457 S->execute();
mkarlsso 6:67d67d452545 2458 delete S;
mkarlsso 6:67d67d452545 2459 }
mkarlsso 6:67d67d452545 2460
mkarlsso 6:67d67d452545 2461 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 6:67d67d452545 2462 //the disp function was put inside a block
mkarlsso 6:67d67d452545 2463 textDisplay.debug("Volume statement\r\n");
mkarlsso 6:67d67d452545 2464 if (isText) {
mkarlsso 6:67d67d452545 2465 int newVolume = atoi(dispVar.data());
mkarlsso 6:67d67d452545 2466
mkarlsso 6:67d67d452545 2467 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2468 sPtr->setVolume(newVolume);
mkarlsso 6:67d67d452545 2469
mkarlsso 6:67d67d452545 2470 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2471 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2472 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2473
mkarlsso 6:67d67d452545 2474 } else {
mkarlsso 6:67d67d452545 2475 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2476 sPtr->setVolume(tmpVar);
mkarlsso 6:67d67d452545 2477 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2478 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2479 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2480 }
mkarlsso 6:67d67d452545 2481
mkarlsso 6:67d67d452545 2482
mkarlsso 0:8dbd6bd9167f 2483 }
mkarlsso 0:8dbd6bd9167f 2484 }
mkarlsso 0:8dbd6bd9167f 2485 //clock statement used to is used to control the clock-------------------------
mkarlsso 0:8dbd6bd9167f 2486 //example: clock(reset); clock(slave); clock(standalone)
mkarlsso 0:8dbd6bd9167f 2487 } else if (tokens[i].find("clock(") != std::string::npos) { //clock commands
mkarlsso 0:8dbd6bd9167f 2488 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2489 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2490 lineError = true;
mkarlsso 0:8dbd6bd9167f 2491 }
mkarlsso 0:8dbd6bd9167f 2492 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 2493 textDisplay << "Error: clock commands only allowed outside of block structure\r\n";
mkarlsso 0:8dbd6bd9167f 2494 lineError = true;
mkarlsso 0:8dbd6bd9167f 2495 }
mkarlsso 5:abee20c0bf2a 2496 int pos1 = tmpLine.find("clock(")+6;
mkarlsso 5:abee20c0bf2a 2497 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 5:abee20c0bf2a 2498 if (pos2 == std::string::npos) {
mkarlsso 5:abee20c0bf2a 2499 textDisplay << "Syntax Error: expected a ')'\r\n";
mkarlsso 5:abee20c0bf2a 2500 lineError = true;
mkarlsso 5:abee20c0bf2a 2501 }
mkarlsso 0:8dbd6bd9167f 2502
mkarlsso 0:8dbd6bd9167f 2503 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2504 //int pos1 = tmpLine.find("clock(")+6;
mkarlsso 5:abee20c0bf2a 2505 //int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 2506 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 0:8dbd6bd9167f 2507
mkarlsso 0:8dbd6bd9167f 2508
mkarlsso 0:8dbd6bd9167f 2509 if (blockDepth == 0) {
mkarlsso 0:8dbd6bd9167f 2510 if (dispVar.compare("reset") == 0) {
mkarlsso 0:8dbd6bd9167f 2511 resetTimer = true;
mkarlsso 0:8dbd6bd9167f 2512 queuePtr->eraseQueue();
mkarlsso 0:8dbd6bd9167f 2513 textDisplay.send(string("Clock reset to 0\r\n"));
mkarlsso 0:8dbd6bd9167f 2514
mkarlsso 0:8dbd6bd9167f 2515 } else if (dispVar.compare("slave") == 0) {
mkarlsso 0:8dbd6bd9167f 2516 if (!clockSlave) {
mkarlsso 0:8dbd6bd9167f 2517 changeToSlave = true;
mkarlsso 0:8dbd6bd9167f 2518 textDisplay.send(string("Slave mode\r\n"));
mkarlsso 0:8dbd6bd9167f 2519
mkarlsso 0:8dbd6bd9167f 2520 }
mkarlsso 0:8dbd6bd9167f 2521 } else if (dispVar.compare("standalone") == 0) {
mkarlsso 0:8dbd6bd9167f 2522 if (clockSlave) {
mkarlsso 0:8dbd6bd9167f 2523 changeToStandAlone = true;
mkarlsso 0:8dbd6bd9167f 2524 textDisplay.send(string("Standalone mode\r\n"));
mkarlsso 0:8dbd6bd9167f 2525
mkarlsso 0:8dbd6bd9167f 2526 }
mkarlsso 0:8dbd6bd9167f 2527 } else if (dispVar.compare("") == 0) {
mkarlsso 0:8dbd6bd9167f 2528 //The user needs the current time displayed.
mkarlsso 0:8dbd6bd9167f 2529
mkarlsso 0:8dbd6bd9167f 2530 //textDisplay.send(string("Current Clock\r\n"));
mkarlsso 0:8dbd6bd9167f 2531 textDisplay << timeKeeper << " current time\r\n";
mkarlsso 0:8dbd6bd9167f 2532 } else {
mkarlsso 0:8dbd6bd9167f 2533 textDisplay << "Error: Clock control statement not understood\r\n";
mkarlsso 0:8dbd6bd9167f 2534 lineError = true;
mkarlsso 0:8dbd6bd9167f 2535 }
mkarlsso 0:8dbd6bd9167f 2536 }
mkarlsso 0:8dbd6bd9167f 2537 }
mkarlsso 0:8dbd6bd9167f 2538
mkarlsso 0:8dbd6bd9167f 2539 //disp command used to display text via serial---------------------------------------
mkarlsso 0:8dbd6bd9167f 2540 //example: disp('hello'); disp(myVar)
mkarlsso 0:8dbd6bd9167f 2541 } else if (tokens[i].find("disp(") != std::string::npos) { //display value of variable
mkarlsso 0:8dbd6bd9167f 2542
mkarlsso 0:8dbd6bd9167f 2543 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2544 textDisplay <<"Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2545 lineError = true;
mkarlsso 0:8dbd6bd9167f 2546 }
mkarlsso 0:8dbd6bd9167f 2547
mkarlsso 0:8dbd6bd9167f 2548 //int pos1 = tokens[i].find("disp(")+5;
mkarlsso 0:8dbd6bd9167f 2549 //int pos2 = tokens[i].find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 2550 //string dispVar = tokens[i].substr(pos1,pos2-pos1);
mkarlsso 0:8dbd6bd9167f 2551
mkarlsso 0:8dbd6bd9167f 2552 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2553 int pos1 = tmpLine.find("disp(")+5;
mkarlsso 0:8dbd6bd9167f 2554 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 2555 if (pos2 == std::string::npos) {
mkarlsso 6:67d67d452545 2556 textDisplay <<"Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2557 lineError = true;
mkarlsso 0:8dbd6bd9167f 2558 }
mkarlsso 3:d7b0a0890d96 2559
mkarlsso 0:8dbd6bd9167f 2560 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2561 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 3:d7b0a0890d96 2562
mkarlsso 0:8dbd6bd9167f 2563 int* tmpVar = findIntVariable(dispVar);
mkarlsso 0:8dbd6bd9167f 2564 bool isText = false;
mkarlsso 0:8dbd6bd9167f 2565 if (tmpVar == NULL) {
mkarlsso 0:8dbd6bd9167f 2566 if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso 0:8dbd6bd9167f 2567 isText = true;
mkarlsso 0:8dbd6bd9167f 2568 } else {
mkarlsso 0:8dbd6bd9167f 2569 textDisplay << "Error: variable to display does not exist\r\n";
mkarlsso 0:8dbd6bd9167f 2570 lineError = true;
mkarlsso 0:8dbd6bd9167f 2571 }
mkarlsso 0:8dbd6bd9167f 2572 }
mkarlsso 0:8dbd6bd9167f 2573 displayAction* dPtr = findFirstUnUsed(displayActionBlock, NUMDISPLAYACTIONS);
mkarlsso 0:8dbd6bd9167f 2574 if (dPtr == NULL) {
mkarlsso 0:8dbd6bd9167f 2575 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2576 lineError = true;
mkarlsso 0:8dbd6bd9167f 2577 }
mkarlsso 3:d7b0a0890d96 2578
mkarlsso 0:8dbd6bd9167f 2579 if (!lineError && (blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 2580 //we are not inside a block structure, so display now
mkarlsso 3:d7b0a0890d96 2581
mkarlsso 0:8dbd6bd9167f 2582 if (isText) {
mkarlsso 0:8dbd6bd9167f 2583 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 0:8dbd6bd9167f 2584 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 0:8dbd6bd9167f 2585 dPtr->execute();
mkarlsso 0:8dbd6bd9167f 2586 //delete dPtr;
mkarlsso 0:8dbd6bd9167f 2587 dPtr->release();
mkarlsso 0:8dbd6bd9167f 2588 } else {
mkarlsso 0:8dbd6bd9167f 2589 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 0:8dbd6bd9167f 2590 dPtr->set(tmpVar, dispVar);
mkarlsso 0:8dbd6bd9167f 2591 dPtr->execute();
mkarlsso 0:8dbd6bd9167f 2592 //delete dPtr;
mkarlsso 0:8dbd6bd9167f 2593 dPtr->release();
mkarlsso 0:8dbd6bd9167f 2594 }
mkarlsso 3:d7b0a0890d96 2595
mkarlsso 0:8dbd6bd9167f 2596 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 0:8dbd6bd9167f 2597 //the disp function was put inside a block
mkarlsso 0:8dbd6bd9167f 2598 textDisplay.debug("Display statement\r\n");
mkarlsso 0:8dbd6bd9167f 2599 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2600 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2601 textDisplay <<"Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2602 lineError = true;
mkarlsso 0:8dbd6bd9167f 2603 }
mkarlsso 0:8dbd6bd9167f 2604 if (!lineError && isText) {
mkarlsso 0:8dbd6bd9167f 2605 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 0:8dbd6bd9167f 2606 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 0:8dbd6bd9167f 2607 tmpAction->set(dPtr);
mkarlsso 0:8dbd6bd9167f 2608 //action* tmpAction = new action(dPtr);
mkarlsso 0:8dbd6bd9167f 2609 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2610 } else if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2611 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 0:8dbd6bd9167f 2612 dPtr->set(tmpVar, dispVar);
mkarlsso 0:8dbd6bd9167f 2613 tmpAction->set(dPtr);
mkarlsso 0:8dbd6bd9167f 2614 //action* tmpAction = new action(dPtr);
mkarlsso 0:8dbd6bd9167f 2615 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2616 }
mkarlsso 3:d7b0a0890d96 2617
mkarlsso 3:d7b0a0890d96 2618
mkarlsso 0:8dbd6bd9167f 2619 }
mkarlsso 0:8dbd6bd9167f 2620 }
mkarlsso 0:8dbd6bd9167f 2621 //----------------------------------------------
mkarlsso 0:8dbd6bd9167f 2622 //The trigger command is used like this:
mkarlsso 0:8dbd6bd9167f 2623 //trigger(n)
mkarlsso 0:8dbd6bd9167f 2624 //Where n is an integer corresponding to a "function n" block
mkarlsso 0:8dbd6bd9167f 2625 //When "trigger" is called, the corresponding function is executed.
mkarlsso 0:8dbd6bd9167f 2626 } else if (tokens[i].find("trigger(") != std::string::npos) { //trigger a function
mkarlsso 0:8dbd6bd9167f 2627
mkarlsso 0:8dbd6bd9167f 2628 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2629 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2630 lineError = true;
mkarlsso 0:8dbd6bd9167f 2631 }
mkarlsso 0:8dbd6bd9167f 2632
mkarlsso 0:8dbd6bd9167f 2633
mkarlsso 0:8dbd6bd9167f 2634 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2635 int pos1 = tmpLine.find("trigger(")+8;
mkarlsso 0:8dbd6bd9167f 2636 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 5:abee20c0bf2a 2637 if (pos2 == std::string::npos) {
mkarlsso 5:abee20c0bf2a 2638 textDisplay << "Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2639 lineError = true;
mkarlsso 0:8dbd6bd9167f 2640 }
mkarlsso 0:8dbd6bd9167f 2641
mkarlsso 5:abee20c0bf2a 2642 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2643 int funcNum = atoi(tmpLine.substr(pos1,pos2-pos1).data());
mkarlsso 5:abee20c0bf2a 2644 if ((funcNum > 0) && (funcNum < NUMFUNCTIONS+1)) {
mkarlsso 6:67d67d452545 2645 if (functionSpotTaken[funcNum-1] && functionEventArray[funcNum-1]->isUsed) {
mkarlsso 5:abee20c0bf2a 2646
mkarlsso 5:abee20c0bf2a 2647
mkarlsso 5:abee20c0bf2a 2648 } else {
mkarlsso 5:abee20c0bf2a 2649 textDisplay << "Error: function number does not exist\r\n";
mkarlsso 5:abee20c0bf2a 2650 lineError = true;
mkarlsso 5:abee20c0bf2a 2651 }
mkarlsso 5:abee20c0bf2a 2652 } else {
mkarlsso 5:abee20c0bf2a 2653 textDisplay << "Error: not a valid function number\r\n";
mkarlsso 0:8dbd6bd9167f 2654 lineError = true;
mkarlsso 0:8dbd6bd9167f 2655 }
mkarlsso 0:8dbd6bd9167f 2656
mkarlsso 5:abee20c0bf2a 2657 funcNum--; //change to 0-based index
mkarlsso 5:abee20c0bf2a 2658 if (!lineError && (blockDepth == 0)) {
mkarlsso 5:abee20c0bf2a 2659 //we are not inside a block structure, so execute function now
mkarlsso 5:abee20c0bf2a 2660 //textDisplay << "Exectuting function";
mkarlsso 5:abee20c0bf2a 2661 //textDisplay.flush();
mkarlsso 5:abee20c0bf2a 2662
mkarlsso 5:abee20c0bf2a 2663 functionEventArray[funcNum]->execute();
mkarlsso 5:abee20c0bf2a 2664
mkarlsso 5:abee20c0bf2a 2665 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 5:abee20c0bf2a 2666 //the trigger function was put inside a block, so we need to create a new action
mkarlsso 5:abee20c0bf2a 2667 textDisplay.debug("Trigger statement\r\n");
mkarlsso 5:abee20c0bf2a 2668 triggerFunctionAction* tPtr = findFirstUnUsed(triggerFunctionActionBlock, NUMTRIGGERACTIONS);
mkarlsso 5:abee20c0bf2a 2669 if (tPtr == NULL) {
mkarlsso 0:8dbd6bd9167f 2670 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2671 lineError = true;
mkarlsso 0:8dbd6bd9167f 2672 }
mkarlsso 5:abee20c0bf2a 2673
mkarlsso 0:8dbd6bd9167f 2674 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2675 //we only give provide it the function number, instead
mkarlsso 5:abee20c0bf2a 2676 //of a pointer to the event. That way, if the user modifies
mkarlsso 5:abee20c0bf2a 2677 //the function (which would change the pointer), all callbacks
mkarlsso 5:abee20c0bf2a 2678 //still using that function number will use the new function.
mkarlsso 5:abee20c0bf2a 2679 tPtr->set(funcNum);
mkarlsso 5:abee20c0bf2a 2680 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 5:abee20c0bf2a 2681 if (tmpAction == NULL) {
mkarlsso 5:abee20c0bf2a 2682 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 5:abee20c0bf2a 2683 lineError = true;
mkarlsso 5:abee20c0bf2a 2684 }
mkarlsso 5:abee20c0bf2a 2685 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2686
mkarlsso 5:abee20c0bf2a 2687 tmpAction->set(tPtr);
mkarlsso 5:abee20c0bf2a 2688 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 5:abee20c0bf2a 2689 }
mkarlsso 0:8dbd6bd9167f 2690 }
mkarlsso 5:abee20c0bf2a 2691
mkarlsso 5:abee20c0bf2a 2692
mkarlsso 0:8dbd6bd9167f 2693 }
mkarlsso 0:8dbd6bd9167f 2694
mkarlsso 0:8dbd6bd9167f 2695 }
mkarlsso 0:8dbd6bd9167f 2696
mkarlsso 0:8dbd6bd9167f 2697
mkarlsso 0:8dbd6bd9167f 2698 //int is used to decalar new variables. Only allowed outside of callbacks-------------------
mkarlsso 0:8dbd6bd9167f 2699 //example: int a; int b = 9
alustig3 4:b019c133a8fb 2700 }else if(tokens[i].compare("kaboom") == 0){//send "kaboom;" to reset mbed
alustig3 4:b019c133a8fb 2701 mbed_reset();
alustig3 4:b019c133a8fb 2702 }else if (tokens[i].compare("int") == 0) { //define a new integer variable
mkarlsso 0:8dbd6bd9167f 2703 textDisplay.debug("Int statement\r\n");
mkarlsso 0:8dbd6bd9167f 2704 if (ifBlockInit || whileBlockInit || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2705 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2706 lineError = true;
mkarlsso 0:8dbd6bd9167f 2707 }
mkarlsso 0:8dbd6bd9167f 2708 tmpString = "";
mkarlsso 0:8dbd6bd9167f 2709 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2710 int spacesBeforeEqualSign = 0;
mkarlsso 0:8dbd6bd9167f 2711 bool countSpaces = true;
mkarlsso 0:8dbd6bd9167f 2712 //combine the tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 2713 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 2714 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 2715 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2716 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 2717 countSpaces = false;
mkarlsso 0:8dbd6bd9167f 2718 } else if (countSpaces) {
mkarlsso 0:8dbd6bd9167f 2719 spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 2720 }
mkarlsso 0:8dbd6bd9167f 2721 }
mkarlsso 0:8dbd6bd9167f 2722
mkarlsso 0:8dbd6bd9167f 2723 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 2724 textDisplay << "Error: Variables can only be first declared outside of callbacks.\r\n";
mkarlsso 0:8dbd6bd9167f 2725 lineError = true;
mkarlsso 0:8dbd6bd9167f 2726 }
mkarlsso 0:8dbd6bd9167f 2727
mkarlsso 0:8dbd6bd9167f 2728 if ((!lineError) && (spacesBeforeEqualSign > 1)) {
mkarlsso 0:8dbd6bd9167f 2729 textDisplay << "Error: Variable can't have a space in it.\r\n";
mkarlsso 0:8dbd6bd9167f 2730 lineError = true;
mkarlsso 0:8dbd6bd9167f 2731 }
mkarlsso 0:8dbd6bd9167f 2732 stringInd = tmpString.find_first_of("=");
mkarlsso 0:8dbd6bd9167f 2733
mkarlsso 0:8dbd6bd9167f 2734 bool variableCreated = false;
mkarlsso 0:8dbd6bd9167f 2735 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2736 if (((stringInd == std::string::npos) && (sz == 2)) || (stringInd != std::string::npos)) {
mkarlsso 0:8dbd6bd9167f 2737
mkarlsso 0:8dbd6bd9167f 2738 if ((stringInd != std::string::npos) && (stringInd > MAXVARNAMESIZE)) {
mkarlsso 0:8dbd6bd9167f 2739 textDisplay << "Error: variable names must be under 30 characters.\r\n";
mkarlsso 0:8dbd6bd9167f 2740 lineError = true;
mkarlsso 0:8dbd6bd9167f 2741 } else if (createIntVariable(tmpString.substr(0,stringInd))) {
mkarlsso 0:8dbd6bd9167f 2742 textDisplay.debug("Created new variable\r\n");
mkarlsso 0:8dbd6bd9167f 2743 variableCreated = true;
mkarlsso 0:8dbd6bd9167f 2744 } else {
mkarlsso 0:8dbd6bd9167f 2745 textDisplay.debug("Attempting to use existing variable\r\n");
mkarlsso 0:8dbd6bd9167f 2746 int* tmpVar = findIntVariable(tmpString.substr(0,stringInd));
mkarlsso 0:8dbd6bd9167f 2747 *tmpVar = 0;
mkarlsso 0:8dbd6bd9167f 2748 //lineError = true;
mkarlsso 0:8dbd6bd9167f 2749 }
mkarlsso 0:8dbd6bd9167f 2750 } else {
mkarlsso 0:8dbd6bd9167f 2751 textDisplay << "Error: variable declaration not understood.\r\n";
mkarlsso 0:8dbd6bd9167f 2752 lineError = true;
mkarlsso 0:8dbd6bd9167f 2753 }
mkarlsso 0:8dbd6bd9167f 2754 }
mkarlsso 0:8dbd6bd9167f 2755 if ((!lineError) && (stringInd != std::string::npos)) { //evaluate the expression
mkarlsso 0:8dbd6bd9167f 2756 //action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 0:8dbd6bd9167f 2757 action* tmpAction = evaluateAssignmentForAction(tmpString.data());
mkarlsso 0:8dbd6bd9167f 2758 if (tmpAction != NULL) {
mkarlsso 0:8dbd6bd9167f 2759 tmpAction->execute();
mkarlsso 0:8dbd6bd9167f 2760 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 2761 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 2762 } else {
mkarlsso 0:8dbd6bd9167f 2763 lineError = true;
mkarlsso 0:8dbd6bd9167f 2764 if (variableCreated) {
mkarlsso 0:8dbd6bd9167f 2765 delete globalVariables.back();
mkarlsso 0:8dbd6bd9167f 2766 globalVariables.pop_back();
mkarlsso 0:8dbd6bd9167f 2767 }
mkarlsso 0:8dbd6bd9167f 2768 }
mkarlsso 0:8dbd6bd9167f 2769 }
mkarlsso 0:8dbd6bd9167f 2770
mkarlsso 0:8dbd6bd9167f 2771 //serial command is used to toggle whether or not to buffer up output text----------------
mkarlsso 0:8dbd6bd9167f 2772 //examples: serial buffer; serial send
mkarlsso 0:8dbd6bd9167f 2773 } else if (tokens[i].compare("serial") == 0) {
mkarlsso 0:8dbd6bd9167f 2774 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2775 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2776 lineError = true;
mkarlsso 0:8dbd6bd9167f 2777 }
mkarlsso 0:8dbd6bd9167f 2778 bool stream = true;
mkarlsso 0:8dbd6bd9167f 2779 if ((!lineError)&&(i+1 < sz)){
mkarlsso 0:8dbd6bd9167f 2780 if (tokens[i+1].compare("buffer") == 0) {
mkarlsso 0:8dbd6bd9167f 2781 stream = false;
mkarlsso 0:8dbd6bd9167f 2782 } else if (tokens[i+1].compare("send") == 0) {
mkarlsso 0:8dbd6bd9167f 2783 stream = true;
mkarlsso 0:8dbd6bd9167f 2784 } else {
mkarlsso 0:8dbd6bd9167f 2785 textDisplay << "Error: 'serial' useage: 'serial buffer' or 'serial send'\r\n";
mkarlsso 0:8dbd6bd9167f 2786 lineError = true;
mkarlsso 0:8dbd6bd9167f 2787 }
mkarlsso 0:8dbd6bd9167f 2788 }
mkarlsso 0:8dbd6bd9167f 2789 i++;
mkarlsso 0:8dbd6bd9167f 2790 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 2791 if (stream) {
mkarlsso 0:8dbd6bd9167f 2792 textStreaming = true;
mkarlsso 0:8dbd6bd9167f 2793 } else {
mkarlsso 0:8dbd6bd9167f 2794 textStreaming = false;
mkarlsso 0:8dbd6bd9167f 2795 }
mkarlsso 0:8dbd6bd9167f 2796 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 2797 if (stream) {
mkarlsso 0:8dbd6bd9167f 2798 //action* tmpAction = new action(1); //code 1 = turn on text streaming
mkarlsso 0:8dbd6bd9167f 2799 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2800 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2801 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2802 lineError = true;
mkarlsso 0:8dbd6bd9167f 2803 } else {
mkarlsso 0:8dbd6bd9167f 2804 tmpAction->set(1);
mkarlsso 0:8dbd6bd9167f 2805 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2806 }
mkarlsso 0:8dbd6bd9167f 2807
mkarlsso 0:8dbd6bd9167f 2808 } else {
mkarlsso 0:8dbd6bd9167f 2809 //action* tmpAction = new action(2); //code 2 = turn on text buffering
mkarlsso 0:8dbd6bd9167f 2810 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2811 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2812 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2813 lineError = true;
mkarlsso 0:8dbd6bd9167f 2814 } else {
mkarlsso 0:8dbd6bd9167f 2815 tmpAction->set(2);
mkarlsso 0:8dbd6bd9167f 2816 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2817 }
mkarlsso 0:8dbd6bd9167f 2818 }
mkarlsso 0:8dbd6bd9167f 2819 }
mkarlsso 0:8dbd6bd9167f 2820
mkarlsso 0:8dbd6bd9167f 2821 //updates command toggles the DIO update messages upon a change------------------
mkarlsso 0:8dbd6bd9167f 2822 //examples: updates on; updates off
mkarlsso 6:67d67d452545 2823 //examples: updates on 3; updates off 3
mkarlsso 0:8dbd6bd9167f 2824 } else if (tokens[i].compare("updates") == 0) {
mkarlsso 0:8dbd6bd9167f 2825 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2826 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2827 lineError = true;
mkarlsso 0:8dbd6bd9167f 2828 }
mkarlsso 0:8dbd6bd9167f 2829 bool stream = true;
mkarlsso 3:d7b0a0890d96 2830 int specifiedPort = -1;
mkarlsso 0:8dbd6bd9167f 2831 if ((!lineError)&&(i+1 < sz)){
mkarlsso 0:8dbd6bd9167f 2832 if (tokens[i+1].compare("on") == 0) {
mkarlsso 0:8dbd6bd9167f 2833 stream = true;
mkarlsso 0:8dbd6bd9167f 2834 } else if (tokens[i+1].compare("off") == 0) {
mkarlsso 0:8dbd6bd9167f 2835 stream = false;
mkarlsso 0:8dbd6bd9167f 2836 } else {
mkarlsso 0:8dbd6bd9167f 2837 textDisplay << "Error: 'updates' useage: 'updates on' or 'updates off'\r\n";
mkarlsso 0:8dbd6bd9167f 2838 lineError = true;
mkarlsso 0:8dbd6bd9167f 2839 }
mkarlsso 0:8dbd6bd9167f 2840 }
mkarlsso 3:d7b0a0890d96 2841 if ((!lineError) && (i+2 < sz)) {
mkarlsso 3:d7b0a0890d96 2842 //There is a port specified
mkarlsso 3:d7b0a0890d96 2843 //int pos1 = tmpLine.find("trigger(")+8;
mkarlsso 3:d7b0a0890d96 2844 //int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 3:d7b0a0890d96 2845 int tempPort = atoi(tokens[i+2].data());
mkarlsso 3:d7b0a0890d96 2846 if (tempPort > 0) {
mkarlsso 3:d7b0a0890d96 2847 specifiedPort = tempPort-1;
mkarlsso 3:d7b0a0890d96 2848 } else {
mkarlsso 3:d7b0a0890d96 2849 textDisplay << "Error: 'updates' useage: 'updates on [port]' or 'updates off [port]'\r\n";
mkarlsso 3:d7b0a0890d96 2850 lineError = true;
mkarlsso 3:d7b0a0890d96 2851 }
mkarlsso 3:d7b0a0890d96 2852 i++;
mkarlsso 3:d7b0a0890d96 2853 }
mkarlsso 0:8dbd6bd9167f 2854 i++;
mkarlsso 0:8dbd6bd9167f 2855 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 2856 if (stream) {
mkarlsso 3:d7b0a0890d96 2857 //applies to all;
mkarlsso 0:8dbd6bd9167f 2858 broadCastStateChanges = true;
mkarlsso 3:d7b0a0890d96 2859 if (specifiedPort > -1) {
mkarlsso 3:d7b0a0890d96 2860 system->setPortUpdatesOn(specifiedPort);
mkarlsso 3:d7b0a0890d96 2861 } else {
mkarlsso 3:d7b0a0890d96 2862 for (int i=0;i<NUMPORTS;i++) {
mkarlsso 3:d7b0a0890d96 2863 system->setPortUpdatesOn(i);
mkarlsso 3:d7b0a0890d96 2864 }
mkarlsso 3:d7b0a0890d96 2865 }
mkarlsso 0:8dbd6bd9167f 2866 } else {
mkarlsso 3:d7b0a0890d96 2867 if (specifiedPort > -1) {
mkarlsso 3:d7b0a0890d96 2868 system->setPortUpdatesOff(specifiedPort);
mkarlsso 3:d7b0a0890d96 2869 } else {
mkarlsso 3:d7b0a0890d96 2870 //applies to all
mkarlsso 3:d7b0a0890d96 2871 //broadCastStateChanges = false;
mkarlsso 3:d7b0a0890d96 2872 for (int i=0;i<NUMPORTS;i++) {
mkarlsso 3:d7b0a0890d96 2873 system->setPortUpdatesOff(i);
mkarlsso 3:d7b0a0890d96 2874 }
mkarlsso 3:d7b0a0890d96 2875 }
mkarlsso 3:d7b0a0890d96 2876
mkarlsso 0:8dbd6bd9167f 2877 }
mkarlsso 0:8dbd6bd9167f 2878 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 3:d7b0a0890d96 2879 //Inside a block-- current no support here to specify a port
mkarlsso 3:d7b0a0890d96 2880
mkarlsso 0:8dbd6bd9167f 2881 if (stream) {
mkarlsso 0:8dbd6bd9167f 2882 //action* tmpAction = new action(3); //code 3 = turn on updates
mkarlsso 0:8dbd6bd9167f 2883 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2884 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2885 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2886 lineError = true;
mkarlsso 0:8dbd6bd9167f 2887 } else {
mkarlsso 0:8dbd6bd9167f 2888 tmpAction->set(3);
mkarlsso 0:8dbd6bd9167f 2889 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2890 }
mkarlsso 0:8dbd6bd9167f 2891 } else {
mkarlsso 0:8dbd6bd9167f 2892 //action* tmpAction = new action(4); //code 4 = turn off updates
mkarlsso 0:8dbd6bd9167f 2893 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2894 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2895 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2896 lineError = true;
mkarlsso 0:8dbd6bd9167f 2897 } else {
mkarlsso 0:8dbd6bd9167f 2898 tmpAction->set(4);
mkarlsso 0:8dbd6bd9167f 2899 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2900 }
mkarlsso 0:8dbd6bd9167f 2901
mkarlsso 0:8dbd6bd9167f 2902 }
mkarlsso 0:8dbd6bd9167f 2903 }
mkarlsso 0:8dbd6bd9167f 2904
mkarlsso 0:8dbd6bd9167f 2905 } else if (tokens[i].compare("memory") == 0) {
mkarlsso 0:8dbd6bd9167f 2906 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2907 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2908 lineError = true;
mkarlsso 0:8dbd6bd9167f 2909 }
mkarlsso 0:8dbd6bd9167f 2910 if ((!lineError) && (blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 2911 textDisplay << "Error: memory statement is not allowed inside a block.\r\n";
mkarlsso 0:8dbd6bd9167f 2912 lineError = true;
mkarlsso 0:8dbd6bd9167f 2913 }
mkarlsso 0:8dbd6bd9167f 2914 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2915 displayMemoryLeft();
mkarlsso 0:8dbd6bd9167f 2916 }
mkarlsso 0:8dbd6bd9167f 2917
mkarlsso 0:8dbd6bd9167f 2918
mkarlsso 0:8dbd6bd9167f 2919 //clear is used to clear things from memory---------------------------------
mkarlsso 0:8dbd6bd9167f 2920 //examples: clear all; clear callbacks; clear queue
mkarlsso 0:8dbd6bd9167f 2921
mkarlsso 0:8dbd6bd9167f 2922 } else if (tokens[i].compare("clear") == 0) { //delete all created events and variables
mkarlsso 0:8dbd6bd9167f 2923 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2924 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2925 lineError = true;
mkarlsso 0:8dbd6bd9167f 2926 }
mkarlsso 0:8dbd6bd9167f 2927 int clearMode = 0;
mkarlsso 0:8dbd6bd9167f 2928 if ((!lineError)&&(i+1 < sz)){
mkarlsso 0:8dbd6bd9167f 2929 if (tokens[i+1].compare("all") == 0) {
mkarlsso 0:8dbd6bd9167f 2930 clearMode = 1;
mkarlsso 0:8dbd6bd9167f 2931 } else if (tokens[i+1].compare("blocks") == 0) {
mkarlsso 0:8dbd6bd9167f 2932 clearMode = 2;
mkarlsso 0:8dbd6bd9167f 2933 } else if (tokens[i+1].compare("queue") == 0) {
mkarlsso 0:8dbd6bd9167f 2934 clearMode = 3;
mkarlsso 0:8dbd6bd9167f 2935 } else {
mkarlsso 0:8dbd6bd9167f 2936 textDisplay << "Error: clear what: all, blocks, or queue? \r\n";
mkarlsso 0:8dbd6bd9167f 2937 lineError = true;
mkarlsso 0:8dbd6bd9167f 2938 }
mkarlsso 0:8dbd6bd9167f 2939 } else {
mkarlsso 0:8dbd6bd9167f 2940 textDisplay << "Error: clear what: all, blocks, or queue? \r\n";
mkarlsso 0:8dbd6bd9167f 2941 lineError = true;
mkarlsso 0:8dbd6bd9167f 2942 }
mkarlsso 0:8dbd6bd9167f 2943
mkarlsso 0:8dbd6bd9167f 2944
mkarlsso 0:8dbd6bd9167f 2945 if ((!lineError) && (clearMode < 3) && (blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 2946 textDisplay << "Error: 'clear all' and 'clear blocks' only allowed outside of block structures\r\n";
mkarlsso 0:8dbd6bd9167f 2947 lineError = true;
mkarlsso 0:8dbd6bd9167f 2948 }
mkarlsso 0:8dbd6bd9167f 2949 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2950 //i++;
mkarlsso 0:8dbd6bd9167f 2951 //clear variables
mkarlsso 5:abee20c0bf2a 2952
mkarlsso 0:8dbd6bd9167f 2953 if (clearMode == 1) {
mkarlsso 5:abee20c0bf2a 2954 //Clears everything
mkarlsso 5:abee20c0bf2a 2955 int sendClearMode = 0;
mkarlsso 5:abee20c0bf2a 2956 sendClearMode |= BLOCKMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2957 sendClearMode |= VARIABLEMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2958 sendClearMode |= ENVSETTINGSMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2959
mkarlsso 5:abee20c0bf2a 2960 clearEnvironmentVariables(sendClearMode);
mkarlsso 5:abee20c0bf2a 2961
mkarlsso 5:abee20c0bf2a 2962 } else if (clearMode == 2) {
mkarlsso 5:abee20c0bf2a 2963 //Clear just varaibles
mkarlsso 5:abee20c0bf2a 2964 int sendClearMode = 0;
mkarlsso 5:abee20c0bf2a 2965 sendClearMode |= VARIABLEMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2966 clearEnvironmentVariables(sendClearMode);
mkarlsso 5:abee20c0bf2a 2967
mkarlsso 5:abee20c0bf2a 2968 } else if (clearMode == 3) {
mkarlsso 5:abee20c0bf2a 2969 //Clear the current event queue (can itself be a queued action)
mkarlsso 0:8dbd6bd9167f 2970 if (blockDepth > 0) { //we are inside a block
mkarlsso 0:8dbd6bd9167f 2971 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2972 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2973 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2974 lineError = true;
mkarlsso 0:8dbd6bd9167f 2975 } else {
mkarlsso 0:8dbd6bd9167f 2976
mkarlsso 0:8dbd6bd9167f 2977 int8_t code = 0;
mkarlsso 0:8dbd6bd9167f 2978 tmpAction->set(code);
mkarlsso 0:8dbd6bd9167f 2979 //action* tmpAction = new action(code); //code 0 = clear queue
mkarlsso 0:8dbd6bd9167f 2980 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2981 }
mkarlsso 0:8dbd6bd9167f 2982 } else {
mkarlsso 0:8dbd6bd9167f 2983 //clear queue now
mkarlsso 0:8dbd6bd9167f 2984 queuePtr->eraseQueue();
mkarlsso 0:8dbd6bd9167f 2985 }
mkarlsso 0:8dbd6bd9167f 2986 }
mkarlsso 0:8dbd6bd9167f 2987 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2988
mkarlsso 0:8dbd6bd9167f 2989
mkarlsso 0:8dbd6bd9167f 2990 }
mkarlsso 0:8dbd6bd9167f 2991
mkarlsso 0:8dbd6bd9167f 2992 //do starts a block---------------------------------------------------------
mkarlsso 0:8dbd6bd9167f 2993 //example: do in 500
mkarlsso 0:8dbd6bd9167f 2994 // ...
mkarlsso 0:8dbd6bd9167f 2995 // end
mkarlsso 0:8dbd6bd9167f 2996
mkarlsso 0:8dbd6bd9167f 2997 } else if (tokens[i].compare("do") == 0) { //the start of a block
mkarlsso 0:8dbd6bd9167f 2998
mkarlsso 0:8dbd6bd9167f 2999 if (!ifBlockInit && !whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3000
mkarlsso 0:8dbd6bd9167f 3001 if ((currentTriggerPort > 0) || (currentFunction > -1)) { //check to make sure we are inside a trigger block
mkarlsso 0:8dbd6bd9167f 3002
mkarlsso 0:8dbd6bd9167f 3003
mkarlsso 0:8dbd6bd9167f 3004 } else {
mkarlsso 0:8dbd6bd9167f 3005 textDisplay << "Error: a statement block must be placed inside a callback or function.\r\n";
mkarlsso 0:8dbd6bd9167f 3006 lineError = true;
mkarlsso 0:8dbd6bd9167f 3007 }
mkarlsso 0:8dbd6bd9167f 3008
mkarlsso 0:8dbd6bd9167f 3009 }
mkarlsso 0:8dbd6bd9167f 3010 expectingDoStatement = false;
mkarlsso 0:8dbd6bd9167f 3011 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3012 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3013 bool eventReserved = false;
mkarlsso 0:8dbd6bd9167f 3014 if ((tmpEvent == NULL)||(tmpAction == NULL)) {
mkarlsso 0:8dbd6bd9167f 3015 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3016 lineError = true;
mkarlsso 0:8dbd6bd9167f 3017
mkarlsso 0:8dbd6bd9167f 3018 } else {
mkarlsso 0:8dbd6bd9167f 3019
mkarlsso 0:8dbd6bd9167f 3020
mkarlsso 0:8dbd6bd9167f 3021 }
mkarlsso 0:8dbd6bd9167f 3022
mkarlsso 0:8dbd6bd9167f 3023 if (i+2 < sz) { //a time delay in the block
mkarlsso 0:8dbd6bd9167f 3024
mkarlsso 0:8dbd6bd9167f 3025 if ((!lineError) && (tokens[i+1].compare("in") == 0) && (isNumber(tokens[i+2]))) {
mkarlsso 0:8dbd6bd9167f 3026 textDisplay.debug("Do in number statement\r\n");
mkarlsso 0:8dbd6bd9167f 3027 currentDelay = atoi(tokens[i+2].data());
mkarlsso 0:8dbd6bd9167f 3028 if (currentDelay < 0) {
mkarlsso 0:8dbd6bd9167f 3029 textDisplay <<"Error: block delay time must be a positive integer\r\n";
mkarlsso 0:8dbd6bd9167f 3030 lineError = true;
mkarlsso 0:8dbd6bd9167f 3031 } else if (!ifBlockInit) { //a standalone do block
mkarlsso 0:8dbd6bd9167f 3032 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3033 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3034 eventReserved = true;
mkarlsso 0:8dbd6bd9167f 3035 tmpEvent->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3036
mkarlsso 0:8dbd6bd9167f 3037 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 0:8dbd6bd9167f 3038 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3039 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3040 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3041 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3042 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 0:8dbd6bd9167f 3043 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3044 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3045 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3046 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3047 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 0:8dbd6bd9167f 3048 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3049
mkarlsso 0:8dbd6bd9167f 3050 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3051 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3052 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 0:8dbd6bd9167f 3053 }
mkarlsso 0:8dbd6bd9167f 3054
mkarlsso 0:8dbd6bd9167f 3055 } else { //an if block
mkarlsso 0:8dbd6bd9167f 3056 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3057
mkarlsso 0:8dbd6bd9167f 3058 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3059 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 0:8dbd6bd9167f 3060 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3061 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3062 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 0:8dbd6bd9167f 3063 }
mkarlsso 0:8dbd6bd9167f 3064 } else if (elseFlag){
mkarlsso 0:8dbd6bd9167f 3065 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3066 } else if (thenFlag){
mkarlsso 0:8dbd6bd9167f 3067 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3068
mkarlsso 0:8dbd6bd9167f 3069 }
mkarlsso 0:8dbd6bd9167f 3070
mkarlsso 0:8dbd6bd9167f 3071
mkarlsso 0:8dbd6bd9167f 3072 }
mkarlsso 0:8dbd6bd9167f 3073
mkarlsso 0:8dbd6bd9167f 3074 } else if ((!lineError) && (tokens[i+1].compare("in") == 0) && (findIntVariable(tokens[i+2])!=NULL)) {
mkarlsso 0:8dbd6bd9167f 3075 textDisplay.debug("Do in VAR statement\r\n");
mkarlsso 0:8dbd6bd9167f 3076 int* delayVar = findIntVariable(tokens[i+2]);
mkarlsso 0:8dbd6bd9167f 3077 //currentDelay = atoi(tokens[i+2].data());
mkarlsso 0:8dbd6bd9167f 3078 if (!ifBlockInit) { //a standalone do block
mkarlsso 0:8dbd6bd9167f 3079 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3080 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3081 eventReserved = true;
mkarlsso 0:8dbd6bd9167f 3082 tmpEvent->setTimeLag(delayVar);
mkarlsso 0:8dbd6bd9167f 3083
mkarlsso 0:8dbd6bd9167f 3084 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 0:8dbd6bd9167f 3085 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3086 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3087 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3088 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3089 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 0:8dbd6bd9167f 3090 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3091 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3092 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3093 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3094 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 0:8dbd6bd9167f 3095 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3096
mkarlsso 0:8dbd6bd9167f 3097 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3098 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3099 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 0:8dbd6bd9167f 3100 }
mkarlsso 0:8dbd6bd9167f 3101
mkarlsso 0:8dbd6bd9167f 3102 } else { //an if block
mkarlsso 0:8dbd6bd9167f 3103 tmpEventPtrArray.back()->setTimeLag(delayVar);
mkarlsso 0:8dbd6bd9167f 3104
mkarlsso 0:8dbd6bd9167f 3105 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3106 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 0:8dbd6bd9167f 3107 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3108 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3109 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 0:8dbd6bd9167f 3110 }
mkarlsso 0:8dbd6bd9167f 3111 } else if (elseFlag){
mkarlsso 0:8dbd6bd9167f 3112 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3113 } else if (thenFlag){
mkarlsso 0:8dbd6bd9167f 3114 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3115
mkarlsso 0:8dbd6bd9167f 3116 }
mkarlsso 0:8dbd6bd9167f 3117
mkarlsso 0:8dbd6bd9167f 3118
mkarlsso 0:8dbd6bd9167f 3119 }
mkarlsso 0:8dbd6bd9167f 3120
mkarlsso 0:8dbd6bd9167f 3121 } else {
mkarlsso 0:8dbd6bd9167f 3122 textDisplay << "Error: block delay time must be a positive integer or a variable\r\n";
mkarlsso 0:8dbd6bd9167f 3123 lineError = true;
mkarlsso 0:8dbd6bd9167f 3124 }
mkarlsso 0:8dbd6bd9167f 3125 } else if (!lineError && !ifBlockInit) { //no time delay given, standalone do
mkarlsso 0:8dbd6bd9167f 3126 textDisplay.debug("Do statement\r\n");
mkarlsso 0:8dbd6bd9167f 3127 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3128 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3129 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3130 eventReserved = true;
mkarlsso 0:8dbd6bd9167f 3131 tmpEvent->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3132 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3133 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3134 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3135 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3136 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3137 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3138 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3139 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3140 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3141 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 0:8dbd6bd9167f 3142 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3143 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3144 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3145 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 0:8dbd6bd9167f 3146 }
mkarlsso 0:8dbd6bd9167f 3147
mkarlsso 0:8dbd6bd9167f 3148 } else if (!lineError) { //no time delay, if block
mkarlsso 0:8dbd6bd9167f 3149
mkarlsso 0:8dbd6bd9167f 3150 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3151 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3152
mkarlsso 0:8dbd6bd9167f 3153
mkarlsso 0:8dbd6bd9167f 3154 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3155 if (blockDepth > 1) {
mkarlsso 0:8dbd6bd9167f 3156 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3157 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3158 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 0:8dbd6bd9167f 3159 }
mkarlsso 0:8dbd6bd9167f 3160 } else {
mkarlsso 0:8dbd6bd9167f 3161 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3162 }
mkarlsso 0:8dbd6bd9167f 3163
mkarlsso 0:8dbd6bd9167f 3164 }
mkarlsso 0:8dbd6bd9167f 3165 if (lineError && eventReserved) {
mkarlsso 0:8dbd6bd9167f 3166 tmpEvent->release();
mkarlsso 0:8dbd6bd9167f 3167 }
mkarlsso 0:8dbd6bd9167f 3168 //close block initiation
mkarlsso 0:8dbd6bd9167f 3169 ifBlockInit = false;
mkarlsso 0:8dbd6bd9167f 3170 whileBlockInit = false;
mkarlsso 0:8dbd6bd9167f 3171 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3172 elseFlag = false;
mkarlsso 0:8dbd6bd9167f 3173 thenFlag = false;
mkarlsso 0:8dbd6bd9167f 3174
mkarlsso 0:8dbd6bd9167f 3175 //currently, there are two types of root-level blocks: functions and callbacks
mkarlsso 0:8dbd6bd9167f 3176 //
mkarlsso 0:8dbd6bd9167f 3177 //A function can be triggered with a command, a callback is tied to a hardware event
mkarlsso 0:8dbd6bd9167f 3178 } else if (tokens[i].compare("function") == 0) { //a new function block
mkarlsso 0:8dbd6bd9167f 3179 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3180 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3181 lineError = true;
mkarlsso 0:8dbd6bd9167f 3182 }
mkarlsso 0:8dbd6bd9167f 3183 if (blockDepth != 0) {
mkarlsso 0:8dbd6bd9167f 3184 textDisplay <<"Error: Can't declare a function block within another block\r\n";
mkarlsso 0:8dbd6bd9167f 3185 lineError = true;
mkarlsso 0:8dbd6bd9167f 3186 }
mkarlsso 0:8dbd6bd9167f 3187 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3188 textDisplay.debug("Function statement\r\n");
mkarlsso 0:8dbd6bd9167f 3189 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3190 if (i+1 < sz) {
mkarlsso 0:8dbd6bd9167f 3191 int tempFuncNum = atoi(tokens[i+1].data());
mkarlsso 0:8dbd6bd9167f 3192 if ((tempFuncNum > 0) && (tempFuncNum < NUMFUNCTIONS+1)) {
mkarlsso 0:8dbd6bd9167f 3193 currentFunction = tempFuncNum-1;
mkarlsso 0:8dbd6bd9167f 3194 } else {
mkarlsso 0:8dbd6bd9167f 3195 textDisplay << "Error: not a valid function number\r\n";
mkarlsso 0:8dbd6bd9167f 3196 lineError = true;
mkarlsso 0:8dbd6bd9167f 3197 }
mkarlsso 0:8dbd6bd9167f 3198 } else {
mkarlsso 0:8dbd6bd9167f 3199 if (!lineError) textDisplay << "Error: Not enough arguments for function statement\r\n";
mkarlsso 0:8dbd6bd9167f 3200 lineError = true;
mkarlsso 0:8dbd6bd9167f 3201 }
mkarlsso 0:8dbd6bd9167f 3202 if (sz > 2) {
mkarlsso 0:8dbd6bd9167f 3203 if (!((sz == 3) && (tokens[i+2].compare("do") == 0))) {
mkarlsso 0:8dbd6bd9167f 3204 textDisplay << "Error: Too many arguments in function statement\r\n";
mkarlsso 0:8dbd6bd9167f 3205 lineError = true;
mkarlsso 0:8dbd6bd9167f 3206 }
mkarlsso 0:8dbd6bd9167f 3207 }
mkarlsso 0:8dbd6bd9167f 3208
mkarlsso 0:8dbd6bd9167f 3209 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3210 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3211 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3212
mkarlsso 0:8dbd6bd9167f 3213 } else {
mkarlsso 0:8dbd6bd9167f 3214 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3215 lineError = true;
mkarlsso 0:8dbd6bd9167f 3216 }
mkarlsso 0:8dbd6bd9167f 3217 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3218
mkarlsso 0:8dbd6bd9167f 3219 blockDepth = 1;
mkarlsso 0:8dbd6bd9167f 3220 i = i+2;
mkarlsso 0:8dbd6bd9167f 3221 //create new event and attach it to the port
mkarlsso 0:8dbd6bd9167f 3222 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 0:8dbd6bd9167f 3223 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3224
mkarlsso 0:8dbd6bd9167f 3225 if (functionSpotTaken[currentFunction]) {
mkarlsso 0:8dbd6bd9167f 3226 functionEventArray[currentFunction]->release();
mkarlsso 0:8dbd6bd9167f 3227 }
mkarlsso 0:8dbd6bd9167f 3228 functionEventArray[currentFunction] = tmpEvent;
mkarlsso 0:8dbd6bd9167f 3229 functionSpotTaken[currentFunction] = true;
mkarlsso 0:8dbd6bd9167f 3230
mkarlsso 0:8dbd6bd9167f 3231 }
mkarlsso 0:8dbd6bd9167f 3232 }
mkarlsso 0:8dbd6bd9167f 3233
mkarlsso 0:8dbd6bd9167f 3234
mkarlsso 0:8dbd6bd9167f 3235 //callback starts a callback block------------------------------------------
mkarlsso 0:8dbd6bd9167f 3236 //exmaple: callback portin(1) down
mkarlsso 0:8dbd6bd9167f 3237 // ...
mkarlsso 0:8dbd6bd9167f 3238 // end
mkarlsso 0:8dbd6bd9167f 3239 } else if (tokens[i].compare("callback") == 0) { //a new callback block
mkarlsso 0:8dbd6bd9167f 3240 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3241 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3242 lineError = true;
mkarlsso 0:8dbd6bd9167f 3243 }
mkarlsso 0:8dbd6bd9167f 3244 if (blockDepth != 0) {
mkarlsso 0:8dbd6bd9167f 3245 textDisplay << "Error: Can't declare a callback block within another block\r\n";
mkarlsso 0:8dbd6bd9167f 3246 lineError = true;
mkarlsso 0:8dbd6bd9167f 3247 }
mkarlsso 0:8dbd6bd9167f 3248 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3249 textDisplay.debug("Callback statement\r\n");
mkarlsso 0:8dbd6bd9167f 3250 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3251 if (i+2 < sz) {
mkarlsso 0:8dbd6bd9167f 3252 if ((tokens[i+1].find("portin[") != std::string::npos) && (tokens[i+1].size() > 8) ) { //callback for a digital port
mkarlsso 0:8dbd6bd9167f 3253 int pos1 = tokens[i+1].find("portin[")+7;
mkarlsso 0:8dbd6bd9167f 3254 int pos2 = tokens[i+1].find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 3255 currentTriggerPort = atoi(tokens[i+1].substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3256
mkarlsso 0:8dbd6bd9167f 3257 if (currentTriggerPort <= 0) {
mkarlsso 0:8dbd6bd9167f 3258 currentTriggerPort = -1;
mkarlsso 0:8dbd6bd9167f 3259 textDisplay << "Error: Not a valid port number\r\n";
mkarlsso 0:8dbd6bd9167f 3260 lineError = true;
mkarlsso 0:8dbd6bd9167f 3261 }
mkarlsso 0:8dbd6bd9167f 3262 } else {
mkarlsso 0:8dbd6bd9167f 3263 textDisplay << "Error: Not a valid callback input\r\n";
mkarlsso 0:8dbd6bd9167f 3264 lineError = true;
mkarlsso 0:8dbd6bd9167f 3265 }
mkarlsso 0:8dbd6bd9167f 3266 if (tokens[i+2].compare("up") == 0) {
mkarlsso 0:8dbd6bd9167f 3267 currentTriggerDir = 1;
mkarlsso 0:8dbd6bd9167f 3268 } else if (tokens[i+2].compare("down") == 0) {
mkarlsso 0:8dbd6bd9167f 3269 currentTriggerDir = -1;
mkarlsso 0:8dbd6bd9167f 3270 } else {
mkarlsso 0:8dbd6bd9167f 3271 textDisplay << "Error: No trigger direction given\r\n";
mkarlsso 0:8dbd6bd9167f 3272 lineError = true;
mkarlsso 0:8dbd6bd9167f 3273 }
mkarlsso 0:8dbd6bd9167f 3274
mkarlsso 0:8dbd6bd9167f 3275 } else {
mkarlsso 0:8dbd6bd9167f 3276 if (!lineError) textDisplay << "Error: Not enough arguments for callback statement\r\n";
mkarlsso 0:8dbd6bd9167f 3277 lineError = true;
mkarlsso 0:8dbd6bd9167f 3278 }
mkarlsso 0:8dbd6bd9167f 3279 if (sz > 3) {
mkarlsso 0:8dbd6bd9167f 3280 if (!((sz == 4) && (tokens[i+3].compare("do") == 0))) {
mkarlsso 0:8dbd6bd9167f 3281 textDisplay << "Error: Too many arguments in callback statement\r\n";
mkarlsso 0:8dbd6bd9167f 3282 lineError = true;
mkarlsso 0:8dbd6bd9167f 3283 }
mkarlsso 0:8dbd6bd9167f 3284 }
mkarlsso 0:8dbd6bd9167f 3285
mkarlsso 0:8dbd6bd9167f 3286 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3287 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3288 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3289
mkarlsso 0:8dbd6bd9167f 3290 } else {
mkarlsso 0:8dbd6bd9167f 3291 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3292 lineError = true;
mkarlsso 0:8dbd6bd9167f 3293 }
mkarlsso 0:8dbd6bd9167f 3294 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3295
mkarlsso 0:8dbd6bd9167f 3296 blockDepth = 1;
mkarlsso 0:8dbd6bd9167f 3297 i = i+2;
mkarlsso 0:8dbd6bd9167f 3298 //create new event and attach it to the port
mkarlsso 0:8dbd6bd9167f 3299 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 0:8dbd6bd9167f 3300 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3301 if (currentTriggerDir == 1) {
mkarlsso 0:8dbd6bd9167f 3302
mkarlsso 0:8dbd6bd9167f 3303 portVector[currentTriggerPort-1].setTriggerUpEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3304 } else {
mkarlsso 0:8dbd6bd9167f 3305
mkarlsso 0:8dbd6bd9167f 3306 portVector[currentTriggerPort-1].setTriggerDownEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3307 }
mkarlsso 0:8dbd6bd9167f 3308
mkarlsso 0:8dbd6bd9167f 3309 }
mkarlsso 0:8dbd6bd9167f 3310 }
mkarlsso 0:8dbd6bd9167f 3311
mkarlsso 0:8dbd6bd9167f 3312 //if starts an if block----------------------------------------------
mkarlsso 0:8dbd6bd9167f 3313 //examples: if x < 10 && y == 1 do; if a==1 do in 1000
mkarlsso 0:8dbd6bd9167f 3314 } else if (tokens[i].compare("if") == 0) { //a new if block
mkarlsso 0:8dbd6bd9167f 3315 if (ifBlockInit || whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3316 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3317 lineError = true;
mkarlsso 0:8dbd6bd9167f 3318 }
mkarlsso 0:8dbd6bd9167f 3319
mkarlsso 0:8dbd6bd9167f 3320 ifBlockInit = true;
mkarlsso 0:8dbd6bd9167f 3321 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3322 bool eventDefined = false;
mkarlsso 0:8dbd6bd9167f 3323 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3324 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3325 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3326 eventDefined = true;
mkarlsso 0:8dbd6bd9167f 3327 } else {
mkarlsso 0:8dbd6bd9167f 3328 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3329 lineError = true;
mkarlsso 0:8dbd6bd9167f 3330 }
mkarlsso 0:8dbd6bd9167f 3331 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3332 textDisplay.debug("If statement\r\n");
mkarlsso 0:8dbd6bd9167f 3333 //this is a regular event
mkarlsso 0:8dbd6bd9167f 3334 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 0:8dbd6bd9167f 3335 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3336
mkarlsso 0:8dbd6bd9167f 3337 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 0:8dbd6bd9167f 3338 tmpEventPtrArray.back()->blockType = 1; //this is an if block
mkarlsso 0:8dbd6bd9167f 3339 blockDepth = blockDepth + 1;
mkarlsso 0:8dbd6bd9167f 3340 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3341 tmpEventPtrArray.back()->blockType = 3; //this is an else if block
mkarlsso 0:8dbd6bd9167f 3342 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3343 tmpEventPtrArray.back()->blockType = 7; //this is a then if block
mkarlsso 0:8dbd6bd9167f 3344 }
mkarlsso 0:8dbd6bd9167f 3345 }
mkarlsso 0:8dbd6bd9167f 3346
mkarlsso 0:8dbd6bd9167f 3347 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3348 //combine the condition tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 3349 tmpString = "";
mkarlsso 0:8dbd6bd9167f 3350 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 3351 if (tokens[j].compare("do") != 0) {
mkarlsso 0:8dbd6bd9167f 3352 i++;
mkarlsso 0:8dbd6bd9167f 3353 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 3354 } else {
mkarlsso 0:8dbd6bd9167f 3355 break;
mkarlsso 0:8dbd6bd9167f 3356 }
mkarlsso 0:8dbd6bd9167f 3357 }
mkarlsso 0:8dbd6bd9167f 3358 //adds the conditions to the current event
mkarlsso 0:8dbd6bd9167f 3359
mkarlsso 0:8dbd6bd9167f 3360 if (!evaluateConditions(tmpString, tmpEventPtrArray.back())) lineError = true;
mkarlsso 0:8dbd6bd9167f 3361 }
mkarlsso 0:8dbd6bd9167f 3362
mkarlsso 0:8dbd6bd9167f 3363 if (lineError && eventDefined) {
mkarlsso 0:8dbd6bd9167f 3364 tmpEvent->release();
mkarlsso 0:8dbd6bd9167f 3365 }
mkarlsso 0:8dbd6bd9167f 3366
mkarlsso 0:8dbd6bd9167f 3367
mkarlsso 0:8dbd6bd9167f 3368 //else starts an else block-------------------------------------
mkarlsso 0:8dbd6bd9167f 3369 //examples: else do in 500; else if x==7 do
mkarlsso 0:8dbd6bd9167f 3370 } else if (tokens[i].compare("else") == 0) { //an else block
mkarlsso 0:8dbd6bd9167f 3371 if (ifBlockInit || whileBlockInit || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3372 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3373 lineError = true;
mkarlsso 0:8dbd6bd9167f 3374 }
mkarlsso 0:8dbd6bd9167f 3375 textDisplay.debug("Else statement\r\n");
mkarlsso 0:8dbd6bd9167f 3376 //callbacks can't have else conditions
mkarlsso 0:8dbd6bd9167f 3377 if ((!lineError) && (blockDepth < 2) && ((currentTriggerPort > -1)||(currentFunction > -1))) {
mkarlsso 0:8dbd6bd9167f 3378 textDisplay << "Error: else statement can not occur after a trigger block or outside a block\r\n";
mkarlsso 0:8dbd6bd9167f 3379 lineError = true;
mkarlsso 0:8dbd6bd9167f 3380 }
mkarlsso 0:8dbd6bd9167f 3381
mkarlsso 0:8dbd6bd9167f 3382 //check to make sure we are in an 'if' block
mkarlsso 0:8dbd6bd9167f 3383 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 1) && (tmpEventPtrArray.back()->blockType != 3)) { //not currently in an 'if' or 'else if' block
mkarlsso 0:8dbd6bd9167f 3384 textDisplay << "Error: else statement can only occur in an 'if' block\r\n";
mkarlsso 0:8dbd6bd9167f 3385 lineError = true;
mkarlsso 0:8dbd6bd9167f 3386 }
mkarlsso 0:8dbd6bd9167f 3387 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3388 elseFlag = true;
mkarlsso 0:8dbd6bd9167f 3389 expectingDoStatement = true;
mkarlsso 0:8dbd6bd9167f 3390
mkarlsso 0:8dbd6bd9167f 3391 }
mkarlsso 0:8dbd6bd9167f 3392 } else if (tokens[i].compare("then") == 0) { //a then block
mkarlsso 0:8dbd6bd9167f 3393 if (ifBlockInit || whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3394 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3395 lineError = true;
mkarlsso 0:8dbd6bd9167f 3396 }
mkarlsso 0:8dbd6bd9167f 3397
mkarlsso 0:8dbd6bd9167f 3398 //trigger blocks can't have else conditions
mkarlsso 0:8dbd6bd9167f 3399 if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso 0:8dbd6bd9167f 3400 textDisplay << "Error: 'then' statement can only occur after a 'while' block\r\n";
mkarlsso 0:8dbd6bd9167f 3401 lineError = true;
mkarlsso 0:8dbd6bd9167f 3402 }
mkarlsso 0:8dbd6bd9167f 3403
mkarlsso 0:8dbd6bd9167f 3404 //check to make sure we are in a 'while' block
mkarlsso 0:8dbd6bd9167f 3405 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 5)) { //not currently in a while block
mkarlsso 0:8dbd6bd9167f 3406 textDisplay << "Error: 'then' statement can only occur in a 'while' block\r\n";
mkarlsso 0:8dbd6bd9167f 3407 lineError = true;
mkarlsso 0:8dbd6bd9167f 3408 }
mkarlsso 0:8dbd6bd9167f 3409 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3410 thenFlag = true;
mkarlsso 0:8dbd6bd9167f 3411 expectingDoStatement = true;
mkarlsso 0:8dbd6bd9167f 3412
mkarlsso 0:8dbd6bd9167f 3413 }
mkarlsso 0:8dbd6bd9167f 3414 //while starts a while block----------------------------------------
mkarlsso 0:8dbd6bd9167f 3415 //example: while x<10 do every 100
mkarlsso 0:8dbd6bd9167f 3416 // ...
mkarlsso 0:8dbd6bd9167f 3417 // end
mkarlsso 0:8dbd6bd9167f 3418 } else if (tokens[i].compare("while") == 0) { //a new while block
mkarlsso 0:8dbd6bd9167f 3419 if (ifBlockInit || whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3420 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3421 lineError = true;
mkarlsso 0:8dbd6bd9167f 3422 }
mkarlsso 0:8dbd6bd9167f 3423 textDisplay.debug("While statement\r\n");
mkarlsso 0:8dbd6bd9167f 3424
mkarlsso 0:8dbd6bd9167f 3425 if ((currentTriggerPort > 0) || (currentFunction > -1)) { //check to make sure we are inside a trigger block
mkarlsso 0:8dbd6bd9167f 3426
mkarlsso 0:8dbd6bd9167f 3427
mkarlsso 0:8dbd6bd9167f 3428 } else {
mkarlsso 0:8dbd6bd9167f 3429 textDisplay << "Error: a statement block must be placed inside a callback or function.\r\n";
mkarlsso 0:8dbd6bd9167f 3430 lineError = true;
mkarlsso 0:8dbd6bd9167f 3431 }
mkarlsso 0:8dbd6bd9167f 3432 //whileBlockInit = true;
mkarlsso 0:8dbd6bd9167f 3433 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3434
mkarlsso 0:8dbd6bd9167f 3435 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3436 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3437 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3438 tmpEvent->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3439 } else {
mkarlsso 0:8dbd6bd9167f 3440 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3441 lineError = true;
mkarlsso 0:8dbd6bd9167f 3442 }
mkarlsso 0:8dbd6bd9167f 3443
mkarlsso 0:8dbd6bd9167f 3444 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3445
mkarlsso 0:8dbd6bd9167f 3446
mkarlsso 0:8dbd6bd9167f 3447 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3448 //combine the condition tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 3449 tmpString = "";
mkarlsso 0:8dbd6bd9167f 3450 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 3451 if (tokens[j].compare("do") != 0) {
mkarlsso 0:8dbd6bd9167f 3452 i++;
mkarlsso 0:8dbd6bd9167f 3453 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 3454 } else {
mkarlsso 0:8dbd6bd9167f 3455 break;
mkarlsso 0:8dbd6bd9167f 3456 }
mkarlsso 0:8dbd6bd9167f 3457 }
mkarlsso 0:8dbd6bd9167f 3458 //adds the conditions to the current event
mkarlsso 0:8dbd6bd9167f 3459 if (!evaluateConditions(tmpString, tmpEvent)) lineError = true;
mkarlsso 0:8dbd6bd9167f 3460 }
mkarlsso 0:8dbd6bd9167f 3461
mkarlsso 0:8dbd6bd9167f 3462 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3463 if ((i+3) < sz) {
mkarlsso 0:8dbd6bd9167f 3464 if ((tokens[i+1].compare("do") == 0) && (tokens[i+2].compare("every") == 0)) {
mkarlsso 0:8dbd6bd9167f 3465
mkarlsso 0:8dbd6bd9167f 3466 if (isNumber(tokens[i+3])) {
mkarlsso 0:8dbd6bd9167f 3467 uint32_t period = atoi(tokens[i+3].data());
mkarlsso 0:8dbd6bd9167f 3468 if (period > 0) {
mkarlsso 0:8dbd6bd9167f 3469
mkarlsso 0:8dbd6bd9167f 3470
mkarlsso 0:8dbd6bd9167f 3471 //tmpEvent->whileLoopPeriod = period;
mkarlsso 0:8dbd6bd9167f 3472 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 0:8dbd6bd9167f 3473 if (!elseFlag) {
mkarlsso 0:8dbd6bd9167f 3474 tmpEvent->blockType = 5; //this is a while block
mkarlsso 0:8dbd6bd9167f 3475
mkarlsso 0:8dbd6bd9167f 3476 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3477 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 3478 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3479 lineError = true;
mkarlsso 0:8dbd6bd9167f 3480 } else {
mkarlsso 0:8dbd6bd9167f 3481 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3482 }
mkarlsso 0:8dbd6bd9167f 3483 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3484 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3485
mkarlsso 0:8dbd6bd9167f 3486 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3487 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3488 } else {
mkarlsso 0:8dbd6bd9167f 3489 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 0:8dbd6bd9167f 3490 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3491 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3492 }
mkarlsso 0:8dbd6bd9167f 3493 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3494 } else {
mkarlsso 0:8dbd6bd9167f 3495 textDisplay << "Error: loop period must be a positive integer.\r\n";
mkarlsso 0:8dbd6bd9167f 3496 lineError = true;
mkarlsso 0:8dbd6bd9167f 3497 }
mkarlsso 0:8dbd6bd9167f 3498 } else if (findIntVariable(tokens[i+3])!=NULL) {
mkarlsso 0:8dbd6bd9167f 3499
mkarlsso 0:8dbd6bd9167f 3500 int* period = findIntVariable(tokens[i+3]);
mkarlsso 0:8dbd6bd9167f 3501 //tmpEvent->whileLoopPeriodVar = period;
mkarlsso 0:8dbd6bd9167f 3502 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 0:8dbd6bd9167f 3503 if (!elseFlag) {
mkarlsso 0:8dbd6bd9167f 3504 tmpEvent->blockType = 5; //this is a while block
mkarlsso 0:8dbd6bd9167f 3505
mkarlsso 0:8dbd6bd9167f 3506 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3507 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 3508 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3509 lineError = true;
mkarlsso 0:8dbd6bd9167f 3510 } else {
mkarlsso 0:8dbd6bd9167f 3511 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3512 }
mkarlsso 0:8dbd6bd9167f 3513 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3514 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3515
mkarlsso 0:8dbd6bd9167f 3516 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3517 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3518 } else {
mkarlsso 0:8dbd6bd9167f 3519 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 0:8dbd6bd9167f 3520 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3521 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3522 }
mkarlsso 0:8dbd6bd9167f 3523 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3524 }
mkarlsso 0:8dbd6bd9167f 3525 } else {
mkarlsso 0:8dbd6bd9167f 3526 textDisplay << "Error: expected a 'do every' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3527 lineError = true;
mkarlsso 0:8dbd6bd9167f 3528 }
mkarlsso 0:8dbd6bd9167f 3529 } else {
mkarlsso 0:8dbd6bd9167f 3530 textDisplay << "Error: expected a 'do every' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3531 lineError = true;
mkarlsso 0:8dbd6bd9167f 3532 }
mkarlsso 0:8dbd6bd9167f 3533 }
mkarlsso 0:8dbd6bd9167f 3534
mkarlsso 0:8dbd6bd9167f 3535 //if the line contains an '=' sign,the equality is evaulated-------------------------
mkarlsso 0:8dbd6bd9167f 3536 //examples: a = 1; a = b + 5; a = random(100); portout[2] = 1; portout[2] = flip
mkarlsso 0:8dbd6bd9167f 3537 } else if ((tmpLine.find_first_of("=") != std::string::npos) ) { //an expression
mkarlsso 0:8dbd6bd9167f 3538 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3539 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3540 lineError = true;
mkarlsso 0:8dbd6bd9167f 3541 }
mkarlsso 0:8dbd6bd9167f 3542
mkarlsso 0:8dbd6bd9167f 3543 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3544 tmpString = "";
mkarlsso 0:8dbd6bd9167f 3545 int spacesBeforeEqualSign = 0;
mkarlsso 0:8dbd6bd9167f 3546 bool countSpaces = true;
mkarlsso 0:8dbd6bd9167f 3547 //combine the tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 3548 for (unsigned j = i; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 3549 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 3550 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 3551 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 3552 countSpaces = false;
mkarlsso 0:8dbd6bd9167f 3553 } else if (countSpaces) {
mkarlsso 0:8dbd6bd9167f 3554 spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 3555 }
mkarlsso 0:8dbd6bd9167f 3556 }
mkarlsso 0:8dbd6bd9167f 3557 if (!lineError && spacesBeforeEqualSign > 1) {
mkarlsso 0:8dbd6bd9167f 3558 textDisplay << "Error: Variable can't have a space in it.\r\n";
mkarlsso 0:8dbd6bd9167f 3559 lineError = true;
mkarlsso 0:8dbd6bd9167f 3560 }
mkarlsso 0:8dbd6bd9167f 3561
mkarlsso 0:8dbd6bd9167f 3562 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3563 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 3564 textDisplay.debug("Variable assignment statement\r\n");
mkarlsso 0:8dbd6bd9167f 3565 //action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 0:8dbd6bd9167f 3566 action* tmpAction = evaluateAssignmentForAction(tmpString.data());
mkarlsso 0:8dbd6bd9167f 3567 if (tmpAction != NULL) {
mkarlsso 0:8dbd6bd9167f 3568 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3569
mkarlsso 0:8dbd6bd9167f 3570 } else {
mkarlsso 0:8dbd6bd9167f 3571 lineError = true;
mkarlsso 0:8dbd6bd9167f 3572 }
mkarlsso 0:8dbd6bd9167f 3573
mkarlsso 0:8dbd6bd9167f 3574 } else { //assignment was written outside of any block structure, so execute now
mkarlsso 0:8dbd6bd9167f 3575
mkarlsso 0:8dbd6bd9167f 3576
mkarlsso 0:8dbd6bd9167f 3577 //action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 0:8dbd6bd9167f 3578 action* tmpAction = evaluateAssignmentForAction(tmpString.data());
mkarlsso 0:8dbd6bd9167f 3579
mkarlsso 0:8dbd6bd9167f 3580 if (tmpAction != NULL) {
mkarlsso 0:8dbd6bd9167f 3581 tmpAction->execute();
mkarlsso 0:8dbd6bd9167f 3582
mkarlsso 0:8dbd6bd9167f 3583 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3584 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3585 } else {
mkarlsso 0:8dbd6bd9167f 3586 lineError = true;
mkarlsso 0:8dbd6bd9167f 3587 }
mkarlsso 0:8dbd6bd9167f 3588 }
mkarlsso 0:8dbd6bd9167f 3589 }
mkarlsso 0:8dbd6bd9167f 3590 } else {
mkarlsso 0:8dbd6bd9167f 3591 //if there was no match to any of the above, an error is given
mkarlsso 0:8dbd6bd9167f 3592 textDisplay << "Error: statement not understood.\r\n";
mkarlsso 0:8dbd6bd9167f 3593 lineError = true;
mkarlsso 0:8dbd6bd9167f 3594 }
mkarlsso 0:8dbd6bd9167f 3595
mkarlsso 0:8dbd6bd9167f 3596 if (lineError) {
mkarlsso 5:abee20c0bf2a 3597 textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 3598 break; //stop parsing the rest of the line if an error was detected
mkarlsso 0:8dbd6bd9167f 3599 }
mkarlsso 0:8dbd6bd9167f 3600 if (wholeLineEvaluated) { //some of the tokens forces the whole line to be avaluated at once
mkarlsso 0:8dbd6bd9167f 3601 i = sz; //skip ahead to end of the line
mkarlsso 0:8dbd6bd9167f 3602 }
mkarlsso 0:8dbd6bd9167f 3603
mkarlsso 0:8dbd6bd9167f 3604 }
mkarlsso 0:8dbd6bd9167f 3605
mkarlsso 0:8dbd6bd9167f 3606 //if there was an error, we quit compiling the code
mkarlsso 0:8dbd6bd9167f 3607 if (lineError) {
mkarlsso 3:d7b0a0890d96 3608
mkarlsso 0:8dbd6bd9167f 3609 textDisplay << "Line text: ";
mkarlsso 5:abee20c0bf2a 3610 /*
mkarlsso 0:8dbd6bd9167f 3611 while (!tokens.empty()) {
mkarlsso 0:8dbd6bd9167f 3612 textDisplay << tokens.front()<< " ";
mkarlsso 5:abee20c0bf2a 3613 //tokens.erase(tokens.begin());
mkarlsso 5:abee20c0bf2a 3614 }*/
mkarlsso 5:abee20c0bf2a 3615
mkarlsso 5:abee20c0bf2a 3616 //Display the line with the syntax error
mkarlsso 5:abee20c0bf2a 3617 for (int tokInd = 0; tokInd < tokens.size(); tokInd++) {
mkarlsso 5:abee20c0bf2a 3618 textDisplay << tokens.at(tokInd) << " ";
mkarlsso 0:8dbd6bd9167f 3619 }
mkarlsso 0:8dbd6bd9167f 3620 textDisplay << "\r\n";
mkarlsso 5:abee20c0bf2a 3621 textDisplay.flush();
mkarlsso 3:d7b0a0890d96 3622
mkarlsso 0:8dbd6bd9167f 3623 currentBlock.resetBuffer();
mkarlsso 5:abee20c0bf2a 3624
mkarlsso 5:abee20c0bf2a 3625 //Clear the line tokens
mkarlsso 0:8dbd6bd9167f 3626 while (!tokens.empty()) {
mkarlsso 0:8dbd6bd9167f 3627 tokens.pop_back();
mkarlsso 0:8dbd6bd9167f 3628 }
mkarlsso 5:abee20c0bf2a 3629
mkarlsso 5:abee20c0bf2a 3630 if (tmpEventPtrArray.size() > 0) {
mkarlsso 5:abee20c0bf2a 3631 tmpEventPtrArray.at(0)->release(); //release the unfinished block (and all children)
mkarlsso 5:abee20c0bf2a 3632 }
mkarlsso 5:abee20c0bf2a 3633 while (tmpEventPtrArray.size() > 0){
mkarlsso 5:abee20c0bf2a 3634 tmpEventPtrArray.pop_back();
mkarlsso 5:abee20c0bf2a 3635 }
mkarlsso 5:abee20c0bf2a 3636
mkarlsso 5:abee20c0bf2a 3637
mkarlsso 3:d7b0a0890d96 3638 //delete tmpEvent;
mkarlsso 5:abee20c0bf2a 3639 /*
mkarlsso 5:abee20c0bf2a 3640 if (tmpEvent != NULL) {
mkarlsso 5:abee20c0bf2a 3641 tmpEvent->release();
mkarlsso 5:abee20c0bf2a 3642 }
mkarlsso 5:abee20c0bf2a 3643 */
mkarlsso 0:8dbd6bd9167f 3644 } else {
mkarlsso 0:8dbd6bd9167f 3645
mkarlsso 5:abee20c0bf2a 3646 //Clear the line tokens
mkarlsso 0:8dbd6bd9167f 3647 while (!tokens.empty()) {
mkarlsso 0:8dbd6bd9167f 3648 tokens.pop_back();
mkarlsso 0:8dbd6bd9167f 3649 }
mkarlsso 0:8dbd6bd9167f 3650 //currentBlock.pop_back();
mkarlsso 0:8dbd6bd9167f 3651
mkarlsso 0:8dbd6bd9167f 3652 }
mkarlsso 0:8dbd6bd9167f 3653
mkarlsso 0:8dbd6bd9167f 3654 }
mkarlsso 0:8dbd6bd9167f 3655
mkarlsso 0:8dbd6bd9167f 3656 //make sure that all blocks have a matching end statement
mkarlsso 0:8dbd6bd9167f 3657
mkarlsso 0:8dbd6bd9167f 3658
mkarlsso 0:8dbd6bd9167f 3659 if ((!lineError)&&(blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 3660 textDisplay << "Error: Missing 1 or more end statements\r\n";
mkarlsso 0:8dbd6bd9167f 3661 lineError = true;
mkarlsso 0:8dbd6bd9167f 3662 currentBlock.resetBuffer();
mkarlsso 0:8dbd6bd9167f 3663 }
mkarlsso 0:8dbd6bd9167f 3664
mkarlsso 0:8dbd6bd9167f 3665 if ((!lineError)&&(blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 3666 textDisplay.send("~~~\r\n");
mkarlsso 0:8dbd6bd9167f 3667 }
mkarlsso 0:8dbd6bd9167f 3668
mkarlsso 0:8dbd6bd9167f 3669 //displayMemoryLeft();
mkarlsso 0:8dbd6bd9167f 3670 //DisplayRAMBanks();
mkarlsso 0:8dbd6bd9167f 3671
mkarlsso 0:8dbd6bd9167f 3672 }
mkarlsso 0:8dbd6bd9167f 3673
mkarlsso 0:8dbd6bd9167f 3674
mkarlsso 0:8dbd6bd9167f 3675 //used to return a pointer to a variable, if it exists
mkarlsso 0:8dbd6bd9167f 3676 int* scriptStream::findIntVariable(string nameInput) {
mkarlsso 0:8dbd6bd9167f 3677
mkarlsso 0:8dbd6bd9167f 3678 textDisplay.debug("Finding variable: ");
mkarlsso 0:8dbd6bd9167f 3679 textDisplay.debug(nameInput.data());
mkarlsso 0:8dbd6bd9167f 3680 int* outPtr = NULL;
mkarlsso 0:8dbd6bd9167f 3681 bool foundIt = false;
mkarlsso 0:8dbd6bd9167f 3682 if (nameInput.find("portout") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 3683 int pos1 = nameInput.find("portout[")+8;
mkarlsso 0:8dbd6bd9167f 3684 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 3685 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3686 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 3687 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3688 outPtr = &portVector[portnum-1].outState;
mkarlsso 0:8dbd6bd9167f 3689 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3690 }
mkarlsso 0:8dbd6bd9167f 3691 } else if (nameInput.find("portin") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 3692 int pos1 = nameInput.find("portin[")+7;
mkarlsso 0:8dbd6bd9167f 3693 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 3694 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3695 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 3696 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3697 outPtr = &portVector[portnum-1].inState;
mkarlsso 0:8dbd6bd9167f 3698 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3699 }
mkarlsso 0:8dbd6bd9167f 3700 }
mkarlsso 0:8dbd6bd9167f 3701
mkarlsso 0:8dbd6bd9167f 3702 if (!foundIt) {
mkarlsso 0:8dbd6bd9167f 3703 std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso 0:8dbd6bd9167f 3704 int start = 0;
mkarlsso 0:8dbd6bd9167f 3705 int end = nameInput.length()-1;
mkarlsso 0:8dbd6bd9167f 3706
mkarlsso 0:8dbd6bd9167f 3707 for (unsigned i = 0; i < sz; i++) {
mkarlsso 0:8dbd6bd9167f 3708
mkarlsso 0:8dbd6bd9167f 3709
mkarlsso 0:8dbd6bd9167f 3710 if ((findStringLoc(nameInput.data(),globalVariables[i]->tag,start,end) != -1) && (strlen(globalVariables[i]->tag)==(end-start+1))) {
mkarlsso 0:8dbd6bd9167f 3711 outPtr = &globalVariables[i]->value;
mkarlsso 0:8dbd6bd9167f 3712 break;
mkarlsso 0:8dbd6bd9167f 3713 }
mkarlsso 0:8dbd6bd9167f 3714 /*
mkarlsso 0:8dbd6bd9167f 3715 if (nameInput.compare(globalVariables[i]->tag) == 0) {
mkarlsso 0:8dbd6bd9167f 3716 outPtr = &globalVariables[i]->value;
mkarlsso 0:8dbd6bd9167f 3717 break;
mkarlsso 0:8dbd6bd9167f 3718 }*/
mkarlsso 0:8dbd6bd9167f 3719 }
mkarlsso 0:8dbd6bd9167f 3720 }
mkarlsso 0:8dbd6bd9167f 3721 textDisplay.debug("...done\r\n");
mkarlsso 0:8dbd6bd9167f 3722
mkarlsso 0:8dbd6bd9167f 3723 return outPtr;
mkarlsso 0:8dbd6bd9167f 3724 }
mkarlsso 0:8dbd6bd9167f 3725
mkarlsso 0:8dbd6bd9167f 3726
mkarlsso 0:8dbd6bd9167f 3727 //used to return a pointer to a variable, if it exists
mkarlsso 0:8dbd6bd9167f 3728 int* scriptStream::findIntVariable(const char* nameInput, int start, int end) {
mkarlsso 0:8dbd6bd9167f 3729
mkarlsso 0:8dbd6bd9167f 3730 textDisplay.debug("Finding variable...");
mkarlsso 0:8dbd6bd9167f 3731 int* outPtr = NULL;
mkarlsso 0:8dbd6bd9167f 3732 bool foundIt = false;
mkarlsso 0:8dbd6bd9167f 3733
mkarlsso 0:8dbd6bd9167f 3734 if (findStringLoc(nameInput,"portout[",start,end) != -1) {
mkarlsso 0:8dbd6bd9167f 3735 int pos1 = findStringLoc(nameInput,"portout[",start,end)+8;
mkarlsso 0:8dbd6bd9167f 3736 int pos2 = findStringLoc(nameInput, "]",pos1,end);
mkarlsso 0:8dbd6bd9167f 3737 if ((pos1 == -1)||(pos2 == -1)) {
mkarlsso 0:8dbd6bd9167f 3738 //syntax error
mkarlsso 0:8dbd6bd9167f 3739 return NULL;
mkarlsso 0:8dbd6bd9167f 3740 }
mkarlsso 0:8dbd6bd9167f 3741
mkarlsso 0:8dbd6bd9167f 3742 //int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3743 long int portnum = strtol(nameInput+pos1,NULL,10);
mkarlsso 0:8dbd6bd9167f 3744 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3745 outPtr = &portVector[(int)portnum-1].outState;
mkarlsso 0:8dbd6bd9167f 3746 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3747 }
mkarlsso 0:8dbd6bd9167f 3748 } else if (findStringLoc(nameInput,"portin[",start,end) != -1) {
mkarlsso 0:8dbd6bd9167f 3749 int pos1 = findStringLoc(nameInput,"portin[",start,end)+7;
mkarlsso 0:8dbd6bd9167f 3750 int pos2 = findStringLoc(nameInput, "]",pos1,end);
mkarlsso 0:8dbd6bd9167f 3751 if ((pos1 == -1)||(pos2 == -1)) {
mkarlsso 0:8dbd6bd9167f 3752 //syntax error
mkarlsso 0:8dbd6bd9167f 3753 return NULL;
mkarlsso 0:8dbd6bd9167f 3754 }
mkarlsso 0:8dbd6bd9167f 3755 long int portnum = strtol(nameInput+pos1,NULL,10);
mkarlsso 0:8dbd6bd9167f 3756
mkarlsso 0:8dbd6bd9167f 3757 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3758 outPtr = &portVector[(int)portnum-1].inState;
mkarlsso 0:8dbd6bd9167f 3759 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3760 }
mkarlsso 0:8dbd6bd9167f 3761 }
mkarlsso 0:8dbd6bd9167f 3762
mkarlsso 0:8dbd6bd9167f 3763 if (!foundIt) {
mkarlsso 0:8dbd6bd9167f 3764 std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso 0:8dbd6bd9167f 3765 for (unsigned i = 0; i < sz; i++) {
mkarlsso 0:8dbd6bd9167f 3766 //const char* varName = globalVariables[i]->tag.data();
mkarlsso 0:8dbd6bd9167f 3767 if ((findStringLoc(nameInput,globalVariables[i]->tag,start,end) != -1) && (strlen(globalVariables[i]->tag)==(end-start+1))) {
mkarlsso 0:8dbd6bd9167f 3768 outPtr = &globalVariables[i]->value;
mkarlsso 0:8dbd6bd9167f 3769 break;
mkarlsso 0:8dbd6bd9167f 3770 }
mkarlsso 0:8dbd6bd9167f 3771 }
mkarlsso 0:8dbd6bd9167f 3772 }
mkarlsso 0:8dbd6bd9167f 3773 textDisplay.debug("done\r\n");
mkarlsso 0:8dbd6bd9167f 3774
mkarlsso 0:8dbd6bd9167f 3775 return outPtr;
mkarlsso 0:8dbd6bd9167f 3776 }
mkarlsso 0:8dbd6bd9167f 3777
mkarlsso 0:8dbd6bd9167f 3778 bool scriptStream::createIntVariable(string nameInput) {
mkarlsso 0:8dbd6bd9167f 3779 if (findIntVariable(nameInput) == NULL) {
mkarlsso 0:8dbd6bd9167f 3780 globalVariables.push_back(new intVariable(nameInput, 0));
mkarlsso 0:8dbd6bd9167f 3781 return true;
mkarlsso 0:8dbd6bd9167f 3782 } else {
mkarlsso 0:8dbd6bd9167f 3783 return false;
mkarlsso 0:8dbd6bd9167f 3784 }
mkarlsso 0:8dbd6bd9167f 3785 }
mkarlsso 0:8dbd6bd9167f 3786
mkarlsso 0:8dbd6bd9167f 3787 action* scriptStream::evaluateAssignmentForAction(const char* expression) {
mkarlsso 0:8dbd6bd9167f 3788
mkarlsso 0:8dbd6bd9167f 3789 //action* tmpAction = new action(); //create a new action
mkarlsso 0:8dbd6bd9167f 3790 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3791 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 3792 textDisplay << "Error: no action memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3793 return NULL;
mkarlsso 0:8dbd6bd9167f 3794 }
mkarlsso 0:8dbd6bd9167f 3795 int stringInd;
mkarlsso 0:8dbd6bd9167f 3796 int stringInd2;
mkarlsso 0:8dbd6bd9167f 3797 int afterEqualLoc;
mkarlsso 0:8dbd6bd9167f 3798 int beforeEqualLoc;
mkarlsso 0:8dbd6bd9167f 3799 int lastCharLoc = strlen(expression)-1;
mkarlsso 0:8dbd6bd9167f 3800 int multiplierInt = 1;
mkarlsso 0:8dbd6bd9167f 3801 //string afterEqual;
mkarlsso 0:8dbd6bd9167f 3802 //string beforeEqual;
mkarlsso 0:8dbd6bd9167f 3803 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 3804 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 3805 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 3806 int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 3807
mkarlsso 0:8dbd6bd9167f 3808 stringInd = findStringLoc(expression,"=",0,strlen(expression)-1); //location of = sign, if it exists
mkarlsso 0:8dbd6bd9167f 3809 if (stringInd == -1) {
mkarlsso 0:8dbd6bd9167f 3810 //Make sure there is an equal sign
mkarlsso 0:8dbd6bd9167f 3811 return NULL;
mkarlsso 0:8dbd6bd9167f 3812 }
mkarlsso 0:8dbd6bd9167f 3813
mkarlsso 0:8dbd6bd9167f 3814 beforeEqualLoc = stringInd-1;
mkarlsso 0:8dbd6bd9167f 3815 afterEqualLoc = stringInd+1;
mkarlsso 0:8dbd6bd9167f 3816
mkarlsso 0:8dbd6bd9167f 3817 //location of +/- sign (only one allowed)
mkarlsso 0:8dbd6bd9167f 3818 stringInd2 = findStringLoc(expression,"+",afterEqualLoc,strlen(expression)-1);
mkarlsso 0:8dbd6bd9167f 3819 if (stringInd2 == -1) {
mkarlsso 0:8dbd6bd9167f 3820 stringInd2 = findStringLoc(expression,"-",afterEqualLoc,strlen(expression)-1);
mkarlsso 0:8dbd6bd9167f 3821 multiplierInt = -1;
mkarlsso 0:8dbd6bd9167f 3822
mkarlsso 0:8dbd6bd9167f 3823 }
mkarlsso 3:d7b0a0890d96 3824
mkarlsso 0:8dbd6bd9167f 3825 tmpVar = findIntVariable(expression,0,beforeEqualLoc); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 3826 if (findStringLoc(expression,"portout[",0,beforeEqualLoc) != -1) { //set the output of a digital port
mkarlsso 0:8dbd6bd9167f 3827 textDisplay.debug("Portout assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3828 int pos1 = findStringLoc(expression,"portout[",0,beforeEqualLoc)+8;
mkarlsso 0:8dbd6bd9167f 3829 int pos2 = findStringLoc(expression,"]",pos1,beforeEqualLoc)-1;
mkarlsso 0:8dbd6bd9167f 3830 if (pos2 < pos1) {
mkarlsso 0:8dbd6bd9167f 3831 textDisplay << "Error: expected a ] character\r\n";
mkarlsso 0:8dbd6bd9167f 3832 return NULL;
mkarlsso 0:8dbd6bd9167f 3833 }
mkarlsso 0:8dbd6bd9167f 3834
mkarlsso 0:8dbd6bd9167f 3835 int portnum = -1;
mkarlsso 0:8dbd6bd9167f 3836 if (isNum(expression,pos1,pos2)) {
mkarlsso 0:8dbd6bd9167f 3837 portnum = atoi(expression+pos1);
mkarlsso 0:8dbd6bd9167f 3838 }
mkarlsso 0:8dbd6bd9167f 3839 int* tmpVar = findIntVariable(expression, pos1,pos2); //returns pointer to the variable, if given
mkarlsso 0:8dbd6bd9167f 3840 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 3841 if ((tmpVar != NULL)||((portnum > 0) && (portnum <= numPorts))) {
mkarlsso 0:8dbd6bd9167f 3842 if (isNum(expression,afterEqualLoc,lastCharLoc)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 3843 portVal = atoi(expression+afterEqualLoc);
mkarlsso 0:8dbd6bd9167f 3844 if ((portVal == 0) || (portVal == 1)) {
mkarlsso 0:8dbd6bd9167f 3845 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 3846 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 3847 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 3848 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3849 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3850 return NULL;
mkarlsso 0:8dbd6bd9167f 3851 } else {
mkarlsso 0:8dbd6bd9167f 3852 //tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 3853 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 3854 tmpMessage->setMessage(NULL,portnum,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 3855 } else {
mkarlsso 0:8dbd6bd9167f 3856 tmpMessage->setMessage(tmpVar,0,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 3857 }
mkarlsso 0:8dbd6bd9167f 3858 }
mkarlsso 0:8dbd6bd9167f 3859
mkarlsso 0:8dbd6bd9167f 3860
mkarlsso 0:8dbd6bd9167f 3861 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 3862
mkarlsso 0:8dbd6bd9167f 3863 } else {
mkarlsso 0:8dbd6bd9167f 3864 textDisplay << "Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 3865 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3866 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3867 return NULL;
mkarlsso 0:8dbd6bd9167f 3868 }
mkarlsso 0:8dbd6bd9167f 3869 } else if (findStringLoc(expression,"flip",afterEqualLoc,lastCharLoc)!=-1) {
mkarlsso 0:8dbd6bd9167f 3870 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 3871 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 3872 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 3873 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3874 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3875 return NULL;
mkarlsso 0:8dbd6bd9167f 3876 } else {
mkarlsso 0:8dbd6bd9167f 3877 //tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 3878 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 3879 tmpMessage->setMessage(NULL,portnum,-1,portVector);
mkarlsso 0:8dbd6bd9167f 3880 } else {
mkarlsso 0:8dbd6bd9167f 3881 tmpMessage->setMessage(tmpVar,0,-1,portVector);
mkarlsso 0:8dbd6bd9167f 3882 }
mkarlsso 0:8dbd6bd9167f 3883 }
mkarlsso 0:8dbd6bd9167f 3884 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 3885 } else {
mkarlsso 0:8dbd6bd9167f 3886 textDisplay << "Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 3887 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3888 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3889 return NULL;
mkarlsso 0:8dbd6bd9167f 3890 }
mkarlsso 0:8dbd6bd9167f 3891 } else {
mkarlsso 0:8dbd6bd9167f 3892 textDisplay << "Port number not found (must be between 1 and " << numPorts << " or an existing variable)\r\n";
mkarlsso 0:8dbd6bd9167f 3893 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3894 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3895 return NULL;
mkarlsso 0:8dbd6bd9167f 3896 }
mkarlsso 0:8dbd6bd9167f 3897 } else if (findStringLoc(expression,"portin",0,stringInd)!=-1) {
mkarlsso 0:8dbd6bd9167f 3898 textDisplay << "Error: portins can not be set\r\n";
mkarlsso 0:8dbd6bd9167f 3899 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3900 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3901 return NULL;
mkarlsso 0:8dbd6bd9167f 3902 } else if (tmpVar != NULL) {
mkarlsso 0:8dbd6bd9167f 3903 intOperation* tmpOp;
mkarlsso 0:8dbd6bd9167f 3904 intOperation* tmpOp2;
mkarlsso 0:8dbd6bd9167f 3905 if (isNum(expression,afterEqualLoc,lastCharLoc)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 3906 textDisplay.debug("Numeric assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3907 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 0:8dbd6bd9167f 3908 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3909 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3910 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3911 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3912 return NULL;
mkarlsso 0:8dbd6bd9167f 3913 } else {
mkarlsso 0:8dbd6bd9167f 3914 tmpOp->set(tmpVar, "=", atoi(expression+afterEqualLoc));
mkarlsso 0:8dbd6bd9167f 3915 }
mkarlsso 0:8dbd6bd9167f 3916 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3917
mkarlsso 0:8dbd6bd9167f 3918 } else if ((stringInd2 == -1)&&(findStringLoc(expression,"random",afterEqualLoc,lastCharLoc)!=-1)) {
mkarlsso 0:8dbd6bd9167f 3919 //assign random number
mkarlsso 0:8dbd6bd9167f 3920 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 3921 textDisplay.debug("Random number assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3922 int highVal = getRandomParam(expression,afterEqualLoc,lastCharLoc);
mkarlsso 0:8dbd6bd9167f 3923
mkarlsso 0:8dbd6bd9167f 3924 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 3925 //tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 0:8dbd6bd9167f 3926 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3927 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3928 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3929 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3930 return NULL;
mkarlsso 0:8dbd6bd9167f 3931 } else {
mkarlsso 0:8dbd6bd9167f 3932 tmpOp->setRandOp(highVal, "=", tmpVar, false);
mkarlsso 0:8dbd6bd9167f 3933 }
mkarlsso 0:8dbd6bd9167f 3934 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3935
mkarlsso 0:8dbd6bd9167f 3936 } else {
mkarlsso 0:8dbd6bd9167f 3937 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3938 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3939 return NULL;
mkarlsso 0:8dbd6bd9167f 3940 }
mkarlsso 0:8dbd6bd9167f 3941 } else if ((stringInd2 == -1)&&(findStringLoc(expression,"clock()",afterEqualLoc,lastCharLoc)!=-1)) {
mkarlsso 0:8dbd6bd9167f 3942 //assign clock value
mkarlsso 0:8dbd6bd9167f 3943 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 3944 textDisplay.debug("Clock assignment to variable\r\n");
mkarlsso 0:8dbd6bd9167f 3945 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3946 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3947 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3948 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3949 return NULL;
mkarlsso 0:8dbd6bd9167f 3950 } else {
mkarlsso 0:8dbd6bd9167f 3951 tmpOp->setClockOp(tmpVar); //assigns the current clock value to tmpVar
mkarlsso 0:8dbd6bd9167f 3952 }
mkarlsso 0:8dbd6bd9167f 3953 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3954
mkarlsso 0:8dbd6bd9167f 3955 } else if (stringInd2 != -1) { //a +/- operation is there
mkarlsso 0:8dbd6bd9167f 3956 textDisplay.debug("equation assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3957 //string multiplier("+");
mkarlsso 0:8dbd6bd9167f 3958 char multiplier[3];
mkarlsso 0:8dbd6bd9167f 3959 if (multiplierInt==1) {
mkarlsso 0:8dbd6bd9167f 3960 strcpy(multiplier,"+");
mkarlsso 0:8dbd6bd9167f 3961 } else {
mkarlsso 0:8dbd6bd9167f 3962 strcpy(multiplier,"-");
mkarlsso 0:8dbd6bd9167f 3963 }
mkarlsso 0:8dbd6bd9167f 3964
mkarlsso 0:8dbd6bd9167f 3965 /*
mkarlsso 0:8dbd6bd9167f 3966 if (afterEqual[stringInd2] == '-') {
mkarlsso 0:8dbd6bd9167f 3967 multiplier = "-";
mkarlsso 0:8dbd6bd9167f 3968 multiplierInt = -1;
mkarlsso 0:8dbd6bd9167f 3969 }*/
mkarlsso 0:8dbd6bd9167f 3970 tmpVar2 = findIntVariable(expression,afterEqualLoc,stringInd2-1); //before the +/- sign
mkarlsso 0:8dbd6bd9167f 3971 tmpVar3 = findIntVariable(expression,stringInd2+1,lastCharLoc); //after the +/- sign
mkarlsso 0:8dbd6bd9167f 3972
mkarlsso 0:8dbd6bd9167f 3973 if ((tmpVar2 != NULL) && isNum(expression,stringInd2+1,lastCharLoc)) { //variable +/- number
mkarlsso 0:8dbd6bd9167f 3974 if (tmpVar2 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 3975 //final sign is += or -=
mkarlsso 0:8dbd6bd9167f 3976 if (multiplierInt==1) {
mkarlsso 0:8dbd6bd9167f 3977 strcpy(multiplier,"+=");
mkarlsso 0:8dbd6bd9167f 3978 } else {
mkarlsso 0:8dbd6bd9167f 3979 strcpy(multiplier,"-=");
mkarlsso 0:8dbd6bd9167f 3980 }
mkarlsso 0:8dbd6bd9167f 3981
mkarlsso 0:8dbd6bd9167f 3982 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3983 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3984 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3985 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3986 return NULL;
mkarlsso 0:8dbd6bd9167f 3987 } else {
mkarlsso 0:8dbd6bd9167f 3988 tmpOp->set(tmpVar, multiplier, atoi(expression+stringInd2+1));
mkarlsso 0:8dbd6bd9167f 3989 }
mkarlsso 0:8dbd6bd9167f 3990 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3991
mkarlsso 0:8dbd6bd9167f 3992 } else {
mkarlsso 0:8dbd6bd9167f 3993
mkarlsso 0:8dbd6bd9167f 3994 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3995 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 3996 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3997 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3998 return NULL;
mkarlsso 0:8dbd6bd9167f 3999 } else {
mkarlsso 0:8dbd6bd9167f 4000
mkarlsso 0:8dbd6bd9167f 4001 tmpOp2->set(tmpVar2,multiplier, atoi(expression+stringInd2+1));
mkarlsso 0:8dbd6bd9167f 4002 //tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4003 }
mkarlsso 0:8dbd6bd9167f 4004
mkarlsso 0:8dbd6bd9167f 4005 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4006 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4007 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4008 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4009 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4010 return NULL;
mkarlsso 0:8dbd6bd9167f 4011 } else {
mkarlsso 0:8dbd6bd9167f 4012 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4013 }
mkarlsso 0:8dbd6bd9167f 4014
mkarlsso 0:8dbd6bd9167f 4015 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4016
mkarlsso 0:8dbd6bd9167f 4017 }
mkarlsso 0:8dbd6bd9167f 4018
mkarlsso 0:8dbd6bd9167f 4019 } else if ((tmpVar3 != NULL) && isNum(expression,afterEqualLoc,stringInd2-1)) { //number +/- variable
mkarlsso 0:8dbd6bd9167f 4020 if (tmpVar3 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 4021 //final sign is += or -=
mkarlsso 0:8dbd6bd9167f 4022 if (multiplierInt==1) {
mkarlsso 0:8dbd6bd9167f 4023 strcpy(multiplier,"+=");
mkarlsso 0:8dbd6bd9167f 4024 } else {
mkarlsso 0:8dbd6bd9167f 4025 strcpy(multiplier,"-=");
mkarlsso 0:8dbd6bd9167f 4026 }
mkarlsso 0:8dbd6bd9167f 4027
mkarlsso 0:8dbd6bd9167f 4028 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4029 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4030 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4031 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4032 return NULL;
mkarlsso 0:8dbd6bd9167f 4033 } else {
mkarlsso 0:8dbd6bd9167f 4034 tmpOp->set(tmpVar, multiplier, atoi(expression+afterEqualLoc));
mkarlsso 0:8dbd6bd9167f 4035 }
mkarlsso 0:8dbd6bd9167f 4036 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4037
mkarlsso 0:8dbd6bd9167f 4038 } else {
mkarlsso 0:8dbd6bd9167f 4039
mkarlsso 0:8dbd6bd9167f 4040 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4041 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4042 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4043 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4044 return NULL;
mkarlsso 0:8dbd6bd9167f 4045 } else {
mkarlsso 0:8dbd6bd9167f 4046 tmpOp2->set(tmpVar3, multiplier, atoi(expression+afterEqualLoc));
mkarlsso 0:8dbd6bd9167f 4047 }
mkarlsso 0:8dbd6bd9167f 4048 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4049
mkarlsso 0:8dbd6bd9167f 4050 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4051 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4052 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4053 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4054 return NULL;
mkarlsso 0:8dbd6bd9167f 4055 } else {
mkarlsso 0:8dbd6bd9167f 4056 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4057 }
mkarlsso 0:8dbd6bd9167f 4058 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4059
mkarlsso 0:8dbd6bd9167f 4060 }
mkarlsso 0:8dbd6bd9167f 4061
mkarlsso 0:8dbd6bd9167f 4062 } else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso 0:8dbd6bd9167f 4063
mkarlsso 0:8dbd6bd9167f 4064 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4065 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4066 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4067 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4068 return NULL;
mkarlsso 0:8dbd6bd9167f 4069 } else {
mkarlsso 0:8dbd6bd9167f 4070 tmpOp2->set(tmpVar2, multiplier, tmpVar3);
mkarlsso 0:8dbd6bd9167f 4071 }
mkarlsso 0:8dbd6bd9167f 4072 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4073
mkarlsso 0:8dbd6bd9167f 4074 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4075 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4076 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4077 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4078 return NULL;
mkarlsso 0:8dbd6bd9167f 4079 } else {
mkarlsso 0:8dbd6bd9167f 4080
mkarlsso 0:8dbd6bd9167f 4081 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4082 }
mkarlsso 0:8dbd6bd9167f 4083 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4084
mkarlsso 0:8dbd6bd9167f 4085 } else if ( isNum(expression,stringInd2+1,lastCharLoc) && isNum(expression,afterEqualLoc,stringInd2-1) ) { //number +/- number
mkarlsso 0:8dbd6bd9167f 4086 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4087 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4088 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4089 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4090 return NULL;
mkarlsso 0:8dbd6bd9167f 4091 } else {
mkarlsso 0:8dbd6bd9167f 4092 tmpOp->set(tmpVar, "=", atoi(expression+afterEqualLoc) + (multiplierInt * atoi(expression+stringInd2+1)) );
mkarlsso 0:8dbd6bd9167f 4093 }
mkarlsso 0:8dbd6bd9167f 4094 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4095
mkarlsso 0:8dbd6bd9167f 4096 } else if ((findStringLoc(expression,"random", afterEqualLoc,stringInd2-1)!=-1) && isNum(expression,stringInd2+1,lastCharLoc)) { //random +/- number
mkarlsso 0:8dbd6bd9167f 4097 int highVal = getRandomParam(expression,afterEqualLoc,stringInd2-1);
mkarlsso 0:8dbd6bd9167f 4098
mkarlsso 0:8dbd6bd9167f 4099 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4100
mkarlsso 0:8dbd6bd9167f 4101
mkarlsso 0:8dbd6bd9167f 4102 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4103 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4104 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4105 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4106 return NULL;
mkarlsso 0:8dbd6bd9167f 4107 } else {
mkarlsso 0:8dbd6bd9167f 4108 tmpOp2->setRandOp(highVal, multiplier, atoi(expression+stringInd2+1),false);
mkarlsso 0:8dbd6bd9167f 4109 }
mkarlsso 0:8dbd6bd9167f 4110 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4111
mkarlsso 0:8dbd6bd9167f 4112 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4113 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4114 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4115 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4116 return NULL;
mkarlsso 0:8dbd6bd9167f 4117 } else {
mkarlsso 0:8dbd6bd9167f 4118 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4119 }
mkarlsso 0:8dbd6bd9167f 4120 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4121
mkarlsso 0:8dbd6bd9167f 4122 } else {
mkarlsso 0:8dbd6bd9167f 4123 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4124 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4125 return NULL;
mkarlsso 0:8dbd6bd9167f 4126 }
mkarlsso 0:8dbd6bd9167f 4127 } else if ((findStringLoc(expression,"random",afterEqualLoc,stringInd2-1)!=-1) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso 0:8dbd6bd9167f 4128 int highVal = getRandomParam(expression,afterEqualLoc,stringInd2-1);
mkarlsso 0:8dbd6bd9167f 4129
mkarlsso 0:8dbd6bd9167f 4130 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4131
mkarlsso 0:8dbd6bd9167f 4132
mkarlsso 0:8dbd6bd9167f 4133 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4134 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4135 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4136 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4137 return NULL;
mkarlsso 0:8dbd6bd9167f 4138 } else {
mkarlsso 0:8dbd6bd9167f 4139 tmpOp2->setRandOp(highVal, multiplier, tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4140 }
mkarlsso 0:8dbd6bd9167f 4141 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4142 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4143 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4144 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4145 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4146 return NULL;
mkarlsso 0:8dbd6bd9167f 4147 } else {
mkarlsso 0:8dbd6bd9167f 4148 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4149 }
mkarlsso 0:8dbd6bd9167f 4150 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4151
mkarlsso 0:8dbd6bd9167f 4152 } else {
mkarlsso 0:8dbd6bd9167f 4153 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4154 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4155 return NULL;
mkarlsso 0:8dbd6bd9167f 4156 }
mkarlsso 0:8dbd6bd9167f 4157
mkarlsso 0:8dbd6bd9167f 4158
mkarlsso 0:8dbd6bd9167f 4159 } else if ((findStringLoc(expression,"random",stringInd2+1,lastCharLoc)!=-1) && isNum(expression,afterEqualLoc,stringInd2-1)) { //number +/- random
mkarlsso 0:8dbd6bd9167f 4160 int highVal = getRandomParam(expression,stringInd2+1,lastCharLoc);
mkarlsso 0:8dbd6bd9167f 4161
mkarlsso 0:8dbd6bd9167f 4162 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4163
mkarlsso 0:8dbd6bd9167f 4164
mkarlsso 0:8dbd6bd9167f 4165 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4166 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4167 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4168 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4169 return NULL;
mkarlsso 0:8dbd6bd9167f 4170 } else {
mkarlsso 0:8dbd6bd9167f 4171
mkarlsso 0:8dbd6bd9167f 4172 tmpOp2->setRandOp(highVal, multiplier, atoi(expression+afterEqualLoc),true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4173 }
mkarlsso 0:8dbd6bd9167f 4174 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4175 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4176 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4177 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4178 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4179 return NULL;
mkarlsso 0:8dbd6bd9167f 4180 } else {
mkarlsso 0:8dbd6bd9167f 4181 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4182 }
mkarlsso 0:8dbd6bd9167f 4183 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4184
mkarlsso 0:8dbd6bd9167f 4185 } else {
mkarlsso 0:8dbd6bd9167f 4186 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4187 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4188 return NULL;
mkarlsso 0:8dbd6bd9167f 4189 }
mkarlsso 0:8dbd6bd9167f 4190 } else if ((findStringLoc(expression,"random",stringInd2+1,lastCharLoc)!=-1) && (tmpVar2 != NULL)) { //variable +/- random
mkarlsso 0:8dbd6bd9167f 4191 int highVal = getRandomParam(expression,stringInd2+1,lastCharLoc);
mkarlsso 0:8dbd6bd9167f 4192
mkarlsso 0:8dbd6bd9167f 4193 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4194
mkarlsso 0:8dbd6bd9167f 4195
mkarlsso 0:8dbd6bd9167f 4196 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4197 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4198 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4199 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4200 return NULL;
mkarlsso 0:8dbd6bd9167f 4201 } else {
mkarlsso 0:8dbd6bd9167f 4202
mkarlsso 0:8dbd6bd9167f 4203 tmpOp2->setRandOp(highVal, multiplier, tmpVar2, true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4204 }
mkarlsso 0:8dbd6bd9167f 4205 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4206 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4207 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4208 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4209 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4210 return NULL;
mkarlsso 0:8dbd6bd9167f 4211 } else {
mkarlsso 0:8dbd6bd9167f 4212 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4213 }
mkarlsso 0:8dbd6bd9167f 4214 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4215
mkarlsso 0:8dbd6bd9167f 4216 } else {
mkarlsso 0:8dbd6bd9167f 4217 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4218 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4219 return NULL;
mkarlsso 0:8dbd6bd9167f 4220 }
mkarlsso 0:8dbd6bd9167f 4221 }
mkarlsso 0:8dbd6bd9167f 4222
mkarlsso 0:8dbd6bd9167f 4223
mkarlsso 0:8dbd6bd9167f 4224 else if ((findStringLoc(expression,"clock()",afterEqualLoc,stringInd2-1)!=-1) && isNum(expression,stringInd2+1,lastCharLoc)) { //clock() +/- number
mkarlsso 0:8dbd6bd9167f 4225
mkarlsso 0:8dbd6bd9167f 4226 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4227 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4228 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4229 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4230 return NULL;
mkarlsso 0:8dbd6bd9167f 4231 } else {
mkarlsso 0:8dbd6bd9167f 4232 tmpOp2->setClockOp(multiplier, atoi(expression+stringInd2+1),false);
mkarlsso 0:8dbd6bd9167f 4233 }
mkarlsso 0:8dbd6bd9167f 4234 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4235
mkarlsso 0:8dbd6bd9167f 4236 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4237 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4238 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4239 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4240 return NULL;
mkarlsso 0:8dbd6bd9167f 4241 } else {
mkarlsso 0:8dbd6bd9167f 4242 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4243 }
mkarlsso 0:8dbd6bd9167f 4244 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4245
mkarlsso 0:8dbd6bd9167f 4246
mkarlsso 0:8dbd6bd9167f 4247 } else if ((findStringLoc(expression,"clock()",afterEqualLoc,stringInd2-1)!=-1) && (tmpVar3 != NULL)) { //clock() +/- variable
mkarlsso 0:8dbd6bd9167f 4248
mkarlsso 0:8dbd6bd9167f 4249
mkarlsso 0:8dbd6bd9167f 4250
mkarlsso 0:8dbd6bd9167f 4251 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4252 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4253 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4254 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4255 return NULL;
mkarlsso 0:8dbd6bd9167f 4256 } else {
mkarlsso 0:8dbd6bd9167f 4257 tmpOp2->setClockOp(multiplier, tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4258 }
mkarlsso 0:8dbd6bd9167f 4259 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4260 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4261 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4262 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4263 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4264 return NULL;
mkarlsso 0:8dbd6bd9167f 4265 } else {
mkarlsso 0:8dbd6bd9167f 4266 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4267 }
mkarlsso 0:8dbd6bd9167f 4268 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4269
mkarlsso 0:8dbd6bd9167f 4270 } else if ((findStringLoc(expression,"clock()",stringInd2+1,lastCharLoc)!=-1) && isNum(expression,afterEqualLoc,lastCharLoc)) { //number +/- clock()
mkarlsso 0:8dbd6bd9167f 4271
mkarlsso 0:8dbd6bd9167f 4272 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4273 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4274 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4275 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4276 return NULL;
mkarlsso 0:8dbd6bd9167f 4277 } else {
mkarlsso 0:8dbd6bd9167f 4278
mkarlsso 0:8dbd6bd9167f 4279 tmpOp2->setClockOp(multiplier, atoi(expression+afterEqualLoc), true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4280 }
mkarlsso 0:8dbd6bd9167f 4281 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4282 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4283 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4284 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4285 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4286 return NULL;
mkarlsso 0:8dbd6bd9167f 4287 } else {
mkarlsso 0:8dbd6bd9167f 4288 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4289 }
mkarlsso 0:8dbd6bd9167f 4290 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4291
mkarlsso 0:8dbd6bd9167f 4292
mkarlsso 0:8dbd6bd9167f 4293 } else if ((findStringLoc(expression,"clock()",stringInd2+1,lastCharLoc)!=-1) && (tmpVar2 != NULL)) { //variable +/- clock()
mkarlsso 0:8dbd6bd9167f 4294
mkarlsso 0:8dbd6bd9167f 4295
mkarlsso 0:8dbd6bd9167f 4296 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4297 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4298 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4299 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4300 return NULL;
mkarlsso 0:8dbd6bd9167f 4301 } else {
mkarlsso 0:8dbd6bd9167f 4302
mkarlsso 0:8dbd6bd9167f 4303 tmpOp2->setClockOp(multiplier, tmpVar2, true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4304 }
mkarlsso 0:8dbd6bd9167f 4305 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4306 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4307 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4308 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4309 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4310 return NULL;
mkarlsso 0:8dbd6bd9167f 4311 } else {
mkarlsso 0:8dbd6bd9167f 4312 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4313 }
mkarlsso 0:8dbd6bd9167f 4314 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4315
mkarlsso 0:8dbd6bd9167f 4316
mkarlsso 0:8dbd6bd9167f 4317 }
mkarlsso 0:8dbd6bd9167f 4318
mkarlsso 0:8dbd6bd9167f 4319 else {
mkarlsso 0:8dbd6bd9167f 4320 textDisplay << "Expression not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 4321 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4322 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4323 return NULL;
mkarlsso 0:8dbd6bd9167f 4324 }
mkarlsso 0:8dbd6bd9167f 4325
mkarlsso 0:8dbd6bd9167f 4326 } else if (findIntVariable(expression,afterEqualLoc,lastCharLoc) != NULL) { //assign value of another variable
mkarlsso 0:8dbd6bd9167f 4327 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4328 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4329 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4330 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4331 return NULL;
mkarlsso 0:8dbd6bd9167f 4332 } else {
mkarlsso 0:8dbd6bd9167f 4333 tmpOp->set(tmpVar, "=", findIntVariable(expression,afterEqualLoc,lastCharLoc));
mkarlsso 0:8dbd6bd9167f 4334 }
mkarlsso 0:8dbd6bd9167f 4335 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4336
mkarlsso 0:8dbd6bd9167f 4337 } else {
mkarlsso 0:8dbd6bd9167f 4338 textDisplay << "Variable not found: " << expression+afterEqualLoc << "\r\n";
mkarlsso 0:8dbd6bd9167f 4339 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4340 return NULL;
mkarlsso 0:8dbd6bd9167f 4341 }
mkarlsso 0:8dbd6bd9167f 4342
mkarlsso 0:8dbd6bd9167f 4343 } else {
mkarlsso 0:8dbd6bd9167f 4344 textDisplay << "Variable not found\r\n";
mkarlsso 0:8dbd6bd9167f 4345 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4346 return NULL;
mkarlsso 0:8dbd6bd9167f 4347 }
mkarlsso 0:8dbd6bd9167f 4348 textDisplay.debug("Assignment successful\r\n");
mkarlsso 0:8dbd6bd9167f 4349 return tmpAction;
mkarlsso 0:8dbd6bd9167f 4350 }
mkarlsso 0:8dbd6bd9167f 4351
mkarlsso 0:8dbd6bd9167f 4352 action* scriptStream::evaluateAssignmentForAction(string expression) {
mkarlsso 0:8dbd6bd9167f 4353
mkarlsso 0:8dbd6bd9167f 4354 //action* tmpAction = new action(); //create a new action
mkarlsso 0:8dbd6bd9167f 4355 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 4356 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 4357 textDisplay << "Error: no action memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4358 return NULL;
mkarlsso 0:8dbd6bd9167f 4359 }
mkarlsso 0:8dbd6bd9167f 4360 std::size_t stringInd;
mkarlsso 0:8dbd6bd9167f 4361 std::size_t stringInd2;
mkarlsso 0:8dbd6bd9167f 4362 string afterEqual;
mkarlsso 0:8dbd6bd9167f 4363 string beforeEqual;
mkarlsso 0:8dbd6bd9167f 4364 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 4365 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 4366 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 4367 int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 4368 stringInd = expression.find_first_of("="); //location of = sign, if it exists
mkarlsso 0:8dbd6bd9167f 4369 beforeEqual = expression.substr(0,stringInd); // the string after the = sign
mkarlsso 0:8dbd6bd9167f 4370 afterEqual = expression.substr(stringInd+1,std::string::npos); // the string after the = sign
mkarlsso 0:8dbd6bd9167f 4371 stringInd2 = afterEqual.find_first_of("+-"); //location of +/- sign (only one allowed)
mkarlsso 0:8dbd6bd9167f 4372 tmpVar = findIntVariable(expression.substr(0,stringInd)); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 4373
mkarlsso 0:8dbd6bd9167f 4374 if (beforeEqual.find("portout[") != std::string::npos) { //set the output of a digital port
mkarlsso 0:8dbd6bd9167f 4375 textDisplay.debug("Portout assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4376 int pos1 = beforeEqual.find("portout[")+8;
mkarlsso 0:8dbd6bd9167f 4377 int pos2 = beforeEqual.find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 4378 int portnum = atoi(beforeEqual.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 4379 int* tmpVar = findIntVariable(beforeEqual.substr(pos1,pos2-pos1)); //returns pointer to the variable, if given
mkarlsso 0:8dbd6bd9167f 4380 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 4381 if ((tmpVar != NULL)||((portnum > 0) && (portnum <= numPorts))) {
mkarlsso 0:8dbd6bd9167f 4382 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 4383 portVal = atoi(afterEqual.data());
mkarlsso 0:8dbd6bd9167f 4384 if ((portVal == 0) || (portVal == 1)) {
mkarlsso 0:8dbd6bd9167f 4385 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 4386 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 4387 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 4388 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4389 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4390 return NULL;
mkarlsso 0:8dbd6bd9167f 4391 } else {
mkarlsso 0:8dbd6bd9167f 4392 //tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 4393 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 4394 tmpMessage->setMessage(NULL,portnum,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 4395 } else {
mkarlsso 0:8dbd6bd9167f 4396 tmpMessage->setMessage(tmpVar,0,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 4397 }
mkarlsso 0:8dbd6bd9167f 4398 }
mkarlsso 0:8dbd6bd9167f 4399
mkarlsso 0:8dbd6bd9167f 4400
mkarlsso 0:8dbd6bd9167f 4401 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 4402
mkarlsso 0:8dbd6bd9167f 4403 } else {
mkarlsso 0:8dbd6bd9167f 4404 textDisplay << "Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 4405 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4406 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4407 return NULL;
mkarlsso 0:8dbd6bd9167f 4408 }
mkarlsso 0:8dbd6bd9167f 4409 } else if (afterEqual.compare("flip") == 0) {
mkarlsso 0:8dbd6bd9167f 4410 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 4411 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 4412 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 4413 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4414 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4415 return NULL;
mkarlsso 0:8dbd6bd9167f 4416 } else {
mkarlsso 0:8dbd6bd9167f 4417 //tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 4418 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 4419 tmpMessage->setMessage(NULL,portnum,-1,portVector);
mkarlsso 0:8dbd6bd9167f 4420 } else {
mkarlsso 0:8dbd6bd9167f 4421 tmpMessage->setMessage(tmpVar,0,-1,portVector);
mkarlsso 0:8dbd6bd9167f 4422 }
mkarlsso 0:8dbd6bd9167f 4423 }
mkarlsso 0:8dbd6bd9167f 4424 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 4425 } else {
mkarlsso 0:8dbd6bd9167f 4426 textDisplay << "Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 4427 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4428 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4429 return NULL;
mkarlsso 0:8dbd6bd9167f 4430 }
mkarlsso 0:8dbd6bd9167f 4431 } else {
mkarlsso 0:8dbd6bd9167f 4432 textDisplay << "Port number not found (must be between 1 and " << numPorts << " or an existing variable)\r\n";
mkarlsso 0:8dbd6bd9167f 4433 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4434 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4435 return NULL;
mkarlsso 0:8dbd6bd9167f 4436 }
mkarlsso 0:8dbd6bd9167f 4437 } else if (beforeEqual.find("portin") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 4438 textDisplay << "Error: portins can not be set\r\n";
mkarlsso 0:8dbd6bd9167f 4439 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4440 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4441 return NULL;
mkarlsso 0:8dbd6bd9167f 4442 } else if (tmpVar != NULL) {
mkarlsso 0:8dbd6bd9167f 4443 intOperation* tmpOp;
mkarlsso 0:8dbd6bd9167f 4444 intOperation* tmpOp2;
mkarlsso 0:8dbd6bd9167f 4445 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 4446 textDisplay.debug("Numeric assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4447 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 0:8dbd6bd9167f 4448 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4449 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4450 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4451 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4452 return NULL;
mkarlsso 0:8dbd6bd9167f 4453 } else {
mkarlsso 0:8dbd6bd9167f 4454 tmpOp->set(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 0:8dbd6bd9167f 4455 }
mkarlsso 0:8dbd6bd9167f 4456 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4457
mkarlsso 0:8dbd6bd9167f 4458 } else if ((stringInd2 == std::string::npos)&&(afterEqual.find("random") != std::string::npos)) {
mkarlsso 0:8dbd6bd9167f 4459 //assign random number
mkarlsso 0:8dbd6bd9167f 4460 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 4461 textDisplay.debug("Random number assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4462 int highVal = getRandomParam(afterEqual);
mkarlsso 0:8dbd6bd9167f 4463
mkarlsso 0:8dbd6bd9167f 4464 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4465 //tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 0:8dbd6bd9167f 4466 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4467 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4468 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4469 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4470 return NULL;
mkarlsso 0:8dbd6bd9167f 4471 } else {
mkarlsso 0:8dbd6bd9167f 4472 tmpOp->setRandOp(highVal, "=", tmpVar, false);
mkarlsso 0:8dbd6bd9167f 4473 }
mkarlsso 0:8dbd6bd9167f 4474 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4475
mkarlsso 0:8dbd6bd9167f 4476 } else {
mkarlsso 0:8dbd6bd9167f 4477 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4478 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4479 return NULL;
mkarlsso 0:8dbd6bd9167f 4480 }
mkarlsso 0:8dbd6bd9167f 4481 } else if ((stringInd2 == std::string::npos)&&(afterEqual.find("clock()") != std::string::npos)) {
mkarlsso 0:8dbd6bd9167f 4482 //assign clock value
mkarlsso 0:8dbd6bd9167f 4483 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 4484 textDisplay.debug("Clock assignment to variable\r\n");
mkarlsso 0:8dbd6bd9167f 4485 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4486 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4487 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4488 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4489 return NULL;
mkarlsso 0:8dbd6bd9167f 4490 } else {
mkarlsso 0:8dbd6bd9167f 4491 tmpOp->setClockOp(tmpVar); //assigns the current clock value to tmpVar
mkarlsso 0:8dbd6bd9167f 4492 }
mkarlsso 0:8dbd6bd9167f 4493 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4494
mkarlsso 0:8dbd6bd9167f 4495 } else if (stringInd2 != std::string::npos) { //a +/- operation is there
mkarlsso 0:8dbd6bd9167f 4496 textDisplay.debug("equation assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4497 string multiplier("+");
mkarlsso 0:8dbd6bd9167f 4498 int multiplierInt = 1;
mkarlsso 0:8dbd6bd9167f 4499 if (afterEqual[stringInd2] == '-') {
mkarlsso 0:8dbd6bd9167f 4500 multiplier = "-";
mkarlsso 0:8dbd6bd9167f 4501 multiplierInt = -1;
mkarlsso 0:8dbd6bd9167f 4502 }
mkarlsso 0:8dbd6bd9167f 4503 tmpVar2 = findIntVariable(afterEqual.substr(0,stringInd2)); //before the +/- sign
mkarlsso 0:8dbd6bd9167f 4504 tmpVar3 = findIntVariable(afterEqual.substr(stringInd2+1,std::string::npos)); //after the +/- sign
mkarlsso 0:8dbd6bd9167f 4505
mkarlsso 0:8dbd6bd9167f 4506 if ((tmpVar2 != NULL) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //variable +/- number
mkarlsso 0:8dbd6bd9167f 4507 if (tmpVar2 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 4508 multiplier.append("="); //final sign is += or -=
mkarlsso 0:8dbd6bd9167f 4509 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 0:8dbd6bd9167f 4510 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4511 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4512 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4513 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4514 return NULL;
mkarlsso 0:8dbd6bd9167f 4515 } else {
mkarlsso 0:8dbd6bd9167f 4516 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 0:8dbd6bd9167f 4517 }
mkarlsso 0:8dbd6bd9167f 4518 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4519
mkarlsso 0:8dbd6bd9167f 4520 } else {
mkarlsso 0:8dbd6bd9167f 4521
mkarlsso 0:8dbd6bd9167f 4522 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4523 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4524 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4525 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4526 return NULL;
mkarlsso 0:8dbd6bd9167f 4527 } else {
mkarlsso 0:8dbd6bd9167f 4528
mkarlsso 0:8dbd6bd9167f 4529 tmpOp2->set(tmpVar2,multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 0:8dbd6bd9167f 4530 //tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4531 }
mkarlsso 0:8dbd6bd9167f 4532
mkarlsso 0:8dbd6bd9167f 4533 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4534 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4535 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4536 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4537 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4538 return NULL;
mkarlsso 0:8dbd6bd9167f 4539 } else {
mkarlsso 0:8dbd6bd9167f 4540 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4541 }
mkarlsso 0:8dbd6bd9167f 4542
mkarlsso 0:8dbd6bd9167f 4543 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4544
mkarlsso 0:8dbd6bd9167f 4545 }
mkarlsso 0:8dbd6bd9167f 4546
mkarlsso 0:8dbd6bd9167f 4547 } else if ((tmpVar3 != NULL) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- variable
mkarlsso 0:8dbd6bd9167f 4548 if (tmpVar3 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 4549 multiplier.append("="); //makes "+=" or "-="
mkarlsso 0:8dbd6bd9167f 4550 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 0:8dbd6bd9167f 4551 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4552 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4553 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4554 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4555 return NULL;
mkarlsso 0:8dbd6bd9167f 4556 } else {
mkarlsso 0:8dbd6bd9167f 4557 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 0:8dbd6bd9167f 4558 }
mkarlsso 0:8dbd6bd9167f 4559 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4560
mkarlsso 0:8dbd6bd9167f 4561 } else {
mkarlsso 0:8dbd6bd9167f 4562
mkarlsso 0:8dbd6bd9167f 4563 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4564 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4565 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4566 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4567 return NULL;
mkarlsso 0:8dbd6bd9167f 4568 } else {
mkarlsso 0:8dbd6bd9167f 4569 tmpOp2->set(tmpVar3, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso 0:8dbd6bd9167f 4570 }
mkarlsso 0:8dbd6bd9167f 4571 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4572
mkarlsso 0:8dbd6bd9167f 4573 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4574 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4575 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4576 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4577 return NULL;
mkarlsso 0:8dbd6bd9167f 4578 } else {
mkarlsso 0:8dbd6bd9167f 4579 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4580 }
mkarlsso 0:8dbd6bd9167f 4581 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4582
mkarlsso 0:8dbd6bd9167f 4583 }
mkarlsso 0:8dbd6bd9167f 4584
mkarlsso 0:8dbd6bd9167f 4585 } else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso 0:8dbd6bd9167f 4586
mkarlsso 0:8dbd6bd9167f 4587 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4588 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4589 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4590 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4591 return NULL;
mkarlsso 0:8dbd6bd9167f 4592 } else {
mkarlsso 0:8dbd6bd9167f 4593 tmpOp2->set(tmpVar2, multiplier.data(), tmpVar3);
mkarlsso 0:8dbd6bd9167f 4594 }
mkarlsso 0:8dbd6bd9167f 4595 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4596
mkarlsso 0:8dbd6bd9167f 4597 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4598 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4599 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4600 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4601 return NULL;
mkarlsso 0:8dbd6bd9167f 4602 } else {
mkarlsso 0:8dbd6bd9167f 4603
mkarlsso 0:8dbd6bd9167f 4604 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4605 }
mkarlsso 0:8dbd6bd9167f 4606 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4607
mkarlsso 0:8dbd6bd9167f 4608 } else if ( isNumber(afterEqual.substr(stringInd2+1,std::string::npos)) && isNumber(afterEqual.substr(0,stringInd2)) ) { //number +/- number
mkarlsso 0:8dbd6bd9167f 4609 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4610 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4611 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4612 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4613 return NULL;
mkarlsso 0:8dbd6bd9167f 4614 } else {
mkarlsso 0:8dbd6bd9167f 4615 tmpOp->set(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso 0:8dbd6bd9167f 4616 }
mkarlsso 0:8dbd6bd9167f 4617 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4618
mkarlsso 0:8dbd6bd9167f 4619 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //random +/- number
mkarlsso 0:8dbd6bd9167f 4620 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 0:8dbd6bd9167f 4621
mkarlsso 0:8dbd6bd9167f 4622 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4623
mkarlsso 0:8dbd6bd9167f 4624
mkarlsso 0:8dbd6bd9167f 4625 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4626 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4627 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4628 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4629 return NULL;
mkarlsso 0:8dbd6bd9167f 4630 } else {
mkarlsso 0:8dbd6bd9167f 4631 tmpOp2->setRandOp(highVal, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()),false);
mkarlsso 0:8dbd6bd9167f 4632 }
mkarlsso 0:8dbd6bd9167f 4633 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4634
mkarlsso 0:8dbd6bd9167f 4635 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4636 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4637 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4638 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4639 return NULL;
mkarlsso 0:8dbd6bd9167f 4640 } else {
mkarlsso 0:8dbd6bd9167f 4641 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4642 }
mkarlsso 0:8dbd6bd9167f 4643 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4644
mkarlsso 0:8dbd6bd9167f 4645 } else {
mkarlsso 0:8dbd6bd9167f 4646 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4647 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4648 return NULL;
mkarlsso 0:8dbd6bd9167f 4649 }
mkarlsso 0:8dbd6bd9167f 4650 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso 0:8dbd6bd9167f 4651 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 0:8dbd6bd9167f 4652
mkarlsso 0:8dbd6bd9167f 4653 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4654
mkarlsso 0:8dbd6bd9167f 4655
mkarlsso 0:8dbd6bd9167f 4656 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4657 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4658 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4659 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4660 return NULL;
mkarlsso 0:8dbd6bd9167f 4661 } else {
mkarlsso 0:8dbd6bd9167f 4662 tmpOp2->setRandOp(highVal, multiplier.data(), tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4663 }
mkarlsso 0:8dbd6bd9167f 4664 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4665 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4666 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4667 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4668 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4669 return NULL;
mkarlsso 0:8dbd6bd9167f 4670 } else {
mkarlsso 0:8dbd6bd9167f 4671 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4672 }
mkarlsso 0:8dbd6bd9167f 4673 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4674
mkarlsso 0:8dbd6bd9167f 4675 } else {
mkarlsso 0:8dbd6bd9167f 4676 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4677 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4678 return NULL;
mkarlsso 0:8dbd6bd9167f 4679 }
mkarlsso 0:8dbd6bd9167f 4680
mkarlsso 0:8dbd6bd9167f 4681
mkarlsso 0:8dbd6bd9167f 4682 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- random
mkarlsso 0:8dbd6bd9167f 4683 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 0:8dbd6bd9167f 4684
mkarlsso 0:8dbd6bd9167f 4685 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4686
mkarlsso 0:8dbd6bd9167f 4687
mkarlsso 0:8dbd6bd9167f 4688 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4689 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4690 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4691 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4692 return NULL;
mkarlsso 0:8dbd6bd9167f 4693 } else {
mkarlsso 0:8dbd6bd9167f 4694
mkarlsso 0:8dbd6bd9167f 4695 tmpOp2->setRandOp(highVal, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()),true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4696 }
mkarlsso 0:8dbd6bd9167f 4697 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4698 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4699 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4700 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4701 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4702 return NULL;
mkarlsso 0:8dbd6bd9167f 4703 } else {
mkarlsso 0:8dbd6bd9167f 4704 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4705 }
mkarlsso 0:8dbd6bd9167f 4706 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4707
mkarlsso 0:8dbd6bd9167f 4708 } else {
mkarlsso 0:8dbd6bd9167f 4709 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4710 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4711 return NULL;
mkarlsso 0:8dbd6bd9167f 4712 }
mkarlsso 0:8dbd6bd9167f 4713 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && (tmpVar2 != NULL)) { //variable +/- random
mkarlsso 0:8dbd6bd9167f 4714 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 0:8dbd6bd9167f 4715
mkarlsso 0:8dbd6bd9167f 4716 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4717
mkarlsso 0:8dbd6bd9167f 4718
mkarlsso 0:8dbd6bd9167f 4719 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4720 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4721 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4722 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4723 return NULL;
mkarlsso 0:8dbd6bd9167f 4724 } else {
mkarlsso 0:8dbd6bd9167f 4725
mkarlsso 0:8dbd6bd9167f 4726 tmpOp2->setRandOp(highVal, multiplier.data(), tmpVar2, true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4727 }
mkarlsso 0:8dbd6bd9167f 4728 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4729 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4730 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4731 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4732 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4733 return NULL;
mkarlsso 0:8dbd6bd9167f 4734 } else {
mkarlsso 0:8dbd6bd9167f 4735 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4736 }
mkarlsso 0:8dbd6bd9167f 4737 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4738
mkarlsso 0:8dbd6bd9167f 4739 } else {
mkarlsso 0:8dbd6bd9167f 4740 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4741 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4742 return NULL;
mkarlsso 0:8dbd6bd9167f 4743 }
mkarlsso 0:8dbd6bd9167f 4744 }
mkarlsso 0:8dbd6bd9167f 4745
mkarlsso 0:8dbd6bd9167f 4746
mkarlsso 0:8dbd6bd9167f 4747
mkarlsso 0:8dbd6bd9167f 4748
mkarlsso 0:8dbd6bd9167f 4749
mkarlsso 0:8dbd6bd9167f 4750 else if ((afterEqual.substr(0,stringInd2).find("clock()") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //clock() +/- number
mkarlsso 0:8dbd6bd9167f 4751
mkarlsso 0:8dbd6bd9167f 4752
mkarlsso 0:8dbd6bd9167f 4753
mkarlsso 0:8dbd6bd9167f 4754 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4755 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4756 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4757 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4758 return NULL;
mkarlsso 0:8dbd6bd9167f 4759 } else {
mkarlsso 0:8dbd6bd9167f 4760 tmpOp2->setClockOp(multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()),false);
mkarlsso 0:8dbd6bd9167f 4761 }
mkarlsso 0:8dbd6bd9167f 4762 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4763
mkarlsso 0:8dbd6bd9167f 4764 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4765 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4766 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4767 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4768 return NULL;
mkarlsso 0:8dbd6bd9167f 4769 } else {
mkarlsso 0:8dbd6bd9167f 4770 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4771 }
mkarlsso 0:8dbd6bd9167f 4772 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4773
mkarlsso 0:8dbd6bd9167f 4774
mkarlsso 0:8dbd6bd9167f 4775 } else if ((afterEqual.substr(0,stringInd2).find("clock()") != std::string::npos) && (tmpVar3 != NULL)) { //clock() +/- variable
mkarlsso 0:8dbd6bd9167f 4776
mkarlsso 0:8dbd6bd9167f 4777
mkarlsso 0:8dbd6bd9167f 4778
mkarlsso 0:8dbd6bd9167f 4779 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4780 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4781 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4782 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4783 return NULL;
mkarlsso 0:8dbd6bd9167f 4784 } else {
mkarlsso 0:8dbd6bd9167f 4785 tmpOp2->setClockOp(multiplier.data(), tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4786 }
mkarlsso 0:8dbd6bd9167f 4787 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4788 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4789 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4790 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4791 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4792 return NULL;
mkarlsso 0:8dbd6bd9167f 4793 } else {
mkarlsso 0:8dbd6bd9167f 4794 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4795 }
mkarlsso 0:8dbd6bd9167f 4796 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4797
mkarlsso 0:8dbd6bd9167f 4798
mkarlsso 0:8dbd6bd9167f 4799
mkarlsso 0:8dbd6bd9167f 4800
mkarlsso 0:8dbd6bd9167f 4801 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("clock()") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- clock()
mkarlsso 0:8dbd6bd9167f 4802
mkarlsso 0:8dbd6bd9167f 4803
mkarlsso 0:8dbd6bd9167f 4804
mkarlsso 0:8dbd6bd9167f 4805 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4806 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4807 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4808 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4809 return NULL;
mkarlsso 0:8dbd6bd9167f 4810 } else {
mkarlsso 0:8dbd6bd9167f 4811
mkarlsso 0:8dbd6bd9167f 4812 tmpOp2->setClockOp(multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()),true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4813 }
mkarlsso 0:8dbd6bd9167f 4814 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4815 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4816 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4817 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4818 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4819 return NULL;
mkarlsso 0:8dbd6bd9167f 4820 } else {
mkarlsso 0:8dbd6bd9167f 4821 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4822 }
mkarlsso 0:8dbd6bd9167f 4823 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4824
mkarlsso 0:8dbd6bd9167f 4825
mkarlsso 0:8dbd6bd9167f 4826 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("clock()") != std::string::npos) && (tmpVar2 != NULL)) { //variable +/- clock()
mkarlsso 0:8dbd6bd9167f 4827
mkarlsso 0:8dbd6bd9167f 4828
mkarlsso 0:8dbd6bd9167f 4829 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4830 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4831 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4832 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4833 return NULL;
mkarlsso 0:8dbd6bd9167f 4834 } else {
mkarlsso 0:8dbd6bd9167f 4835
mkarlsso 0:8dbd6bd9167f 4836 tmpOp2->setClockOp(multiplier.data(), tmpVar2, true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4837 }
mkarlsso 0:8dbd6bd9167f 4838 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4839 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4840 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4841 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4842 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4843 return NULL;
mkarlsso 0:8dbd6bd9167f 4844 } else {
mkarlsso 0:8dbd6bd9167f 4845 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4846 }
mkarlsso 0:8dbd6bd9167f 4847 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4848
mkarlsso 0:8dbd6bd9167f 4849
mkarlsso 0:8dbd6bd9167f 4850 }
mkarlsso 0:8dbd6bd9167f 4851
mkarlsso 0:8dbd6bd9167f 4852 else {
mkarlsso 0:8dbd6bd9167f 4853 textDisplay << "Expression not understood: " << afterEqual << "\r\n";
mkarlsso 0:8dbd6bd9167f 4854 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4855 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4856 return NULL;
mkarlsso 0:8dbd6bd9167f 4857 }
mkarlsso 0:8dbd6bd9167f 4858
mkarlsso 0:8dbd6bd9167f 4859 } else if (findIntVariable(afterEqual) != NULL) { //assign value of another variable
mkarlsso 0:8dbd6bd9167f 4860 //tmpOp = new intOperation(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 0:8dbd6bd9167f 4861 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4862 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4863 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4864 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4865 return NULL;
mkarlsso 0:8dbd6bd9167f 4866 } else {
mkarlsso 0:8dbd6bd9167f 4867 tmpOp->set(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 0:8dbd6bd9167f 4868 }
mkarlsso 0:8dbd6bd9167f 4869 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4870
mkarlsso 0:8dbd6bd9167f 4871 } else {
mkarlsso 0:8dbd6bd9167f 4872 textDisplay << "Variable not found: " << afterEqual << "\r\n";
mkarlsso 0:8dbd6bd9167f 4873 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4874 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4875 return NULL;
mkarlsso 0:8dbd6bd9167f 4876 }
mkarlsso 0:8dbd6bd9167f 4877
mkarlsso 0:8dbd6bd9167f 4878 } else {
mkarlsso 0:8dbd6bd9167f 4879 textDisplay << "Variable not found\r\n";
mkarlsso 0:8dbd6bd9167f 4880 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4881 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4882 return NULL;
mkarlsso 0:8dbd6bd9167f 4883 }
mkarlsso 0:8dbd6bd9167f 4884 textDisplay.debug("Assignment successful\r\n");
mkarlsso 0:8dbd6bd9167f 4885 return tmpAction;
mkarlsso 0:8dbd6bd9167f 4886 }
mkarlsso 0:8dbd6bd9167f 4887
mkarlsso 0:8dbd6bd9167f 4888 /*
mkarlsso 0:8dbd6bd9167f 4889 bool scriptStream::isOutsideParenth(string& expression,std::size_t foundItem) {
mkarlsso 0:8dbd6bd9167f 4890
mkarlsso 0:8dbd6bd9167f 4891 int pDepth = 0; // How many nested parentheses
mkarlsso 0:8dbd6bd9167f 4892
mkarlsso 0:8dbd6bd9167f 4893 if (foundItem < expression.length()) {
mkarlsso 0:8dbd6bd9167f 4894 for (int i = 0; i <= foundItem; i++) {
mkarlsso 0:8dbd6bd9167f 4895 if (expression[i] == '(') {
mkarlsso 0:8dbd6bd9167f 4896 pDepth++;
mkarlsso 0:8dbd6bd9167f 4897 } else if (expression[i] == ')') {
mkarlsso 0:8dbd6bd9167f 4898 pDepth--;
mkarlsso 0:8dbd6bd9167f 4899 }
mkarlsso 0:8dbd6bd9167f 4900 }
mkarlsso 0:8dbd6bd9167f 4901 if (pDepth<=0) {
mkarlsso 0:8dbd6bd9167f 4902
mkarlsso 0:8dbd6bd9167f 4903 return true;
mkarlsso 0:8dbd6bd9167f 4904 } else {
mkarlsso 0:8dbd6bd9167f 4905
mkarlsso 0:8dbd6bd9167f 4906 return false;
mkarlsso 0:8dbd6bd9167f 4907 }
mkarlsso 0:8dbd6bd9167f 4908 } else {
mkarlsso 0:8dbd6bd9167f 4909 return true;
mkarlsso 0:8dbd6bd9167f 4910 }
mkarlsso 0:8dbd6bd9167f 4911
mkarlsso 0:8dbd6bd9167f 4912 }
mkarlsso 0:8dbd6bd9167f 4913
mkarlsso 0:8dbd6bd9167f 4914 std::size_t scriptStream::findFirstOrOutsideParenth(string& expression) {
mkarlsso 0:8dbd6bd9167f 4915
mkarlsso 0:8dbd6bd9167f 4916 std::size_t foundItem = expression.find("||");
mkarlsso 0:8dbd6bd9167f 4917 while (foundItem != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 4918 if (isOutsideParenth(expression,foundItem)) {
mkarlsso 0:8dbd6bd9167f 4919 break;
mkarlsso 0:8dbd6bd9167f 4920 }
mkarlsso 0:8dbd6bd9167f 4921 foundItem = expression.find("||",foundItem+1);
mkarlsso 0:8dbd6bd9167f 4922 }
mkarlsso 0:8dbd6bd9167f 4923 return foundItem;
mkarlsso 0:8dbd6bd9167f 4924 }
mkarlsso 0:8dbd6bd9167f 4925
mkarlsso 0:8dbd6bd9167f 4926 std::size_t scriptStream::findFirstAndOutsideParenth(string& expression) {
mkarlsso 0:8dbd6bd9167f 4927
mkarlsso 0:8dbd6bd9167f 4928 std::size_t foundItem = expression.find("&&");
mkarlsso 0:8dbd6bd9167f 4929 while (foundItem != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 4930 if (isOutsideParenth(expression,foundItem)){
mkarlsso 0:8dbd6bd9167f 4931 break;
mkarlsso 0:8dbd6bd9167f 4932 }
mkarlsso 0:8dbd6bd9167f 4933 foundItem = expression.find("&&",foundItem+1);
mkarlsso 0:8dbd6bd9167f 4934 }
mkarlsso 0:8dbd6bd9167f 4935 return foundItem;
mkarlsso 0:8dbd6bd9167f 4936 }
mkarlsso 0:8dbd6bd9167f 4937
mkarlsso 0:8dbd6bd9167f 4938 condition* scriptStream::parseConditions(string& expression) {
mkarlsso 0:8dbd6bd9167f 4939 //This function is used to parse a condition string
mkarlsso 0:8dbd6bd9167f 4940 //such as (x < y && x != z) || (y == 2)
mkarlsso 0:8dbd6bd9167f 4941 //This function first identifies the root node of the logic tree
mkarlsso 0:8dbd6bd9167f 4942 //based on operator precedence ( () > && > || ), and then recursively calls itself
mkarlsso 0:8dbd6bd9167f 4943 //to find the nodes of the branches. The basic building blocks of
mkarlsso 0:8dbd6bd9167f 4944 //the final condition object are arithmatic comparitors (a > b) and
mkarlsso 0:8dbd6bd9167f 4945 //other condition objects.
mkarlsso 0:8dbd6bd9167f 4946
mkarlsso 0:8dbd6bd9167f 4947
mkarlsso 0:8dbd6bd9167f 4948
mkarlsso 0:8dbd6bd9167f 4949 condition* newCondition = NULL;
mkarlsso 0:8dbd6bd9167f 4950 bool singleCondition = false; //no compound conditions
mkarlsso 0:8dbd6bd9167f 4951 string afterComparator;
mkarlsso 0:8dbd6bd9167f 4952 string beforeComparator;
mkarlsso 0:8dbd6bd9167f 4953
mkarlsso 0:8dbd6bd9167f 4954 std::size_t found;
mkarlsso 0:8dbd6bd9167f 4955
mkarlsso 0:8dbd6bd9167f 4956 //To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso 0:8dbd6bd9167f 4957 //so we look for OR conditions first
mkarlsso 0:8dbd6bd9167f 4958 char currentOperator = OR_CONDITION;
mkarlsso 0:8dbd6bd9167f 4959
mkarlsso 0:8dbd6bd9167f 4960 found = findFirstOrOutsideParenth(expression);
mkarlsso 0:8dbd6bd9167f 4961 if (found==std::string::npos) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso 0:8dbd6bd9167f 4962 currentOperator = AND_CONDITION;
mkarlsso 0:8dbd6bd9167f 4963
mkarlsso 0:8dbd6bd9167f 4964 found = findFirstAndOutsideParenth(expression);
mkarlsso 0:8dbd6bd9167f 4965 }
mkarlsso 0:8dbd6bd9167f 4966 if (found==std::string::npos) { //no or/and conditions outside parentheses found
mkarlsso 0:8dbd6bd9167f 4967 //if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso 0:8dbd6bd9167f 4968 bool removedParenth = false;
mkarlsso 0:8dbd6bd9167f 4969 if ((expression[0] == '(') && (expression[expression.length()-1] == ')')) {
mkarlsso 0:8dbd6bd9167f 4970
mkarlsso 0:8dbd6bd9167f 4971 expression = expression.substr(1,expression.length()-2);
mkarlsso 0:8dbd6bd9167f 4972 removedParenth = true;
mkarlsso 0:8dbd6bd9167f 4973 }
mkarlsso 0:8dbd6bd9167f 4974 if (removedParenth) { //we removed parentheses, so try again
mkarlsso 0:8dbd6bd9167f 4975 textDisplay.debug("Condition: parenth removed\r\n");
mkarlsso 0:8dbd6bd9167f 4976 return parseConditions(expression);
mkarlsso 0:8dbd6bd9167f 4977 } else {
mkarlsso 0:8dbd6bd9167f 4978 singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso 0:8dbd6bd9167f 4979 }
mkarlsso 0:8dbd6bd9167f 4980 }
mkarlsso 0:8dbd6bd9167f 4981
mkarlsso 0:8dbd6bd9167f 4982 if (singleCondition) { //no compound conditions found
mkarlsso 0:8dbd6bd9167f 4983 textDisplay.debug("Single condition: ");
mkarlsso 0:8dbd6bd9167f 4984 std::size_t equalStringInd;
mkarlsso 0:8dbd6bd9167f 4985 std::size_t greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 4986 std::size_t lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 4987 std::size_t notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 4988 std::size_t greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 4989 std::size_t lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 4990 std::size_t generalCompareStringInd;
mkarlsso 0:8dbd6bd9167f 4991
mkarlsso 0:8dbd6bd9167f 4992
mkarlsso 0:8dbd6bd9167f 4993 string tmpCondition = expression;
mkarlsso 0:8dbd6bd9167f 4994 string compareString;
mkarlsso 0:8dbd6bd9167f 4995 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 4996 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 4997 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 4998 int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 4999
mkarlsso 0:8dbd6bd9167f 5000 int offset = 0;
mkarlsso 0:8dbd6bd9167f 5001 equalStringInd = tmpCondition.find("=="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5002 greaterOrEqualStringInd = tmpCondition.find(">="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5003 lessThanOrEqualStringInd = tmpCondition.find("<="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5004 notEqualStringInd = tmpCondition.find("!="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5005 greaterThanStringInd = tmpCondition.find_first_of(">"); //location of comparator
mkarlsso 0:8dbd6bd9167f 5006 lessThanStringInd = tmpCondition.find_first_of("<"); //location of comparator
mkarlsso 0:8dbd6bd9167f 5007
mkarlsso 0:8dbd6bd9167f 5008 if ((equalStringInd != std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5009 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5010
mkarlsso 0:8dbd6bd9167f 5011 generalCompareStringInd = equalStringInd;
mkarlsso 0:8dbd6bd9167f 5012 compareString = "==";
mkarlsso 0:8dbd6bd9167f 5013 textDisplay.debug("==\r\n");
mkarlsso 0:8dbd6bd9167f 5014 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd != std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5015 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5016
mkarlsso 0:8dbd6bd9167f 5017 generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5018 compareString = ">=";
mkarlsso 0:8dbd6bd9167f 5019 textDisplay.debug(">=\r\n");
mkarlsso 0:8dbd6bd9167f 5020 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5021 (lessThanOrEqualStringInd != std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5022
mkarlsso 0:8dbd6bd9167f 5023 generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5024 compareString = "<=";
mkarlsso 0:8dbd6bd9167f 5025 textDisplay.debug("<=\r\n");
mkarlsso 0:8dbd6bd9167f 5026 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5027 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd != std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5028
mkarlsso 0:8dbd6bd9167f 5029 generalCompareStringInd = notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5030 compareString = "!=";
mkarlsso 0:8dbd6bd9167f 5031 textDisplay.debug("!=\r\n");
mkarlsso 0:8dbd6bd9167f 5032 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5033 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5034 (greaterThanStringInd != std::string::npos) && (lessThanStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5035
mkarlsso 0:8dbd6bd9167f 5036 generalCompareStringInd = greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 5037 compareString = ">";
mkarlsso 0:8dbd6bd9167f 5038 offset = 1;
mkarlsso 0:8dbd6bd9167f 5039 textDisplay.debug(">\r\n");
mkarlsso 0:8dbd6bd9167f 5040 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5041 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5042 (greaterThanStringInd == std::string::npos) && (lessThanStringInd != std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5043
mkarlsso 0:8dbd6bd9167f 5044 generalCompareStringInd = lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5045 compareString = "<";
mkarlsso 0:8dbd6bd9167f 5046 offset = 1;
mkarlsso 0:8dbd6bd9167f 5047 textDisplay.debug("<\r\n");
mkarlsso 0:8dbd6bd9167f 5048
mkarlsso 0:8dbd6bd9167f 5049 }else {
mkarlsso 0:8dbd6bd9167f 5050 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5051 return 0;
mkarlsso 0:8dbd6bd9167f 5052 }
mkarlsso 0:8dbd6bd9167f 5053 textDisplay.debug("Allocating memory for condition...");
mkarlsso 0:8dbd6bd9167f 5054 intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso 0:8dbd6bd9167f 5055
mkarlsso 0:8dbd6bd9167f 5056 if (newCompare == NULL) {
mkarlsso 0:8dbd6bd9167f 5057 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5058 return NULL;
mkarlsso 0:8dbd6bd9167f 5059 }
mkarlsso 0:8dbd6bd9167f 5060 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5061 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5062 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5063 return NULL;
mkarlsso 0:8dbd6bd9167f 5064 }
mkarlsso 0:8dbd6bd9167f 5065 textDisplay.debug("success.\r\n");
mkarlsso 0:8dbd6bd9167f 5066 beforeComparator.reserve(tmpCondition.length());
mkarlsso 0:8dbd6bd9167f 5067 textDisplay << beforeComparator.capacity();
mkarlsso 0:8dbd6bd9167f 5068 textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 5069
mkarlsso 0:8dbd6bd9167f 5070 afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5071
mkarlsso 0:8dbd6bd9167f 5072 beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso 0:8dbd6bd9167f 5073
mkarlsso 0:8dbd6bd9167f 5074 tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5075 if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso 0:8dbd6bd9167f 5076 tmpVar2 = findIntVariable(afterComparator); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5077 if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso 0:8dbd6bd9167f 5078 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso 0:8dbd6bd9167f 5079 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5080 textDisplay.debug("Compare variable to variable\r\n");
mkarlsso 0:8dbd6bd9167f 5081 newCompare->set(tmpVar,compareString.data(),tmpVar2);
mkarlsso 0:8dbd6bd9167f 5082 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5083
mkarlsso 0:8dbd6bd9167f 5084
mkarlsso 0:8dbd6bd9167f 5085 } else if (isNumber(afterComparator)) {
mkarlsso 0:8dbd6bd9167f 5086 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 0:8dbd6bd9167f 5087 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5088 textDisplay.debug("Compare variable to number\r\n");
mkarlsso 0:8dbd6bd9167f 5089 newCompare->set(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 0:8dbd6bd9167f 5090 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5091
mkarlsso 0:8dbd6bd9167f 5092
mkarlsso 0:8dbd6bd9167f 5093 } //more here
mkarlsso 0:8dbd6bd9167f 5094
mkarlsso 0:8dbd6bd9167f 5095 } else {
mkarlsso 0:8dbd6bd9167f 5096 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5097
mkarlsso 0:8dbd6bd9167f 5098 return NULL;
mkarlsso 0:8dbd6bd9167f 5099 }
mkarlsso 0:8dbd6bd9167f 5100
mkarlsso 0:8dbd6bd9167f 5101 } else { //this is a compound condition (with either && or ||)
mkarlsso 0:8dbd6bd9167f 5102 textDisplay.debug("Compound condition\r\n");
mkarlsso 0:8dbd6bd9167f 5103 afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5104 beforeComparator = expression.substr(0,found);
mkarlsso 0:8dbd6bd9167f 5105 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5106 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5107 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5108 return NULL;
mkarlsso 0:8dbd6bd9167f 5109 } else {
mkarlsso 0:8dbd6bd9167f 5110 newCondition->isUsed = true; //reserve the condition slot;
mkarlsso 0:8dbd6bd9167f 5111 }
mkarlsso 0:8dbd6bd9167f 5112 //recursively call this function to parse the sub conditions
mkarlsso 0:8dbd6bd9167f 5113 condition* cond1 = parseConditions(beforeComparator);
mkarlsso 0:8dbd6bd9167f 5114 if (cond1 == NULL) {
mkarlsso 0:8dbd6bd9167f 5115 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5116 return NULL;
mkarlsso 0:8dbd6bd9167f 5117 }
mkarlsso 0:8dbd6bd9167f 5118 condition* cond2 = parseConditions(afterComparator);
mkarlsso 0:8dbd6bd9167f 5119 if (cond2 == NULL) {
mkarlsso 0:8dbd6bd9167f 5120 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5121 cond1->release();
mkarlsso 0:8dbd6bd9167f 5122 return NULL;
mkarlsso 0:8dbd6bd9167f 5123 }
mkarlsso 0:8dbd6bd9167f 5124 newCondition->set(cond1,currentOperator, cond2);
mkarlsso 0:8dbd6bd9167f 5125
mkarlsso 0:8dbd6bd9167f 5126 }
mkarlsso 0:8dbd6bd9167f 5127
mkarlsso 0:8dbd6bd9167f 5128 return newCondition; //all went well, so return the newly made condition
mkarlsso 0:8dbd6bd9167f 5129
mkarlsso 0:8dbd6bd9167f 5130 }*/
mkarlsso 0:8dbd6bd9167f 5131
mkarlsso 0:8dbd6bd9167f 5132
mkarlsso 0:8dbd6bd9167f 5133 bool scriptStream::isOutsideParenth(const char* expression,int foundItem,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5134
mkarlsso 0:8dbd6bd9167f 5135 int pDepth = 0; // How many nested parentheses
mkarlsso 0:8dbd6bd9167f 5136
mkarlsso 0:8dbd6bd9167f 5137 if ((foundItem >= start)&&(foundItem<=end)&&(foundItem < strlen(expression))&&(end < strlen(expression))&&(start <= end)&&(start>=0)) {
mkarlsso 0:8dbd6bd9167f 5138 for (int i = start; i <= foundItem; i++) {
mkarlsso 0:8dbd6bd9167f 5139 if (expression[i] == '(') {
mkarlsso 0:8dbd6bd9167f 5140 pDepth++;
mkarlsso 0:8dbd6bd9167f 5141 } else if (expression[i] == ')') {
mkarlsso 0:8dbd6bd9167f 5142 pDepth--;
mkarlsso 0:8dbd6bd9167f 5143 }
mkarlsso 0:8dbd6bd9167f 5144 }
mkarlsso 0:8dbd6bd9167f 5145 if (pDepth<=0) {
mkarlsso 0:8dbd6bd9167f 5146
mkarlsso 0:8dbd6bd9167f 5147 return true;
mkarlsso 0:8dbd6bd9167f 5148 } else {
mkarlsso 0:8dbd6bd9167f 5149
mkarlsso 0:8dbd6bd9167f 5150 return false;
mkarlsso 0:8dbd6bd9167f 5151 }
mkarlsso 0:8dbd6bd9167f 5152 } else {
mkarlsso 0:8dbd6bd9167f 5153 //error handling defaults in a true condition
mkarlsso 0:8dbd6bd9167f 5154 return true;
mkarlsso 0:8dbd6bd9167f 5155 }
mkarlsso 0:8dbd6bd9167f 5156
mkarlsso 0:8dbd6bd9167f 5157 }
mkarlsso 0:8dbd6bd9167f 5158
mkarlsso 0:8dbd6bd9167f 5159 int scriptStream::findFirstOrOutsideParenth(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5160
mkarlsso 0:8dbd6bd9167f 5161 int foundItem = findStringLoc(expression,"||",start,end);
mkarlsso 0:8dbd6bd9167f 5162 while (foundItem != -1) {
mkarlsso 0:8dbd6bd9167f 5163 if (isOutsideParenth(expression,foundItem,start,end)) {
mkarlsso 0:8dbd6bd9167f 5164 //it's out side of ()
mkarlsso 0:8dbd6bd9167f 5165 break;
mkarlsso 0:8dbd6bd9167f 5166 }
mkarlsso 0:8dbd6bd9167f 5167 //not outside ()
mkarlsso 0:8dbd6bd9167f 5168 foundItem = findStringLoc(expression,"||",foundItem+1,end);
mkarlsso 0:8dbd6bd9167f 5169 }
mkarlsso 0:8dbd6bd9167f 5170 return foundItem;
mkarlsso 0:8dbd6bd9167f 5171 }
mkarlsso 0:8dbd6bd9167f 5172
mkarlsso 0:8dbd6bd9167f 5173 int scriptStream::findFirstAndOutsideParenth(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5174
mkarlsso 0:8dbd6bd9167f 5175 int foundItem = findStringLoc(expression,"&&",start,end);
mkarlsso 0:8dbd6bd9167f 5176 while (foundItem != -1) {
mkarlsso 0:8dbd6bd9167f 5177 if (isOutsideParenth(expression,foundItem,start,end)){
mkarlsso 0:8dbd6bd9167f 5178 break;
mkarlsso 0:8dbd6bd9167f 5179 }
mkarlsso 0:8dbd6bd9167f 5180 foundItem = findStringLoc(expression,"||",foundItem+1,end);
mkarlsso 0:8dbd6bd9167f 5181 }
mkarlsso 0:8dbd6bd9167f 5182 return foundItem;
mkarlsso 0:8dbd6bd9167f 5183 }
mkarlsso 0:8dbd6bd9167f 5184
mkarlsso 0:8dbd6bd9167f 5185
mkarlsso 0:8dbd6bd9167f 5186 condition* scriptStream::parseConditions(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5187
mkarlsso 0:8dbd6bd9167f 5188
mkarlsso 0:8dbd6bd9167f 5189 //This function is used to parse a condition string
mkarlsso 0:8dbd6bd9167f 5190 //such as (x < y && x != z) || (y == 2)
mkarlsso 0:8dbd6bd9167f 5191 //This function first identifies the root node of the logic tree
mkarlsso 0:8dbd6bd9167f 5192 //based on operator precedence ( () > && > || ), and then recursively calls itself
mkarlsso 0:8dbd6bd9167f 5193 //to find the nodes of the branches. The basic building blocks of
mkarlsso 0:8dbd6bd9167f 5194 //the final condition object are arithmatic comparitors (a > b) and
mkarlsso 0:8dbd6bd9167f 5195 //other condition objects.
mkarlsso 0:8dbd6bd9167f 5196
mkarlsso 0:8dbd6bd9167f 5197
mkarlsso 0:8dbd6bd9167f 5198
mkarlsso 0:8dbd6bd9167f 5199 condition* newCondition = NULL;
mkarlsso 0:8dbd6bd9167f 5200 bool singleCondition = false; //no compound conditions
mkarlsso 0:8dbd6bd9167f 5201 //string afterComparator;
mkarlsso 0:8dbd6bd9167f 5202 //string beforeComparator;
mkarlsso 0:8dbd6bd9167f 5203 int afterComparatorLoc;
mkarlsso 0:8dbd6bd9167f 5204 int beforeComparatorLoc;
mkarlsso 0:8dbd6bd9167f 5205
mkarlsso 0:8dbd6bd9167f 5206
mkarlsso 0:8dbd6bd9167f 5207
mkarlsso 0:8dbd6bd9167f 5208 int found;
mkarlsso 0:8dbd6bd9167f 5209
mkarlsso 0:8dbd6bd9167f 5210 //To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso 0:8dbd6bd9167f 5211 //so we look for OR conditions first
mkarlsso 0:8dbd6bd9167f 5212 char currentOperator = OR_CONDITION;
mkarlsso 0:8dbd6bd9167f 5213
mkarlsso 0:8dbd6bd9167f 5214 found = findFirstOrOutsideParenth(expression,start,end);
mkarlsso 0:8dbd6bd9167f 5215 if (found==-1) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso 0:8dbd6bd9167f 5216 currentOperator = AND_CONDITION;
mkarlsso 0:8dbd6bd9167f 5217
mkarlsso 0:8dbd6bd9167f 5218 found = findFirstAndOutsideParenth(expression,start,end);
mkarlsso 0:8dbd6bd9167f 5219 }
mkarlsso 0:8dbd6bd9167f 5220 if (found==-1) { //no or/and conditions outside parentheses found
mkarlsso 0:8dbd6bd9167f 5221 //if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso 0:8dbd6bd9167f 5222 bool removedParenth = false;
mkarlsso 0:8dbd6bd9167f 5223 if ((expression[start] == '(') && (expression[end] == ')')) {
mkarlsso 0:8dbd6bd9167f 5224
mkarlsso 0:8dbd6bd9167f 5225 start++;
mkarlsso 0:8dbd6bd9167f 5226 end--;
mkarlsso 0:8dbd6bd9167f 5227
mkarlsso 0:8dbd6bd9167f 5228 //expression = expression.substr(1,expression.length()-2);
mkarlsso 0:8dbd6bd9167f 5229 removedParenth = true;
mkarlsso 0:8dbd6bd9167f 5230 }
mkarlsso 0:8dbd6bd9167f 5231 if (removedParenth) { //we removed parentheses, so try again
mkarlsso 0:8dbd6bd9167f 5232 textDisplay.debug("Condition: parenth removed\r\n");
mkarlsso 0:8dbd6bd9167f 5233 return parseConditions(expression,start,end);
mkarlsso 0:8dbd6bd9167f 5234 } else {
mkarlsso 0:8dbd6bd9167f 5235 singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso 0:8dbd6bd9167f 5236 }
mkarlsso 0:8dbd6bd9167f 5237 }
mkarlsso 0:8dbd6bd9167f 5238
mkarlsso 0:8dbd6bd9167f 5239 if (singleCondition) { //no compound conditions found
mkarlsso 0:8dbd6bd9167f 5240 textDisplay.debug("Single condition: ");
mkarlsso 0:8dbd6bd9167f 5241 int equalStringInd;
mkarlsso 0:8dbd6bd9167f 5242 int greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5243 int lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5244 int notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5245 int greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 5246 int lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5247 int generalCompareStringInd;
mkarlsso 0:8dbd6bd9167f 5248
mkarlsso 0:8dbd6bd9167f 5249
mkarlsso 0:8dbd6bd9167f 5250 //string tmpCondition = expression;
mkarlsso 0:8dbd6bd9167f 5251 char compareString[3];
mkarlsso 0:8dbd6bd9167f 5252 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 5253 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 5254 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 5255 //int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 5256
mkarlsso 0:8dbd6bd9167f 5257 int offset = 0;
mkarlsso 0:8dbd6bd9167f 5258 equalStringInd = findStringLoc(expression,"==",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5259 greaterOrEqualStringInd = findStringLoc(expression,">=",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5260 lessThanOrEqualStringInd = findStringLoc(expression,"<=",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5261 notEqualStringInd = findStringLoc(expression,"!=",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5262 greaterThanStringInd = findStringLoc(expression,">",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5263 lessThanStringInd = findStringLoc(expression,"<",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5264
mkarlsso 0:8dbd6bd9167f 5265 if ((equalStringInd != -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5266 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5267
mkarlsso 0:8dbd6bd9167f 5268 generalCompareStringInd = equalStringInd;
mkarlsso 0:8dbd6bd9167f 5269 strcpy(compareString,"==");
mkarlsso 0:8dbd6bd9167f 5270 //compareString = "==";
mkarlsso 0:8dbd6bd9167f 5271 textDisplay.debug("==\r\n");
mkarlsso 0:8dbd6bd9167f 5272 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd != -1) &&
mkarlsso 0:8dbd6bd9167f 5273 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5274
mkarlsso 0:8dbd6bd9167f 5275 generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5276 strcpy(compareString,">=");
mkarlsso 0:8dbd6bd9167f 5277 //compareString = ">=";
mkarlsso 0:8dbd6bd9167f 5278 textDisplay.debug(">=\r\n");
mkarlsso 0:8dbd6bd9167f 5279 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5280 (lessThanOrEqualStringInd != -1) && (notEqualStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5281
mkarlsso 0:8dbd6bd9167f 5282 generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5283 strcpy(compareString,"<=");
mkarlsso 0:8dbd6bd9167f 5284 //compareString = "<=";
mkarlsso 0:8dbd6bd9167f 5285 textDisplay.debug("<=\r\n");
mkarlsso 0:8dbd6bd9167f 5286 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5287 (lessThanOrEqualStringInd == -1) && (notEqualStringInd != -1)){
mkarlsso 0:8dbd6bd9167f 5288
mkarlsso 0:8dbd6bd9167f 5289 generalCompareStringInd = notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5290 strcpy(compareString,"!=");
mkarlsso 0:8dbd6bd9167f 5291 //compareString = "!=";
mkarlsso 0:8dbd6bd9167f 5292 textDisplay.debug("!=\r\n");
mkarlsso 0:8dbd6bd9167f 5293 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5294 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5295 (greaterThanStringInd != -1) && (lessThanStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5296
mkarlsso 0:8dbd6bd9167f 5297 generalCompareStringInd = greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 5298 strcpy(compareString,">");
mkarlsso 0:8dbd6bd9167f 5299 //compareString = ">";
mkarlsso 0:8dbd6bd9167f 5300 offset = 1;
mkarlsso 0:8dbd6bd9167f 5301 textDisplay.debug(">\r\n");
mkarlsso 0:8dbd6bd9167f 5302 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5303 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5304 (greaterThanStringInd == -1) && (lessThanStringInd != -1)){
mkarlsso 0:8dbd6bd9167f 5305
mkarlsso 0:8dbd6bd9167f 5306 generalCompareStringInd = lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5307 strcpy(compareString,"<");
mkarlsso 0:8dbd6bd9167f 5308 //compareString = "<";
mkarlsso 0:8dbd6bd9167f 5309 offset = 1;
mkarlsso 0:8dbd6bd9167f 5310 textDisplay.debug("<\r\n");
mkarlsso 0:8dbd6bd9167f 5311
mkarlsso 0:8dbd6bd9167f 5312 }else {
mkarlsso 0:8dbd6bd9167f 5313 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5314 return 0;
mkarlsso 0:8dbd6bd9167f 5315 }
mkarlsso 0:8dbd6bd9167f 5316 textDisplay.debug("Allocating memory for condition...");
mkarlsso 0:8dbd6bd9167f 5317 intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso 0:8dbd6bd9167f 5318
mkarlsso 0:8dbd6bd9167f 5319 if (newCompare == NULL) {
mkarlsso 0:8dbd6bd9167f 5320 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5321 return NULL;
mkarlsso 0:8dbd6bd9167f 5322 }
mkarlsso 0:8dbd6bd9167f 5323 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5324 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5325 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5326 return NULL;
mkarlsso 0:8dbd6bd9167f 5327 }
mkarlsso 0:8dbd6bd9167f 5328 textDisplay.debug("success.\r\n");
mkarlsso 0:8dbd6bd9167f 5329 //beforeComparator.reserve(tmpCondition.length());
mkarlsso 0:8dbd6bd9167f 5330 //textDisplay << beforeComparator.capacity();
mkarlsso 0:8dbd6bd9167f 5331 //textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 5332
mkarlsso 0:8dbd6bd9167f 5333 afterComparatorLoc = generalCompareStringInd+2-offset;
mkarlsso 0:8dbd6bd9167f 5334 beforeComparatorLoc = generalCompareStringInd-1;
mkarlsso 0:8dbd6bd9167f 5335
mkarlsso 0:8dbd6bd9167f 5336 //afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5337 //beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso 0:8dbd6bd9167f 5338
mkarlsso 0:8dbd6bd9167f 5339 //tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5340 tmpVar = findIntVariable(expression,start,beforeComparatorLoc);
mkarlsso 0:8dbd6bd9167f 5341
mkarlsso 0:8dbd6bd9167f 5342 if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso 0:8dbd6bd9167f 5343 tmpVar2 = findIntVariable(expression, afterComparatorLoc, end); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5344 if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso 0:8dbd6bd9167f 5345 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso 0:8dbd6bd9167f 5346 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5347 textDisplay.debug("Compare variable to variable\r\n");
mkarlsso 0:8dbd6bd9167f 5348 newCompare->set(tmpVar,compareString,tmpVar2);
mkarlsso 0:8dbd6bd9167f 5349 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5350
mkarlsso 0:8dbd6bd9167f 5351
mkarlsso 0:8dbd6bd9167f 5352 } else if (isNum(expression, afterComparatorLoc, end)) {
mkarlsso 0:8dbd6bd9167f 5353 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 0:8dbd6bd9167f 5354 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5355 textDisplay.debug("Compare variable to number\r\n");
mkarlsso 0:8dbd6bd9167f 5356 newCompare->set(tmpVar,compareString,atoi(expression+afterComparatorLoc));
mkarlsso 0:8dbd6bd9167f 5357 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5358
mkarlsso 0:8dbd6bd9167f 5359
mkarlsso 0:8dbd6bd9167f 5360 } else {
mkarlsso 0:8dbd6bd9167f 5361 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5362 return NULL;
mkarlsso 0:8dbd6bd9167f 5363 }//more here
mkarlsso 0:8dbd6bd9167f 5364
mkarlsso 0:8dbd6bd9167f 5365 } else {
mkarlsso 0:8dbd6bd9167f 5366 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5367
mkarlsso 0:8dbd6bd9167f 5368 return NULL;
mkarlsso 0:8dbd6bd9167f 5369 }
mkarlsso 0:8dbd6bd9167f 5370
mkarlsso 0:8dbd6bd9167f 5371 } else { //this is a compound condition (with either && or ||)
mkarlsso 0:8dbd6bd9167f 5372 textDisplay.debug("Compound condition\r\n");
mkarlsso 0:8dbd6bd9167f 5373 afterComparatorLoc = found+2;
mkarlsso 0:8dbd6bd9167f 5374 beforeComparatorLoc = found-1;
mkarlsso 0:8dbd6bd9167f 5375 //afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5376 //beforeComparator = expression.substr(0,found);
mkarlsso 0:8dbd6bd9167f 5377 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5378 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5379 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5380 return NULL;
mkarlsso 0:8dbd6bd9167f 5381 } else {
mkarlsso 0:8dbd6bd9167f 5382 newCondition->isUsed = true; //reserve the condition slot;
mkarlsso 0:8dbd6bd9167f 5383 }
mkarlsso 0:8dbd6bd9167f 5384 //recursively call this function to parse the sub conditions
mkarlsso 0:8dbd6bd9167f 5385 condition* cond1 = parseConditions(expression,start,beforeComparatorLoc);
mkarlsso 0:8dbd6bd9167f 5386 if (cond1 == NULL) {
mkarlsso 0:8dbd6bd9167f 5387 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5388 return NULL;
mkarlsso 0:8dbd6bd9167f 5389 }
mkarlsso 0:8dbd6bd9167f 5390 condition* cond2 = parseConditions(expression,afterComparatorLoc,end);
mkarlsso 0:8dbd6bd9167f 5391 if (cond2 == NULL) {
mkarlsso 0:8dbd6bd9167f 5392 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5393 cond1->release();
mkarlsso 0:8dbd6bd9167f 5394 return NULL;
mkarlsso 0:8dbd6bd9167f 5395 }
mkarlsso 0:8dbd6bd9167f 5396 newCondition->set(cond1,currentOperator, cond2);
mkarlsso 0:8dbd6bd9167f 5397
mkarlsso 0:8dbd6bd9167f 5398 }
mkarlsso 0:8dbd6bd9167f 5399
mkarlsso 0:8dbd6bd9167f 5400 return newCondition; //all went well, so return the newly made condition
mkarlsso 0:8dbd6bd9167f 5401
mkarlsso 0:8dbd6bd9167f 5402
mkarlsso 0:8dbd6bd9167f 5403 }
mkarlsso 0:8dbd6bd9167f 5404
mkarlsso 0:8dbd6bd9167f 5405
mkarlsso 0:8dbd6bd9167f 5406
mkarlsso 0:8dbd6bd9167f 5407
mkarlsso 0:8dbd6bd9167f 5408 bool scriptStream::evaluateConditions(string& expression, event* currentEvent) {
mkarlsso 0:8dbd6bd9167f 5409 //calls the function to parse the condition string. The condition pointer is then
mkarlsso 0:8dbd6bd9167f 5410 //attached to the event
mkarlsso 0:8dbd6bd9167f 5411
mkarlsso 0:8dbd6bd9167f 5412 condition* newCondition = NULL;
mkarlsso 0:8dbd6bd9167f 5413 //newCondition = parseConditions(expression);
mkarlsso 0:8dbd6bd9167f 5414 newCondition = parseConditions(expression.data(),0,expression.length()-1);
mkarlsso 0:8dbd6bd9167f 5415 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5416 return false;
mkarlsso 0:8dbd6bd9167f 5417 } else {
mkarlsso 0:8dbd6bd9167f 5418 currentEvent->addCondition(newCondition);
mkarlsso 0:8dbd6bd9167f 5419 return true;
mkarlsso 0:8dbd6bd9167f 5420 }
mkarlsso 0:8dbd6bd9167f 5421 }
mkarlsso 0:8dbd6bd9167f 5422
mkarlsso 0:8dbd6bd9167f 5423 int scriptStream::getRandomParam(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5424
mkarlsso 0:8dbd6bd9167f 5425 int pos1 = findStringLoc(expression,"random(",start,end)+7;
mkarlsso 0:8dbd6bd9167f 5426 int pos2 = findStringLoc(expression,")",pos1,end);
mkarlsso 0:8dbd6bd9167f 5427 if (pos2 == -1) {
mkarlsso 0:8dbd6bd9167f 5428 textDisplay << "Error: bad syntax\r\n";
mkarlsso 0:8dbd6bd9167f 5429 return 0;
mkarlsso 0:8dbd6bd9167f 5430 }
mkarlsso 0:8dbd6bd9167f 5431
mkarlsso 0:8dbd6bd9167f 5432 int highVal = atoi(expression+pos1);
mkarlsso 0:8dbd6bd9167f 5433
mkarlsso 0:8dbd6bd9167f 5434 if ((highVal > 0)) {
mkarlsso 0:8dbd6bd9167f 5435 return highVal;
mkarlsso 0:8dbd6bd9167f 5436 } else {
mkarlsso 0:8dbd6bd9167f 5437 textDisplay << "Error: random parameter must be 1 or more\r\n";
mkarlsso 0:8dbd6bd9167f 5438 return 0;
mkarlsso 0:8dbd6bd9167f 5439 }
mkarlsso 0:8dbd6bd9167f 5440 }
mkarlsso 0:8dbd6bd9167f 5441
mkarlsso 0:8dbd6bd9167f 5442 int scriptStream::getRandomParam(string expression) {
mkarlsso 0:8dbd6bd9167f 5443
mkarlsso 0:8dbd6bd9167f 5444 int pos1 = expression.find("random(")+7;
mkarlsso 0:8dbd6bd9167f 5445 int pos2 = expression.find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 5446 int highVal = atoi(expression.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 5447
mkarlsso 0:8dbd6bd9167f 5448 if ((highVal > 0)) {
mkarlsso 0:8dbd6bd9167f 5449 return highVal;
mkarlsso 0:8dbd6bd9167f 5450 } else {
mkarlsso 0:8dbd6bd9167f 5451 textDisplay << "Error: random parameter must be 1 or more\r\n";
mkarlsso 0:8dbd6bd9167f 5452 return 0;
mkarlsso 0:8dbd6bd9167f 5453 }
mkarlsso 0:8dbd6bd9167f 5454 }
mkarlsso 0:8dbd6bd9167f 5455
mkarlsso 0:8dbd6bd9167f 5456 int scriptStream::findStringLoc(const char *refString, const char *findString,int start,int end) {
mkarlsso 0:8dbd6bd9167f 5457 //look for 'findString' inside 'refString', only considering characters in between 'start' and 'end'
mkarlsso 0:8dbd6bd9167f 5458 //return -1 if not found
mkarlsso 0:8dbd6bd9167f 5459
mkarlsso 0:8dbd6bd9167f 5460 if ((start < strlen(refString))&&(end < strlen(refString))&&(end >= start)) {
mkarlsso 0:8dbd6bd9167f 5461 const char* charPtr = strstr(refString+start,findString);
mkarlsso 0:8dbd6bd9167f 5462 //if found, make sure it was containted within the start and end bounds
mkarlsso 0:8dbd6bd9167f 5463 if ((charPtr != NULL) && ((int)(charPtr-refString) <= (end-strlen(findString)+1))) {
mkarlsso 0:8dbd6bd9167f 5464 return (int)(charPtr-refString);
mkarlsso 0:8dbd6bd9167f 5465 }
mkarlsso 0:8dbd6bd9167f 5466 }
mkarlsso 0:8dbd6bd9167f 5467 return -1;
mkarlsso 0:8dbd6bd9167f 5468 }
mkarlsso 0:8dbd6bd9167f 5469
mkarlsso 0:8dbd6bd9167f 5470 bool scriptStream::isNum(const char *expression, int start, int end) {
mkarlsso 0:8dbd6bd9167f 5471
mkarlsso 0:8dbd6bd9167f 5472 if ((start>0)&&(end<strlen(expression))&&(start<=end)) {
mkarlsso 0:8dbd6bd9167f 5473
mkarlsso 0:8dbd6bd9167f 5474 bool outcome = true;
mkarlsso 0:8dbd6bd9167f 5475 while (start <= end) {
mkarlsso 0:8dbd6bd9167f 5476 //look for any digit, or a - sign
mkarlsso 0:8dbd6bd9167f 5477 if (!((expression[start] >= 45) && (expression[start] <= 57) && (expression[start] != 46) && (expression[start] != 47))) {
mkarlsso 0:8dbd6bd9167f 5478 outcome = false;
mkarlsso 0:8dbd6bd9167f 5479 break;
mkarlsso 0:8dbd6bd9167f 5480 }
mkarlsso 0:8dbd6bd9167f 5481 start++;
mkarlsso 0:8dbd6bd9167f 5482 }
mkarlsso 0:8dbd6bd9167f 5483 return outcome;
mkarlsso 0:8dbd6bd9167f 5484 }
mkarlsso 0:8dbd6bd9167f 5485 return false;
mkarlsso 0:8dbd6bd9167f 5486 }
mkarlsso 0:8dbd6bd9167f 5487
mkarlsso 0:8dbd6bd9167f 5488 bool scriptStream::areStringsSame(const char *str1, const char *str2, int start, int end) {
mkarlsso 0:8dbd6bd9167f 5489 if ((findStringLoc(str1,str2,start,end) != -1) && (strlen(str2)==(end-start+1))) {
mkarlsso 0:8dbd6bd9167f 5490 return true;
mkarlsso 0:8dbd6bd9167f 5491 } else {
mkarlsso 0:8dbd6bd9167f 5492 return false;
mkarlsso 0:8dbd6bd9167f 5493 }
mkarlsso 0:8dbd6bd9167f 5494
mkarlsso 0:8dbd6bd9167f 5495
mkarlsso 0:8dbd6bd9167f 5496 }
mkarlsso 0:8dbd6bd9167f 5497
mkarlsso 5:abee20c0bf2a 5498 void scriptStream::clearEnvironmentVariables(int clearMode) {
mkarlsso 5:abee20c0bf2a 5499 //Modes:
mkarlsso 5:abee20c0bf2a 5500
mkarlsso 5:abee20c0bf2a 5501 //clear callbacks, functions, and queue
mkarlsso 5:abee20c0bf2a 5502 if (clearMode & BLOCKMEMORYTYPES) {
mkarlsso 5:abee20c0bf2a 5503 for (int pNum = 0; pNum < NUMPORTS; pNum++) {
mkarlsso 5:abee20c0bf2a 5504 //delete portVector[pNum]->triggerUpEventPtr;
mkarlsso 5:abee20c0bf2a 5505 if (portVector[pNum].triggerUpEventPtr != NULL) {
mkarlsso 5:abee20c0bf2a 5506 portVector[pNum].triggerUpEventPtr->release();
mkarlsso 5:abee20c0bf2a 5507 }
mkarlsso 5:abee20c0bf2a 5508 portVector[pNum].triggerUpEventPtr = NULL;
mkarlsso 5:abee20c0bf2a 5509
mkarlsso 5:abee20c0bf2a 5510 //delete portVector[pNum]->triggerDownEventPtr;
mkarlsso 5:abee20c0bf2a 5511 if (portVector[pNum].triggerDownEventPtr != NULL) {
mkarlsso 5:abee20c0bf2a 5512 portVector[pNum].triggerDownEventPtr->release();
mkarlsso 5:abee20c0bf2a 5513 }
mkarlsso 5:abee20c0bf2a 5514 portVector[pNum].triggerDownEventPtr = NULL;
mkarlsso 5:abee20c0bf2a 5515
mkarlsso 5:abee20c0bf2a 5516 }
mkarlsso 5:abee20c0bf2a 5517 for (int i = 0; i < NUMFUNCTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5518 functionSpotTaken[i] = false;
mkarlsso 5:abee20c0bf2a 5519 functionEventArray[i] = NULL;
mkarlsso 5:abee20c0bf2a 5520 }
mkarlsso 5:abee20c0bf2a 5521 for (int i = 0; i < NUMEVENTS; i++) {
mkarlsso 5:abee20c0bf2a 5522 eventBlock[i].release();
mkarlsso 5:abee20c0bf2a 5523 }
mkarlsso 5:abee20c0bf2a 5524 for (int i = 0; i < NUMCONDITIONS; i++) {
mkarlsso 5:abee20c0bf2a 5525 conditionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5526 }
mkarlsso 5:abee20c0bf2a 5527 for (int i = 0; i < NUMINTCOMPARE; i++) {
mkarlsso 5:abee20c0bf2a 5528 intCompareBlock[i].release();
mkarlsso 5:abee20c0bf2a 5529 }
mkarlsso 5:abee20c0bf2a 5530 for (int i = 0; i < NUMACTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5531 actionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5532 }
mkarlsso 5:abee20c0bf2a 5533 for (int i = 0; i < NUMPORTMESSAGES; i++) {
mkarlsso 5:abee20c0bf2a 5534 portMessageBlock[i].release();
mkarlsso 5:abee20c0bf2a 5535 }
mkarlsso 5:abee20c0bf2a 5536 for (int i = 0; i < NUMINTOPERATIONS; i++) {
mkarlsso 5:abee20c0bf2a 5537 intOperationBlock[i].release();
mkarlsso 5:abee20c0bf2a 5538 }
mkarlsso 5:abee20c0bf2a 5539 for (int i = 0; i < NUMDISPLAYACTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5540 displayActionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5541 }
mkarlsso 5:abee20c0bf2a 5542 for (int i = 0; i <NUMTRIGGERACTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5543 triggerFunctionActionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5544 }
mkarlsso 5:abee20c0bf2a 5545
mkarlsso 5:abee20c0bf2a 5546 queuePtr->eraseQueue();
mkarlsso 5:abee20c0bf2a 5547 }
mkarlsso 5:abee20c0bf2a 5548
mkarlsso 5:abee20c0bf2a 5549 if (clearMode & VARIABLEMEMORYTYPES) {
mkarlsso 5:abee20c0bf2a 5550 while (!globalVariables.empty()) {
mkarlsso 5:abee20c0bf2a 5551 delete globalVariables.back();
mkarlsso 5:abee20c0bf2a 5552 globalVariables.pop_back();
mkarlsso 5:abee20c0bf2a 5553 }
mkarlsso 5:abee20c0bf2a 5554 }
mkarlsso 5:abee20c0bf2a 5555
mkarlsso 5:abee20c0bf2a 5556 if (clearMode & ENVSETTINGSMEMORYTYPES) {
mkarlsso 5:abee20c0bf2a 5557 //set all environment settings to default values
mkarlsso 5:abee20c0bf2a 5558 broadCastStateChanges = true;
mkarlsso 5:abee20c0bf2a 5559 for (int i=0;i<NUMPORTS;i++) {
mkarlsso 5:abee20c0bf2a 5560 system->setPortUpdatesOn(i);
mkarlsso 5:abee20c0bf2a 5561 }
mkarlsso 5:abee20c0bf2a 5562 }
mkarlsso 5:abee20c0bf2a 5563
mkarlsso 5:abee20c0bf2a 5564
mkarlsso 5:abee20c0bf2a 5565
mkarlsso 5:abee20c0bf2a 5566 }
mkarlsso 5:abee20c0bf2a 5567