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@10:cd8d235fe993, 2016-01-28 (annotated)

Committer:
alustig3
Date:
Thu Jan 28 16:58:03 2016 +0000
Revision:
10:cd8d235fe993
Parent:
9:f15ad8d18881 
SOMO II integration.; Pin mappings for Karpova Lab stateScript boards

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)
alustig3 9:f15ad8d18881 2309 // sound(s03)
mkarlsso 0:8dbd6bd9167f 2310 } else if (tokens[i].find("sound(") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2311 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2312 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2313 lineError = true;
mkarlsso 0:8dbd6bd9167f 2314 }
mkarlsso 0:8dbd6bd9167f 2315 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2316 int pos1 = tmpLine.find("sound(")+6;
mkarlsso 0:8dbd6bd9167f 2317 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 6:67d67d452545 2318 if (pos2 == std::string::npos) {
mkarlsso 6:67d67d452545 2319 textDisplay << "Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2320 lineError = true;
mkarlsso 0:8dbd6bd9167f 2321 }
mkarlsso 6:67d67d452545 2322 if (!lineError) {
mkarlsso 6:67d67d452545 2323 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 6:67d67d452545 2324 int* tmpVar = findIntVariable(dispVar);
mkarlsso 6:67d67d452545 2325 bool isText = false;
mkarlsso 6:67d67d452545 2326 bool stopSignal = false;
mkarlsso 6:67d67d452545 2327 bool resetSignal = false;
alustig3 9:f15ad8d18881 2328 unsigned char sendTrack = 0;
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;
alustig3 9:f15ad8d18881 2332 // textDisplay <<"command= "<<tmpLine.substr(pos1+1,pos2-pos1-2)<<"\r\n";
alustig3 9:f15ad8d18881 2333 } else if (tmpLine.compare(pos1,1,"s")==0 && dispVar.length()==3) {
alustig3 9:f15ad8d18881 2334 sendTrack = (dispVar[1]-48)*10 + dispVar[2]-48;
mkarlsso 6:67d67d452545 2335 } else if (dispVar.compare("stop") == 0) {
mkarlsso 6:67d67d452545 2336 stopSignal = true;
mkarlsso 6:67d67d452545 2337 } else if (dispVar.compare("reset") == 0) {
mkarlsso 6:67d67d452545 2338 resetSignal = true;
mkarlsso 0:8dbd6bd9167f 2339 } else {
mkarlsso 6:67d67d452545 2340 textDisplay << "Error: variable input to sound() does not exist\r\n";
mkarlsso 0:8dbd6bd9167f 2341 lineError = true;
mkarlsso 0:8dbd6bd9167f 2342 }
mkarlsso 6:67d67d452545 2343 }
mkarlsso 6:67d67d452545 2344 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 6:67d67d452545 2345 if (tmpAction == NULL) {
mkarlsso 6:67d67d452545 2346 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2347 lineError = true;
mkarlsso 0:8dbd6bd9167f 2348 }
mkarlsso 6:67d67d452545 2349 if (!lineError && (blockDepth == 0)) {
mkarlsso 6:67d67d452545 2350 //we are not inside a block structure, so play sound now
mkarlsso 6:67d67d452545 2351 if (stopSignal) {
mkarlsso 6:67d67d452545 2352 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2353 S->setPlayback(false);
mkarlsso 6:67d67d452545 2354 S->execute();
mkarlsso 6:67d67d452545 2355 delete S;
mkarlsso 6:67d67d452545 2356 } else if (resetSignal) {
mkarlsso 6:67d67d452545 2357 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2358 S->setReset();
mkarlsso 6:67d67d452545 2359 S->execute();
mkarlsso 6:67d67d452545 2360 delete S;
alustig3 9:f15ad8d18881 2361 } else if (sendTrack>0 && sendTrack<100){ //track number must be 1-99
alustig3 9:f15ad8d18881 2362 sSound* S = system->createNewSoundAction();
alustig3 9:f15ad8d18881 2363 // textDisplay<<"sent:"<<sendTrack;
alustig3 9:f15ad8d18881 2364 S->setFile(sendTrack);
alustig3 9:f15ad8d18881 2365 S->execute();
alustig3 9:f15ad8d18881 2366 delete S;
mkarlsso 6:67d67d452545 2367 } else if (isText) {
mkarlsso 6:67d67d452545 2368 if (pos2-pos1-2 <= 20) {
mkarlsso 6:67d67d452545 2369 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2370 S->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 6:67d67d452545 2371 S->execute();
mkarlsso 6:67d67d452545 2372 delete S;
mkarlsso 6:67d67d452545 2373 } else {
mkarlsso 6:67d67d452545 2374 textDisplay << "Error: sound file names must be 20 characters or less.\r\n";
mkarlsso 6:67d67d452545 2375 lineError = true;
mkarlsso 6:67d67d452545 2376 }
mkarlsso 6:67d67d452545 2377 } else {
mkarlsso 6:67d67d452545 2378 textDisplay << "Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n";
mkarlsso 6:67d67d452545 2379 lineError = true;
mkarlsso 6:67d67d452545 2380 }
mkarlsso 6:67d67d452545 2381
mkarlsso 6:67d67d452545 2382 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 6:67d67d452545 2383 //the disp function was put inside a block
mkarlsso 6:67d67d452545 2384 textDisplay.debug("Sound statement\r\n");
mkarlsso 6:67d67d452545 2385 if (stopSignal) {
mkarlsso 0:8dbd6bd9167f 2386 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2387 sPtr->setPlayback(false);
mkarlsso 0:8dbd6bd9167f 2388 //action* tmpAction = new action(sPtr);
mkarlsso 0:8dbd6bd9167f 2389 tmpAction->set(sPtr);
mkarlsso 0:8dbd6bd9167f 2390 tmpEventPtrArray.back()->addAction(tmpAction);
alustig3 9:f15ad8d18881 2391 }else if (resetSignal) {
mkarlsso 6:67d67d452545 2392 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2393 sPtr->setReset();
mkarlsso 6:67d67d452545 2394 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2395 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2396 tmpEventPtrArray.back()->addAction(tmpAction);
alustig3 9:f15ad8d18881 2397 }else if (sendTrack>0 && sendTrack<100){
alustig3 9:f15ad8d18881 2398 sSound* sPtr = system->createNewSoundAction();
alustig3 9:f15ad8d18881 2399 sPtr->setFile(sendTrack);
alustig3 9:f15ad8d18881 2400 tmpAction->set(sPtr);
alustig3 9:f15ad8d18881 2401 tmpEventPtrArray.back()->addAction(tmpAction);
alustig3 9:f15ad8d18881 2402 }else if (isText) {
mkarlsso 6:67d67d452545 2403 if (pos2-pos1-2 <= 20) {
mkarlsso 6:67d67d452545 2404 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2405 sPtr->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 6:67d67d452545 2406 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2407 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2408 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2409 } else {
mkarlsso 6:67d67d452545 2410 textDisplay << "Error: sound file names must be 20 characters or less.\r\n";
mkarlsso 6:67d67d452545 2411 lineError = true;
mkarlsso 6:67d67d452545 2412 }
mkarlsso 0:8dbd6bd9167f 2413 } else {
mkarlsso 6:67d67d452545 2414 textDisplay << "Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n";
mkarlsso 0:8dbd6bd9167f 2415 lineError = true;
mkarlsso 0:8dbd6bd9167f 2416 }
mkarlsso 0:8dbd6bd9167f 2417 }
mkarlsso 0:8dbd6bd9167f 2418 }
mkarlsso 0:8dbd6bd9167f 2419
mkarlsso 0:8dbd6bd9167f 2420 } else if (tokens[i].find("volume(") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2421 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2422 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2423 lineError = true;
mkarlsso 0:8dbd6bd9167f 2424 }
mkarlsso 0:8dbd6bd9167f 2425 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2426 int pos1 = tmpLine.find("volume(")+7;
mkarlsso 0:8dbd6bd9167f 2427 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 6:67d67d452545 2428 if (pos2 == std::string::npos) {
mkarlsso 6:67d67d452545 2429 textDisplay << "Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2430 lineError = true;
mkarlsso 0:8dbd6bd9167f 2431 }
mkarlsso 6:67d67d452545 2432 if (!lineError) {
mkarlsso 6:67d67d452545 2433 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 6:67d67d452545 2434
mkarlsso 6:67d67d452545 2435 int* tmpVar = findIntVariable(dispVar);
mkarlsso 6:67d67d452545 2436 bool isText = false;
mkarlsso 6:67d67d452545 2437 if (tmpVar == NULL) {
mkarlsso 6:67d67d452545 2438 if (isNumber(dispVar)) {
mkarlsso 6:67d67d452545 2439 isText = true;
mkarlsso 0:8dbd6bd9167f 2440 } else {
mkarlsso 6:67d67d452545 2441 textDisplay << "Error: variable input to volume() does not exist\r\n";
mkarlsso 0:8dbd6bd9167f 2442 lineError = true;
mkarlsso 0:8dbd6bd9167f 2443 }
mkarlsso 6:67d67d452545 2444 }
mkarlsso 6:67d67d452545 2445 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 6:67d67d452545 2446 if (tmpAction == NULL) {
mkarlsso 6:67d67d452545 2447 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 6:67d67d452545 2448 lineError = true;
mkarlsso 0:8dbd6bd9167f 2449 }
mkarlsso 6:67d67d452545 2450 if (!lineError && (blockDepth == 0)) {
mkarlsso 6:67d67d452545 2451 //we are not inside a block structure, so play sound now
mkarlsso 6:67d67d452545 2452 if (isText) {
mkarlsso 6:67d67d452545 2453 int newVolume = atoi(dispVar.data());
alustig3 9:f15ad8d18881 2454 if ((newVolume >=0)&&(newVolume <= 255)) { // for SOMO II it should be between 0 and 30, but I'm not sure how to let this code know whether the SOMO or the smartWAV is being used
mkarlsso 6:67d67d452545 2455 sSound* S = system->createNewSoundAction();
alustig3 9:f15ad8d18881 2456 // textDisplay << "new vol=" <<newVolume;
mkarlsso 6:67d67d452545 2457 S->setVolume(newVolume);
mkarlsso 6:67d67d452545 2458 S->execute();
mkarlsso 6:67d67d452545 2459 delete S;
mkarlsso 6:67d67d452545 2460 } else {
alustig3 9:f15ad8d18881 2461 textDisplay << "Error: sound volume must be between 0 and 255 .\r\n";
mkarlsso 6:67d67d452545 2462 lineError = true;
mkarlsso 6:67d67d452545 2463 }
mkarlsso 6:67d67d452545 2464 } else {
mkarlsso 6:67d67d452545 2465 sSound* S = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2466 S->setVolume(tmpVar);
mkarlsso 6:67d67d452545 2467 S->execute();
mkarlsso 6:67d67d452545 2468 delete S;
mkarlsso 6:67d67d452545 2469 }
mkarlsso 6:67d67d452545 2470
mkarlsso 6:67d67d452545 2471 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 6:67d67d452545 2472 //the disp function was put inside a block
mkarlsso 6:67d67d452545 2473 textDisplay.debug("Volume statement\r\n");
mkarlsso 6:67d67d452545 2474 if (isText) {
mkarlsso 6:67d67d452545 2475 int newVolume = atoi(dispVar.data());
mkarlsso 6:67d67d452545 2476
mkarlsso 6:67d67d452545 2477 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2478 sPtr->setVolume(newVolume);
mkarlsso 6:67d67d452545 2479
mkarlsso 6:67d67d452545 2480 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2481 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2482 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2483
mkarlsso 6:67d67d452545 2484 } else {
mkarlsso 6:67d67d452545 2485 sSound* sPtr = system->createNewSoundAction();
mkarlsso 6:67d67d452545 2486 sPtr->setVolume(tmpVar);
mkarlsso 6:67d67d452545 2487 //action* tmpAction = new action(sPtr);
mkarlsso 6:67d67d452545 2488 tmpAction->set(sPtr);
mkarlsso 6:67d67d452545 2489 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 6:67d67d452545 2490 }
mkarlsso 6:67d67d452545 2491
mkarlsso 6:67d67d452545 2492
mkarlsso 0:8dbd6bd9167f 2493 }
mkarlsso 0:8dbd6bd9167f 2494 }
mkarlsso 0:8dbd6bd9167f 2495 //clock statement used to is used to control the clock-------------------------
mkarlsso 0:8dbd6bd9167f 2496 //example: clock(reset); clock(slave); clock(standalone)
mkarlsso 0:8dbd6bd9167f 2497 } else if (tokens[i].find("clock(") != std::string::npos) { //clock commands
mkarlsso 0:8dbd6bd9167f 2498 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2499 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2500 lineError = true;
mkarlsso 0:8dbd6bd9167f 2501 }
mkarlsso 0:8dbd6bd9167f 2502 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 2503 textDisplay << "Error: clock commands only allowed outside of block structure\r\n";
mkarlsso 0:8dbd6bd9167f 2504 lineError = true;
mkarlsso 0:8dbd6bd9167f 2505 }
mkarlsso 5:abee20c0bf2a 2506 int pos1 = tmpLine.find("clock(")+6;
mkarlsso 5:abee20c0bf2a 2507 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 5:abee20c0bf2a 2508 if (pos2 == std::string::npos) {
mkarlsso 5:abee20c0bf2a 2509 textDisplay << "Syntax Error: expected a ')'\r\n";
mkarlsso 5:abee20c0bf2a 2510 lineError = true;
mkarlsso 5:abee20c0bf2a 2511 }
mkarlsso 0:8dbd6bd9167f 2512
mkarlsso 0:8dbd6bd9167f 2513 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2514 //int pos1 = tmpLine.find("clock(")+6;
mkarlsso 5:abee20c0bf2a 2515 //int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 2516 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 0:8dbd6bd9167f 2517
mkarlsso 0:8dbd6bd9167f 2518
mkarlsso 0:8dbd6bd9167f 2519 if (blockDepth == 0) {
mkarlsso 0:8dbd6bd9167f 2520 if (dispVar.compare("reset") == 0) {
mkarlsso 0:8dbd6bd9167f 2521 resetTimer = true;
mkarlsso 0:8dbd6bd9167f 2522 queuePtr->eraseQueue();
mkarlsso 0:8dbd6bd9167f 2523 textDisplay.send(string("Clock reset to 0\r\n"));
mkarlsso 0:8dbd6bd9167f 2524
mkarlsso 0:8dbd6bd9167f 2525 } else if (dispVar.compare("slave") == 0) {
mkarlsso 0:8dbd6bd9167f 2526 if (!clockSlave) {
mkarlsso 0:8dbd6bd9167f 2527 changeToSlave = true;
mkarlsso 0:8dbd6bd9167f 2528 textDisplay.send(string("Slave mode\r\n"));
mkarlsso 0:8dbd6bd9167f 2529
mkarlsso 0:8dbd6bd9167f 2530 }
mkarlsso 0:8dbd6bd9167f 2531 } else if (dispVar.compare("standalone") == 0) {
mkarlsso 0:8dbd6bd9167f 2532 if (clockSlave) {
mkarlsso 0:8dbd6bd9167f 2533 changeToStandAlone = true;
mkarlsso 0:8dbd6bd9167f 2534 textDisplay.send(string("Standalone mode\r\n"));
mkarlsso 0:8dbd6bd9167f 2535
mkarlsso 0:8dbd6bd9167f 2536 }
mkarlsso 0:8dbd6bd9167f 2537 } else if (dispVar.compare("") == 0) {
mkarlsso 0:8dbd6bd9167f 2538 //The user needs the current time displayed.
mkarlsso 0:8dbd6bd9167f 2539
mkarlsso 0:8dbd6bd9167f 2540 //textDisplay.send(string("Current Clock\r\n"));
mkarlsso 0:8dbd6bd9167f 2541 textDisplay << timeKeeper << " current time\r\n";
mkarlsso 0:8dbd6bd9167f 2542 } else {
mkarlsso 0:8dbd6bd9167f 2543 textDisplay << "Error: Clock control statement not understood\r\n";
mkarlsso 0:8dbd6bd9167f 2544 lineError = true;
mkarlsso 0:8dbd6bd9167f 2545 }
mkarlsso 0:8dbd6bd9167f 2546 }
mkarlsso 0:8dbd6bd9167f 2547 }
mkarlsso 0:8dbd6bd9167f 2548
mkarlsso 0:8dbd6bd9167f 2549 //disp command used to display text via serial---------------------------------------
mkarlsso 0:8dbd6bd9167f 2550 //example: disp('hello'); disp(myVar)
mkarlsso 0:8dbd6bd9167f 2551 } else if (tokens[i].find("disp(") != std::string::npos) { //display value of variable
mkarlsso 0:8dbd6bd9167f 2552
mkarlsso 0:8dbd6bd9167f 2553 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2554 textDisplay <<"Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2555 lineError = true;
mkarlsso 0:8dbd6bd9167f 2556 }
mkarlsso 0:8dbd6bd9167f 2557
mkarlsso 0:8dbd6bd9167f 2558 //int pos1 = tokens[i].find("disp(")+5;
mkarlsso 0:8dbd6bd9167f 2559 //int pos2 = tokens[i].find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 2560 //string dispVar = tokens[i].substr(pos1,pos2-pos1);
mkarlsso 0:8dbd6bd9167f 2561
mkarlsso 0:8dbd6bd9167f 2562 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2563 int pos1 = tmpLine.find("disp(")+5;
mkarlsso 0:8dbd6bd9167f 2564 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 2565 if (pos2 == std::string::npos) {
mkarlsso 6:67d67d452545 2566 textDisplay <<"Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2567 lineError = true;
mkarlsso 0:8dbd6bd9167f 2568 }
mkarlsso 3:d7b0a0890d96 2569
mkarlsso 0:8dbd6bd9167f 2570 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2571 string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso 3:d7b0a0890d96 2572
mkarlsso 0:8dbd6bd9167f 2573 int* tmpVar = findIntVariable(dispVar);
mkarlsso 0:8dbd6bd9167f 2574 bool isText = false;
mkarlsso 0:8dbd6bd9167f 2575 if (tmpVar == NULL) {
mkarlsso 0:8dbd6bd9167f 2576 if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso 0:8dbd6bd9167f 2577 isText = true;
mkarlsso 0:8dbd6bd9167f 2578 } else {
mkarlsso 0:8dbd6bd9167f 2579 textDisplay << "Error: variable to display does not exist\r\n";
mkarlsso 0:8dbd6bd9167f 2580 lineError = true;
mkarlsso 0:8dbd6bd9167f 2581 }
mkarlsso 0:8dbd6bd9167f 2582 }
mkarlsso 0:8dbd6bd9167f 2583 displayAction* dPtr = findFirstUnUsed(displayActionBlock, NUMDISPLAYACTIONS);
mkarlsso 0:8dbd6bd9167f 2584 if (dPtr == NULL) {
mkarlsso 0:8dbd6bd9167f 2585 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2586 lineError = true;
mkarlsso 0:8dbd6bd9167f 2587 }
mkarlsso 3:d7b0a0890d96 2588
mkarlsso 0:8dbd6bd9167f 2589 if (!lineError && (blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 2590 //we are not inside a block structure, so display now
mkarlsso 3:d7b0a0890d96 2591
mkarlsso 0:8dbd6bd9167f 2592 if (isText) {
mkarlsso 0:8dbd6bd9167f 2593 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 0:8dbd6bd9167f 2594 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 0:8dbd6bd9167f 2595 dPtr->execute();
mkarlsso 0:8dbd6bd9167f 2596 //delete dPtr;
mkarlsso 0:8dbd6bd9167f 2597 dPtr->release();
mkarlsso 0:8dbd6bd9167f 2598 } else {
mkarlsso 0:8dbd6bd9167f 2599 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 0:8dbd6bd9167f 2600 dPtr->set(tmpVar, dispVar);
mkarlsso 0:8dbd6bd9167f 2601 dPtr->execute();
mkarlsso 0:8dbd6bd9167f 2602 //delete dPtr;
mkarlsso 0:8dbd6bd9167f 2603 dPtr->release();
mkarlsso 0:8dbd6bd9167f 2604 }
mkarlsso 3:d7b0a0890d96 2605
mkarlsso 0:8dbd6bd9167f 2606 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 0:8dbd6bd9167f 2607 //the disp function was put inside a block
mkarlsso 0:8dbd6bd9167f 2608 textDisplay.debug("Display statement\r\n");
mkarlsso 0:8dbd6bd9167f 2609 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2610 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2611 textDisplay <<"Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2612 lineError = true;
mkarlsso 0:8dbd6bd9167f 2613 }
mkarlsso 0:8dbd6bd9167f 2614 if (!lineError && isText) {
mkarlsso 0:8dbd6bd9167f 2615 //displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso 0:8dbd6bd9167f 2616 dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso 0:8dbd6bd9167f 2617 tmpAction->set(dPtr);
mkarlsso 0:8dbd6bd9167f 2618 //action* tmpAction = new action(dPtr);
mkarlsso 0:8dbd6bd9167f 2619 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2620 } else if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2621 //displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso 0:8dbd6bd9167f 2622 dPtr->set(tmpVar, dispVar);
mkarlsso 0:8dbd6bd9167f 2623 tmpAction->set(dPtr);
mkarlsso 0:8dbd6bd9167f 2624 //action* tmpAction = new action(dPtr);
mkarlsso 0:8dbd6bd9167f 2625 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2626 }
mkarlsso 3:d7b0a0890d96 2627
mkarlsso 3:d7b0a0890d96 2628
mkarlsso 0:8dbd6bd9167f 2629 }
mkarlsso 0:8dbd6bd9167f 2630 }
mkarlsso 0:8dbd6bd9167f 2631 //----------------------------------------------
mkarlsso 0:8dbd6bd9167f 2632 //The trigger command is used like this:
mkarlsso 0:8dbd6bd9167f 2633 //trigger(n)
mkarlsso 0:8dbd6bd9167f 2634 //Where n is an integer corresponding to a "function n" block
mkarlsso 0:8dbd6bd9167f 2635 //When "trigger" is called, the corresponding function is executed.
mkarlsso 0:8dbd6bd9167f 2636 } else if (tokens[i].find("trigger(") != std::string::npos) { //trigger a function
mkarlsso 0:8dbd6bd9167f 2637
mkarlsso 0:8dbd6bd9167f 2638 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2639 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2640 lineError = true;
mkarlsso 0:8dbd6bd9167f 2641 }
mkarlsso 0:8dbd6bd9167f 2642
mkarlsso 0:8dbd6bd9167f 2643
mkarlsso 0:8dbd6bd9167f 2644 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2645 int pos1 = tmpLine.find("trigger(")+8;
mkarlsso 0:8dbd6bd9167f 2646 int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 5:abee20c0bf2a 2647 if (pos2 == std::string::npos) {
mkarlsso 5:abee20c0bf2a 2648 textDisplay << "Syntax error: expected a ')'\r\n";
mkarlsso 0:8dbd6bd9167f 2649 lineError = true;
mkarlsso 0:8dbd6bd9167f 2650 }
mkarlsso 0:8dbd6bd9167f 2651
mkarlsso 5:abee20c0bf2a 2652 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2653 int funcNum = atoi(tmpLine.substr(pos1,pos2-pos1).data());
mkarlsso 5:abee20c0bf2a 2654 if ((funcNum > 0) && (funcNum < NUMFUNCTIONS+1)) {
mkarlsso 6:67d67d452545 2655 if (functionSpotTaken[funcNum-1] && functionEventArray[funcNum-1]->isUsed) {
mkarlsso 5:abee20c0bf2a 2656
mkarlsso 5:abee20c0bf2a 2657
mkarlsso 5:abee20c0bf2a 2658 } else {
mkarlsso 5:abee20c0bf2a 2659 textDisplay << "Error: function number does not exist\r\n";
mkarlsso 5:abee20c0bf2a 2660 lineError = true;
mkarlsso 5:abee20c0bf2a 2661 }
mkarlsso 5:abee20c0bf2a 2662 } else {
mkarlsso 5:abee20c0bf2a 2663 textDisplay << "Error: not a valid function number\r\n";
mkarlsso 0:8dbd6bd9167f 2664 lineError = true;
mkarlsso 0:8dbd6bd9167f 2665 }
mkarlsso 0:8dbd6bd9167f 2666
mkarlsso 5:abee20c0bf2a 2667 funcNum--; //change to 0-based index
mkarlsso 5:abee20c0bf2a 2668 if (!lineError && (blockDepth == 0)) {
mkarlsso 5:abee20c0bf2a 2669 //we are not inside a block structure, so execute function now
mkarlsso 5:abee20c0bf2a 2670 //textDisplay << "Exectuting function";
mkarlsso 5:abee20c0bf2a 2671 //textDisplay.flush();
mkarlsso 5:abee20c0bf2a 2672
mkarlsso 5:abee20c0bf2a 2673 functionEventArray[funcNum]->execute();
mkarlsso 5:abee20c0bf2a 2674
mkarlsso 5:abee20c0bf2a 2675 } else if (!lineError && (blockDepth > 0) ){
mkarlsso 5:abee20c0bf2a 2676 //the trigger function was put inside a block, so we need to create a new action
mkarlsso 5:abee20c0bf2a 2677 textDisplay.debug("Trigger statement\r\n");
mkarlsso 5:abee20c0bf2a 2678 triggerFunctionAction* tPtr = findFirstUnUsed(triggerFunctionActionBlock, NUMTRIGGERACTIONS);
mkarlsso 5:abee20c0bf2a 2679 if (tPtr == NULL) {
mkarlsso 0:8dbd6bd9167f 2680 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2681 lineError = true;
mkarlsso 0:8dbd6bd9167f 2682 }
mkarlsso 5:abee20c0bf2a 2683
mkarlsso 0:8dbd6bd9167f 2684 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2685 //we only give provide it the function number, instead
mkarlsso 5:abee20c0bf2a 2686 //of a pointer to the event. That way, if the user modifies
mkarlsso 5:abee20c0bf2a 2687 //the function (which would change the pointer), all callbacks
mkarlsso 5:abee20c0bf2a 2688 //still using that function number will use the new function.
mkarlsso 5:abee20c0bf2a 2689 tPtr->set(funcNum);
mkarlsso 5:abee20c0bf2a 2690 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 5:abee20c0bf2a 2691 if (tmpAction == NULL) {
mkarlsso 5:abee20c0bf2a 2692 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 5:abee20c0bf2a 2693 lineError = true;
mkarlsso 5:abee20c0bf2a 2694 }
mkarlsso 5:abee20c0bf2a 2695 if (!lineError) {
mkarlsso 5:abee20c0bf2a 2696
mkarlsso 5:abee20c0bf2a 2697 tmpAction->set(tPtr);
mkarlsso 5:abee20c0bf2a 2698 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 5:abee20c0bf2a 2699 }
mkarlsso 0:8dbd6bd9167f 2700 }
mkarlsso 5:abee20c0bf2a 2701
mkarlsso 5:abee20c0bf2a 2702
mkarlsso 0:8dbd6bd9167f 2703 }
mkarlsso 0:8dbd6bd9167f 2704
mkarlsso 0:8dbd6bd9167f 2705 }
mkarlsso 0:8dbd6bd9167f 2706
mkarlsso 0:8dbd6bd9167f 2707
mkarlsso 0:8dbd6bd9167f 2708 //int is used to decalar new variables. Only allowed outside of callbacks-------------------
mkarlsso 0:8dbd6bd9167f 2709 //example: int a; int b = 9
alustig3 4:b019c133a8fb 2710 }else if(tokens[i].compare("kaboom") == 0){//send "kaboom;" to reset mbed
alustig3 4:b019c133a8fb 2711 mbed_reset();
alustig3 4:b019c133a8fb 2712 }else if (tokens[i].compare("int") == 0) { //define a new integer variable
mkarlsso 0:8dbd6bd9167f 2713 textDisplay.debug("Int statement\r\n");
mkarlsso 0:8dbd6bd9167f 2714 if (ifBlockInit || whileBlockInit || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2715 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2716 lineError = true;
mkarlsso 0:8dbd6bd9167f 2717 }
mkarlsso 0:8dbd6bd9167f 2718 tmpString = "";
mkarlsso 0:8dbd6bd9167f 2719 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2720 int spacesBeforeEqualSign = 0;
mkarlsso 0:8dbd6bd9167f 2721 bool countSpaces = true;
mkarlsso 0:8dbd6bd9167f 2722 //combine the tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 2723 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 2724 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 2725 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 2726 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 2727 countSpaces = false;
mkarlsso 0:8dbd6bd9167f 2728 } else if (countSpaces) {
mkarlsso 0:8dbd6bd9167f 2729 spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 2730 }
mkarlsso 0:8dbd6bd9167f 2731 }
mkarlsso 0:8dbd6bd9167f 2732
mkarlsso 0:8dbd6bd9167f 2733 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 2734 textDisplay << "Error: Variables can only be first declared outside of callbacks.\r\n";
mkarlsso 0:8dbd6bd9167f 2735 lineError = true;
mkarlsso 0:8dbd6bd9167f 2736 }
mkarlsso 0:8dbd6bd9167f 2737
mkarlsso 0:8dbd6bd9167f 2738 if ((!lineError) && (spacesBeforeEqualSign > 1)) {
mkarlsso 0:8dbd6bd9167f 2739 textDisplay << "Error: Variable can't have a space in it.\r\n";
mkarlsso 0:8dbd6bd9167f 2740 lineError = true;
mkarlsso 0:8dbd6bd9167f 2741 }
mkarlsso 0:8dbd6bd9167f 2742 stringInd = tmpString.find_first_of("=");
mkarlsso 0:8dbd6bd9167f 2743
mkarlsso 0:8dbd6bd9167f 2744 bool variableCreated = false;
mkarlsso 0:8dbd6bd9167f 2745 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2746 if (((stringInd == std::string::npos) && (sz == 2)) || (stringInd != std::string::npos)) {
mkarlsso 0:8dbd6bd9167f 2747
mkarlsso 0:8dbd6bd9167f 2748 if ((stringInd != std::string::npos) && (stringInd > MAXVARNAMESIZE)) {
mkarlsso 0:8dbd6bd9167f 2749 textDisplay << "Error: variable names must be under 30 characters.\r\n";
mkarlsso 0:8dbd6bd9167f 2750 lineError = true;
mkarlsso 0:8dbd6bd9167f 2751 } else if (createIntVariable(tmpString.substr(0,stringInd))) {
mkarlsso 0:8dbd6bd9167f 2752 textDisplay.debug("Created new variable\r\n");
mkarlsso 0:8dbd6bd9167f 2753 variableCreated = true;
mkarlsso 0:8dbd6bd9167f 2754 } else {
mkarlsso 0:8dbd6bd9167f 2755 textDisplay.debug("Attempting to use existing variable\r\n");
mkarlsso 0:8dbd6bd9167f 2756 int* tmpVar = findIntVariable(tmpString.substr(0,stringInd));
mkarlsso 0:8dbd6bd9167f 2757 *tmpVar = 0;
mkarlsso 0:8dbd6bd9167f 2758 //lineError = true;
mkarlsso 0:8dbd6bd9167f 2759 }
mkarlsso 0:8dbd6bd9167f 2760 } else {
mkarlsso 0:8dbd6bd9167f 2761 textDisplay << "Error: variable declaration not understood.\r\n";
mkarlsso 0:8dbd6bd9167f 2762 lineError = true;
mkarlsso 0:8dbd6bd9167f 2763 }
mkarlsso 0:8dbd6bd9167f 2764 }
mkarlsso 0:8dbd6bd9167f 2765 if ((!lineError) && (stringInd != std::string::npos)) { //evaluate the expression
mkarlsso 0:8dbd6bd9167f 2766 //action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 0:8dbd6bd9167f 2767 action* tmpAction = evaluateAssignmentForAction(tmpString.data());
mkarlsso 0:8dbd6bd9167f 2768 if (tmpAction != NULL) {
mkarlsso 0:8dbd6bd9167f 2769 tmpAction->execute();
mkarlsso 0:8dbd6bd9167f 2770 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 2771 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 2772 } else {
mkarlsso 0:8dbd6bd9167f 2773 lineError = true;
mkarlsso 0:8dbd6bd9167f 2774 if (variableCreated) {
mkarlsso 0:8dbd6bd9167f 2775 delete globalVariables.back();
mkarlsso 0:8dbd6bd9167f 2776 globalVariables.pop_back();
mkarlsso 0:8dbd6bd9167f 2777 }
mkarlsso 0:8dbd6bd9167f 2778 }
mkarlsso 0:8dbd6bd9167f 2779 }
mkarlsso 0:8dbd6bd9167f 2780
mkarlsso 0:8dbd6bd9167f 2781 //serial command is used to toggle whether or not to buffer up output text----------------
mkarlsso 0:8dbd6bd9167f 2782 //examples: serial buffer; serial send
mkarlsso 0:8dbd6bd9167f 2783 } else if (tokens[i].compare("serial") == 0) {
mkarlsso 0:8dbd6bd9167f 2784 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2785 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2786 lineError = true;
mkarlsso 0:8dbd6bd9167f 2787 }
mkarlsso 0:8dbd6bd9167f 2788 bool stream = true;
mkarlsso 0:8dbd6bd9167f 2789 if ((!lineError)&&(i+1 < sz)){
mkarlsso 0:8dbd6bd9167f 2790 if (tokens[i+1].compare("buffer") == 0) {
mkarlsso 0:8dbd6bd9167f 2791 stream = false;
mkarlsso 0:8dbd6bd9167f 2792 } else if (tokens[i+1].compare("send") == 0) {
mkarlsso 0:8dbd6bd9167f 2793 stream = true;
mkarlsso 0:8dbd6bd9167f 2794 } else {
mkarlsso 0:8dbd6bd9167f 2795 textDisplay << "Error: 'serial' useage: 'serial buffer' or 'serial send'\r\n";
mkarlsso 0:8dbd6bd9167f 2796 lineError = true;
mkarlsso 0:8dbd6bd9167f 2797 }
mkarlsso 0:8dbd6bd9167f 2798 }
mkarlsso 0:8dbd6bd9167f 2799 i++;
mkarlsso 0:8dbd6bd9167f 2800 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 2801 if (stream) {
mkarlsso 0:8dbd6bd9167f 2802 textStreaming = true;
mkarlsso 0:8dbd6bd9167f 2803 } else {
mkarlsso 0:8dbd6bd9167f 2804 textStreaming = false;
mkarlsso 0:8dbd6bd9167f 2805 }
mkarlsso 0:8dbd6bd9167f 2806 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 2807 if (stream) {
mkarlsso 0:8dbd6bd9167f 2808 //action* tmpAction = new action(1); //code 1 = turn on text streaming
mkarlsso 0:8dbd6bd9167f 2809 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2810 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2811 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2812 lineError = true;
mkarlsso 0:8dbd6bd9167f 2813 } else {
mkarlsso 0:8dbd6bd9167f 2814 tmpAction->set(1);
mkarlsso 0:8dbd6bd9167f 2815 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2816 }
mkarlsso 0:8dbd6bd9167f 2817
mkarlsso 0:8dbd6bd9167f 2818 } else {
mkarlsso 0:8dbd6bd9167f 2819 //action* tmpAction = new action(2); //code 2 = turn on text buffering
mkarlsso 0:8dbd6bd9167f 2820 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2821 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2822 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2823 lineError = true;
mkarlsso 0:8dbd6bd9167f 2824 } else {
mkarlsso 0:8dbd6bd9167f 2825 tmpAction->set(2);
mkarlsso 0:8dbd6bd9167f 2826 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2827 }
mkarlsso 0:8dbd6bd9167f 2828 }
mkarlsso 0:8dbd6bd9167f 2829 }
mkarlsso 0:8dbd6bd9167f 2830
mkarlsso 0:8dbd6bd9167f 2831 //updates command toggles the DIO update messages upon a change------------------
mkarlsso 0:8dbd6bd9167f 2832 //examples: updates on; updates off
mkarlsso 6:67d67d452545 2833 //examples: updates on 3; updates off 3
mkarlsso 0:8dbd6bd9167f 2834 } else if (tokens[i].compare("updates") == 0) {
mkarlsso 0:8dbd6bd9167f 2835 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2836 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2837 lineError = true;
mkarlsso 0:8dbd6bd9167f 2838 }
mkarlsso 0:8dbd6bd9167f 2839 bool stream = true;
mkarlsso 3:d7b0a0890d96 2840 int specifiedPort = -1;
mkarlsso 0:8dbd6bd9167f 2841 if ((!lineError)&&(i+1 < sz)){
mkarlsso 0:8dbd6bd9167f 2842 if (tokens[i+1].compare("on") == 0) {
mkarlsso 0:8dbd6bd9167f 2843 stream = true;
mkarlsso 0:8dbd6bd9167f 2844 } else if (tokens[i+1].compare("off") == 0) {
mkarlsso 0:8dbd6bd9167f 2845 stream = false;
mkarlsso 0:8dbd6bd9167f 2846 } else {
mkarlsso 0:8dbd6bd9167f 2847 textDisplay << "Error: 'updates' useage: 'updates on' or 'updates off'\r\n";
mkarlsso 0:8dbd6bd9167f 2848 lineError = true;
mkarlsso 0:8dbd6bd9167f 2849 }
mkarlsso 0:8dbd6bd9167f 2850 }
mkarlsso 3:d7b0a0890d96 2851 if ((!lineError) && (i+2 < sz)) {
mkarlsso 3:d7b0a0890d96 2852 //There is a port specified
mkarlsso 3:d7b0a0890d96 2853 //int pos1 = tmpLine.find("trigger(")+8;
mkarlsso 3:d7b0a0890d96 2854 //int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso 3:d7b0a0890d96 2855 int tempPort = atoi(tokens[i+2].data());
mkarlsso 3:d7b0a0890d96 2856 if (tempPort > 0) {
mkarlsso 3:d7b0a0890d96 2857 specifiedPort = tempPort-1;
mkarlsso 3:d7b0a0890d96 2858 } else {
mkarlsso 3:d7b0a0890d96 2859 textDisplay << "Error: 'updates' useage: 'updates on [port]' or 'updates off [port]'\r\n";
mkarlsso 3:d7b0a0890d96 2860 lineError = true;
mkarlsso 3:d7b0a0890d96 2861 }
mkarlsso 3:d7b0a0890d96 2862 i++;
mkarlsso 3:d7b0a0890d96 2863 }
mkarlsso 0:8dbd6bd9167f 2864 i++;
mkarlsso 0:8dbd6bd9167f 2865 if ((!lineError) && (blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 2866 if (stream) {
mkarlsso 3:d7b0a0890d96 2867 //applies to all;
mkarlsso 0:8dbd6bd9167f 2868 broadCastStateChanges = true;
mkarlsso 3:d7b0a0890d96 2869 if (specifiedPort > -1) {
mkarlsso 3:d7b0a0890d96 2870 system->setPortUpdatesOn(specifiedPort);
mkarlsso 3:d7b0a0890d96 2871 } else {
mkarlsso 3:d7b0a0890d96 2872 for (int i=0;i<NUMPORTS;i++) {
mkarlsso 3:d7b0a0890d96 2873 system->setPortUpdatesOn(i);
mkarlsso 3:d7b0a0890d96 2874 }
mkarlsso 3:d7b0a0890d96 2875 }
mkarlsso 0:8dbd6bd9167f 2876 } else {
mkarlsso 3:d7b0a0890d96 2877 if (specifiedPort > -1) {
mkarlsso 3:d7b0a0890d96 2878 system->setPortUpdatesOff(specifiedPort);
mkarlsso 3:d7b0a0890d96 2879 } else {
mkarlsso 3:d7b0a0890d96 2880 //applies to all
mkarlsso 3:d7b0a0890d96 2881 //broadCastStateChanges = false;
mkarlsso 3:d7b0a0890d96 2882 for (int i=0;i<NUMPORTS;i++) {
mkarlsso 3:d7b0a0890d96 2883 system->setPortUpdatesOff(i);
mkarlsso 3:d7b0a0890d96 2884 }
mkarlsso 3:d7b0a0890d96 2885 }
mkarlsso 3:d7b0a0890d96 2886
mkarlsso 0:8dbd6bd9167f 2887 }
mkarlsso 0:8dbd6bd9167f 2888 } else if ((!lineError) && (blockDepth > 0)) {
mkarlsso 3:d7b0a0890d96 2889 //Inside a block-- current no support here to specify a port
mkarlsso 3:d7b0a0890d96 2890
mkarlsso 0:8dbd6bd9167f 2891 if (stream) {
mkarlsso 0:8dbd6bd9167f 2892 //action* tmpAction = new action(3); //code 3 = turn on 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(3);
mkarlsso 0:8dbd6bd9167f 2899 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2900 }
mkarlsso 0:8dbd6bd9167f 2901 } else {
mkarlsso 0:8dbd6bd9167f 2902 //action* tmpAction = new action(4); //code 4 = turn off updates
mkarlsso 0:8dbd6bd9167f 2903 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2904 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2905 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2906 lineError = true;
mkarlsso 0:8dbd6bd9167f 2907 } else {
mkarlsso 0:8dbd6bd9167f 2908 tmpAction->set(4);
mkarlsso 0:8dbd6bd9167f 2909 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2910 }
mkarlsso 0:8dbd6bd9167f 2911
mkarlsso 0:8dbd6bd9167f 2912 }
mkarlsso 0:8dbd6bd9167f 2913 }
mkarlsso 0:8dbd6bd9167f 2914
mkarlsso 0:8dbd6bd9167f 2915 } else if (tokens[i].compare("memory") == 0) {
mkarlsso 0:8dbd6bd9167f 2916 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2917 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2918 lineError = true;
mkarlsso 0:8dbd6bd9167f 2919 }
mkarlsso 0:8dbd6bd9167f 2920 if ((!lineError) && (blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 2921 textDisplay << "Error: memory statement is not allowed inside a block.\r\n";
mkarlsso 0:8dbd6bd9167f 2922 lineError = true;
mkarlsso 0:8dbd6bd9167f 2923 }
mkarlsso 0:8dbd6bd9167f 2924 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2925 displayMemoryLeft();
mkarlsso 0:8dbd6bd9167f 2926 }
mkarlsso 0:8dbd6bd9167f 2927
mkarlsso 0:8dbd6bd9167f 2928
mkarlsso 0:8dbd6bd9167f 2929 //clear is used to clear things from memory---------------------------------
mkarlsso 0:8dbd6bd9167f 2930 //examples: clear all; clear callbacks; clear queue
mkarlsso 0:8dbd6bd9167f 2931
mkarlsso 0:8dbd6bd9167f 2932 } else if (tokens[i].compare("clear") == 0) { //delete all created events and variables
mkarlsso 0:8dbd6bd9167f 2933 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 2934 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 2935 lineError = true;
mkarlsso 0:8dbd6bd9167f 2936 }
mkarlsso 0:8dbd6bd9167f 2937 int clearMode = 0;
mkarlsso 0:8dbd6bd9167f 2938 if ((!lineError)&&(i+1 < sz)){
mkarlsso 0:8dbd6bd9167f 2939 if (tokens[i+1].compare("all") == 0) {
mkarlsso 0:8dbd6bd9167f 2940 clearMode = 1;
mkarlsso 0:8dbd6bd9167f 2941 } else if (tokens[i+1].compare("blocks") == 0) {
mkarlsso 0:8dbd6bd9167f 2942 clearMode = 2;
mkarlsso 0:8dbd6bd9167f 2943 } else if (tokens[i+1].compare("queue") == 0) {
mkarlsso 0:8dbd6bd9167f 2944 clearMode = 3;
mkarlsso 0:8dbd6bd9167f 2945 } else {
mkarlsso 0:8dbd6bd9167f 2946 textDisplay << "Error: clear what: all, blocks, or queue? \r\n";
mkarlsso 0:8dbd6bd9167f 2947 lineError = true;
mkarlsso 0:8dbd6bd9167f 2948 }
mkarlsso 0:8dbd6bd9167f 2949 } else {
mkarlsso 0:8dbd6bd9167f 2950 textDisplay << "Error: clear what: all, blocks, or queue? \r\n";
mkarlsso 0:8dbd6bd9167f 2951 lineError = true;
mkarlsso 0:8dbd6bd9167f 2952 }
mkarlsso 0:8dbd6bd9167f 2953
mkarlsso 0:8dbd6bd9167f 2954
mkarlsso 0:8dbd6bd9167f 2955 if ((!lineError) && (clearMode < 3) && (blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 2956 textDisplay << "Error: 'clear all' and 'clear blocks' only allowed outside of block structures\r\n";
mkarlsso 0:8dbd6bd9167f 2957 lineError = true;
mkarlsso 0:8dbd6bd9167f 2958 }
mkarlsso 0:8dbd6bd9167f 2959 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 2960 //i++;
mkarlsso 0:8dbd6bd9167f 2961 //clear variables
mkarlsso 5:abee20c0bf2a 2962
mkarlsso 0:8dbd6bd9167f 2963 if (clearMode == 1) {
mkarlsso 5:abee20c0bf2a 2964 //Clears everything
mkarlsso 5:abee20c0bf2a 2965 int sendClearMode = 0;
mkarlsso 5:abee20c0bf2a 2966 sendClearMode |= BLOCKMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2967 sendClearMode |= VARIABLEMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2968 sendClearMode |= ENVSETTINGSMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2969
mkarlsso 5:abee20c0bf2a 2970 clearEnvironmentVariables(sendClearMode);
mkarlsso 5:abee20c0bf2a 2971
mkarlsso 5:abee20c0bf2a 2972 } else if (clearMode == 2) {
mkarlsso 5:abee20c0bf2a 2973 //Clear just varaibles
mkarlsso 5:abee20c0bf2a 2974 int sendClearMode = 0;
mkarlsso 5:abee20c0bf2a 2975 sendClearMode |= VARIABLEMEMORYTYPES;
mkarlsso 5:abee20c0bf2a 2976 clearEnvironmentVariables(sendClearMode);
mkarlsso 5:abee20c0bf2a 2977
mkarlsso 5:abee20c0bf2a 2978 } else if (clearMode == 3) {
mkarlsso 5:abee20c0bf2a 2979 //Clear the current event queue (can itself be a queued action)
mkarlsso 0:8dbd6bd9167f 2980 if (blockDepth > 0) { //we are inside a block
mkarlsso 0:8dbd6bd9167f 2981 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 2982 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 2983 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 2984 lineError = true;
mkarlsso 0:8dbd6bd9167f 2985 } else {
mkarlsso 0:8dbd6bd9167f 2986
mkarlsso 0:8dbd6bd9167f 2987 int8_t code = 0;
mkarlsso 0:8dbd6bd9167f 2988 tmpAction->set(code);
mkarlsso 0:8dbd6bd9167f 2989 //action* tmpAction = new action(code); //code 0 = clear queue
mkarlsso 0:8dbd6bd9167f 2990 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 2991 }
mkarlsso 0:8dbd6bd9167f 2992 } else {
mkarlsso 0:8dbd6bd9167f 2993 //clear queue now
mkarlsso 0:8dbd6bd9167f 2994 queuePtr->eraseQueue();
mkarlsso 0:8dbd6bd9167f 2995 }
mkarlsso 0:8dbd6bd9167f 2996 }
mkarlsso 0:8dbd6bd9167f 2997 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 2998
mkarlsso 0:8dbd6bd9167f 2999
mkarlsso 0:8dbd6bd9167f 3000 }
mkarlsso 0:8dbd6bd9167f 3001
mkarlsso 0:8dbd6bd9167f 3002 //do starts a block---------------------------------------------------------
mkarlsso 0:8dbd6bd9167f 3003 //example: do in 500
mkarlsso 0:8dbd6bd9167f 3004 // ...
mkarlsso 0:8dbd6bd9167f 3005 // end
mkarlsso 0:8dbd6bd9167f 3006
mkarlsso 0:8dbd6bd9167f 3007 } else if (tokens[i].compare("do") == 0) { //the start of a block
mkarlsso 0:8dbd6bd9167f 3008
mkarlsso 0:8dbd6bd9167f 3009 if (!ifBlockInit && !whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3010
mkarlsso 0:8dbd6bd9167f 3011 if ((currentTriggerPort > 0) || (currentFunction > -1)) { //check to make sure we are inside a trigger block
mkarlsso 0:8dbd6bd9167f 3012
mkarlsso 0:8dbd6bd9167f 3013
mkarlsso 0:8dbd6bd9167f 3014 } else {
mkarlsso 0:8dbd6bd9167f 3015 textDisplay << "Error: a statement block must be placed inside a callback or function.\r\n";
mkarlsso 0:8dbd6bd9167f 3016 lineError = true;
mkarlsso 0:8dbd6bd9167f 3017 }
mkarlsso 0:8dbd6bd9167f 3018
mkarlsso 0:8dbd6bd9167f 3019 }
mkarlsso 0:8dbd6bd9167f 3020 expectingDoStatement = false;
mkarlsso 0:8dbd6bd9167f 3021 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3022 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3023 bool eventReserved = false;
mkarlsso 0:8dbd6bd9167f 3024 if ((tmpEvent == NULL)||(tmpAction == NULL)) {
mkarlsso 0:8dbd6bd9167f 3025 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3026 lineError = true;
mkarlsso 0:8dbd6bd9167f 3027
mkarlsso 0:8dbd6bd9167f 3028 } else {
mkarlsso 0:8dbd6bd9167f 3029
mkarlsso 0:8dbd6bd9167f 3030
mkarlsso 0:8dbd6bd9167f 3031 }
mkarlsso 0:8dbd6bd9167f 3032
mkarlsso 0:8dbd6bd9167f 3033 if (i+2 < sz) { //a time delay in the block
mkarlsso 0:8dbd6bd9167f 3034
mkarlsso 0:8dbd6bd9167f 3035 if ((!lineError) && (tokens[i+1].compare("in") == 0) && (isNumber(tokens[i+2]))) {
mkarlsso 0:8dbd6bd9167f 3036 textDisplay.debug("Do in number statement\r\n");
mkarlsso 0:8dbd6bd9167f 3037 currentDelay = atoi(tokens[i+2].data());
mkarlsso 0:8dbd6bd9167f 3038 if (currentDelay < 0) {
mkarlsso 0:8dbd6bd9167f 3039 textDisplay <<"Error: block delay time must be a positive integer\r\n";
mkarlsso 0:8dbd6bd9167f 3040 lineError = true;
mkarlsso 0:8dbd6bd9167f 3041 } else if (!ifBlockInit) { //a standalone do block
mkarlsso 0:8dbd6bd9167f 3042 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3043 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3044 eventReserved = true;
mkarlsso 0:8dbd6bd9167f 3045 tmpEvent->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3046
mkarlsso 0:8dbd6bd9167f 3047 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 0:8dbd6bd9167f 3048 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3049 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3050 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3051 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3052 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 0:8dbd6bd9167f 3053 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3054 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3055 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3056 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3057 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 0:8dbd6bd9167f 3058 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3059
mkarlsso 0:8dbd6bd9167f 3060 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3061 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3062 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 0:8dbd6bd9167f 3063 }
mkarlsso 0:8dbd6bd9167f 3064
mkarlsso 0:8dbd6bd9167f 3065 } else { //an if block
mkarlsso 0:8dbd6bd9167f 3066 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3067
mkarlsso 0:8dbd6bd9167f 3068 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3069 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 0:8dbd6bd9167f 3070 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3071 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3072 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 0:8dbd6bd9167f 3073 }
mkarlsso 0:8dbd6bd9167f 3074 } else if (elseFlag){
mkarlsso 0:8dbd6bd9167f 3075 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3076 } else if (thenFlag){
mkarlsso 0:8dbd6bd9167f 3077 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3078
mkarlsso 0:8dbd6bd9167f 3079 }
mkarlsso 0:8dbd6bd9167f 3080
mkarlsso 0:8dbd6bd9167f 3081
mkarlsso 0:8dbd6bd9167f 3082 }
mkarlsso 0:8dbd6bd9167f 3083
mkarlsso 0:8dbd6bd9167f 3084 } else if ((!lineError) && (tokens[i+1].compare("in") == 0) && (findIntVariable(tokens[i+2])!=NULL)) {
mkarlsso 0:8dbd6bd9167f 3085 textDisplay.debug("Do in VAR statement\r\n");
mkarlsso 0:8dbd6bd9167f 3086 int* delayVar = findIntVariable(tokens[i+2]);
mkarlsso 0:8dbd6bd9167f 3087 //currentDelay = atoi(tokens[i+2].data());
mkarlsso 0:8dbd6bd9167f 3088 if (!ifBlockInit) { //a standalone do block
mkarlsso 0:8dbd6bd9167f 3089 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3090 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3091 eventReserved = true;
mkarlsso 0:8dbd6bd9167f 3092 tmpEvent->setTimeLag(delayVar);
mkarlsso 0:8dbd6bd9167f 3093
mkarlsso 0:8dbd6bd9167f 3094 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 0:8dbd6bd9167f 3095 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3096 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3097 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3098 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3099 tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso 0:8dbd6bd9167f 3100 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3101 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3102 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3103 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3104 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 0:8dbd6bd9167f 3105 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3106
mkarlsso 0:8dbd6bd9167f 3107 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3108 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3109 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 0:8dbd6bd9167f 3110 }
mkarlsso 0:8dbd6bd9167f 3111
mkarlsso 0:8dbd6bd9167f 3112 } else { //an if block
mkarlsso 0:8dbd6bd9167f 3113 tmpEventPtrArray.back()->setTimeLag(delayVar);
mkarlsso 0:8dbd6bd9167f 3114
mkarlsso 0:8dbd6bd9167f 3115 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3116 if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso 0:8dbd6bd9167f 3117 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3118 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3119 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 0:8dbd6bd9167f 3120 }
mkarlsso 0:8dbd6bd9167f 3121 } else if (elseFlag){
mkarlsso 0:8dbd6bd9167f 3122 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3123 } else if (thenFlag){
mkarlsso 0:8dbd6bd9167f 3124 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3125
mkarlsso 0:8dbd6bd9167f 3126 }
mkarlsso 0:8dbd6bd9167f 3127
mkarlsso 0:8dbd6bd9167f 3128
mkarlsso 0:8dbd6bd9167f 3129 }
mkarlsso 0:8dbd6bd9167f 3130
mkarlsso 0:8dbd6bd9167f 3131 } else {
mkarlsso 0:8dbd6bd9167f 3132 textDisplay << "Error: block delay time must be a positive integer or a variable\r\n";
mkarlsso 0:8dbd6bd9167f 3133 lineError = true;
mkarlsso 0:8dbd6bd9167f 3134 }
mkarlsso 0:8dbd6bd9167f 3135 } else if (!lineError && !ifBlockInit) { //no time delay given, standalone do
mkarlsso 0:8dbd6bd9167f 3136 textDisplay.debug("Do statement\r\n");
mkarlsso 0:8dbd6bd9167f 3137 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3138 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3139 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3140 eventReserved = true;
mkarlsso 0:8dbd6bd9167f 3141 tmpEvent->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3142 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3143 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3144 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3145 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3146 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3147 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3148 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3149 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3150 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3151 tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso 0:8dbd6bd9167f 3152 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3153 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3154 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3155 tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso 0:8dbd6bd9167f 3156 }
mkarlsso 0:8dbd6bd9167f 3157
mkarlsso 0:8dbd6bd9167f 3158 } else if (!lineError) { //no time delay, if block
mkarlsso 0:8dbd6bd9167f 3159
mkarlsso 0:8dbd6bd9167f 3160 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3161 tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3162
mkarlsso 0:8dbd6bd9167f 3163
mkarlsso 0:8dbd6bd9167f 3164 if (!elseFlag && !thenFlag) {
mkarlsso 0:8dbd6bd9167f 3165 if (blockDepth > 1) {
mkarlsso 0:8dbd6bd9167f 3166 tmpAction->set(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3167 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3168 //tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso 0:8dbd6bd9167f 3169 }
mkarlsso 0:8dbd6bd9167f 3170 } else {
mkarlsso 0:8dbd6bd9167f 3171 tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3172 }
mkarlsso 0:8dbd6bd9167f 3173
mkarlsso 0:8dbd6bd9167f 3174 }
mkarlsso 0:8dbd6bd9167f 3175 if (lineError && eventReserved) {
mkarlsso 0:8dbd6bd9167f 3176 tmpEvent->release();
mkarlsso 0:8dbd6bd9167f 3177 }
mkarlsso 0:8dbd6bd9167f 3178 //close block initiation
mkarlsso 0:8dbd6bd9167f 3179 ifBlockInit = false;
mkarlsso 0:8dbd6bd9167f 3180 whileBlockInit = false;
mkarlsso 0:8dbd6bd9167f 3181 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3182 elseFlag = false;
mkarlsso 0:8dbd6bd9167f 3183 thenFlag = false;
mkarlsso 0:8dbd6bd9167f 3184
mkarlsso 0:8dbd6bd9167f 3185 //currently, there are two types of root-level blocks: functions and callbacks
mkarlsso 0:8dbd6bd9167f 3186 //
mkarlsso 0:8dbd6bd9167f 3187 //A function can be triggered with a command, a callback is tied to a hardware event
mkarlsso 0:8dbd6bd9167f 3188 } else if (tokens[i].compare("function") == 0) { //a new function block
mkarlsso 0:8dbd6bd9167f 3189 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3190 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3191 lineError = true;
mkarlsso 0:8dbd6bd9167f 3192 }
mkarlsso 0:8dbd6bd9167f 3193 if (blockDepth != 0) {
mkarlsso 0:8dbd6bd9167f 3194 textDisplay <<"Error: Can't declare a function block within another block\r\n";
mkarlsso 0:8dbd6bd9167f 3195 lineError = true;
mkarlsso 0:8dbd6bd9167f 3196 }
mkarlsso 0:8dbd6bd9167f 3197 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3198 textDisplay.debug("Function statement\r\n");
mkarlsso 0:8dbd6bd9167f 3199 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3200 if (i+1 < sz) {
mkarlsso 0:8dbd6bd9167f 3201 int tempFuncNum = atoi(tokens[i+1].data());
mkarlsso 0:8dbd6bd9167f 3202 if ((tempFuncNum > 0) && (tempFuncNum < NUMFUNCTIONS+1)) {
mkarlsso 0:8dbd6bd9167f 3203 currentFunction = tempFuncNum-1;
mkarlsso 0:8dbd6bd9167f 3204 } else {
mkarlsso 0:8dbd6bd9167f 3205 textDisplay << "Error: not a valid function number\r\n";
mkarlsso 0:8dbd6bd9167f 3206 lineError = true;
mkarlsso 0:8dbd6bd9167f 3207 }
mkarlsso 0:8dbd6bd9167f 3208 } else {
mkarlsso 0:8dbd6bd9167f 3209 if (!lineError) textDisplay << "Error: Not enough arguments for function statement\r\n";
mkarlsso 0:8dbd6bd9167f 3210 lineError = true;
mkarlsso 0:8dbd6bd9167f 3211 }
mkarlsso 0:8dbd6bd9167f 3212 if (sz > 2) {
mkarlsso 0:8dbd6bd9167f 3213 if (!((sz == 3) && (tokens[i+2].compare("do") == 0))) {
mkarlsso 0:8dbd6bd9167f 3214 textDisplay << "Error: Too many arguments in function statement\r\n";
mkarlsso 0:8dbd6bd9167f 3215 lineError = true;
mkarlsso 0:8dbd6bd9167f 3216 }
mkarlsso 0:8dbd6bd9167f 3217 }
mkarlsso 0:8dbd6bd9167f 3218
mkarlsso 0:8dbd6bd9167f 3219 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3220 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3221 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3222
mkarlsso 0:8dbd6bd9167f 3223 } else {
mkarlsso 0:8dbd6bd9167f 3224 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3225 lineError = true;
mkarlsso 0:8dbd6bd9167f 3226 }
mkarlsso 0:8dbd6bd9167f 3227 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3228
mkarlsso 0:8dbd6bd9167f 3229 blockDepth = 1;
mkarlsso 0:8dbd6bd9167f 3230 i = i+2;
mkarlsso 0:8dbd6bd9167f 3231 //create new event and attach it to the port
mkarlsso 0:8dbd6bd9167f 3232 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 0:8dbd6bd9167f 3233 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3234
mkarlsso 0:8dbd6bd9167f 3235 if (functionSpotTaken[currentFunction]) {
mkarlsso 0:8dbd6bd9167f 3236 functionEventArray[currentFunction]->release();
mkarlsso 0:8dbd6bd9167f 3237 }
mkarlsso 0:8dbd6bd9167f 3238 functionEventArray[currentFunction] = tmpEvent;
mkarlsso 0:8dbd6bd9167f 3239 functionSpotTaken[currentFunction] = true;
mkarlsso 0:8dbd6bd9167f 3240
mkarlsso 0:8dbd6bd9167f 3241 }
mkarlsso 0:8dbd6bd9167f 3242 }
mkarlsso 0:8dbd6bd9167f 3243
mkarlsso 0:8dbd6bd9167f 3244
mkarlsso 0:8dbd6bd9167f 3245 //callback starts a callback block------------------------------------------
mkarlsso 0:8dbd6bd9167f 3246 //exmaple: callback portin(1) down
mkarlsso 0:8dbd6bd9167f 3247 // ...
mkarlsso 0:8dbd6bd9167f 3248 // end
mkarlsso 0:8dbd6bd9167f 3249 } else if (tokens[i].compare("callback") == 0) { //a new callback block
mkarlsso 0:8dbd6bd9167f 3250 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3251 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3252 lineError = true;
mkarlsso 0:8dbd6bd9167f 3253 }
mkarlsso 0:8dbd6bd9167f 3254 if (blockDepth != 0) {
mkarlsso 0:8dbd6bd9167f 3255 textDisplay << "Error: Can't declare a callback block within another block\r\n";
mkarlsso 0:8dbd6bd9167f 3256 lineError = true;
mkarlsso 0:8dbd6bd9167f 3257 }
mkarlsso 0:8dbd6bd9167f 3258 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3259 textDisplay.debug("Callback statement\r\n");
mkarlsso 0:8dbd6bd9167f 3260 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3261 if (i+2 < sz) {
mkarlsso 0:8dbd6bd9167f 3262 if ((tokens[i+1].find("portin[") != std::string::npos) && (tokens[i+1].size() > 8) ) { //callback for a digital port
mkarlsso 0:8dbd6bd9167f 3263 int pos1 = tokens[i+1].find("portin[")+7;
mkarlsso 0:8dbd6bd9167f 3264 int pos2 = tokens[i+1].find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 3265 currentTriggerPort = atoi(tokens[i+1].substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3266
mkarlsso 0:8dbd6bd9167f 3267 if (currentTriggerPort <= 0) {
mkarlsso 0:8dbd6bd9167f 3268 currentTriggerPort = -1;
mkarlsso 0:8dbd6bd9167f 3269 textDisplay << "Error: Not a valid port number\r\n";
mkarlsso 0:8dbd6bd9167f 3270 lineError = true;
mkarlsso 0:8dbd6bd9167f 3271 }
mkarlsso 0:8dbd6bd9167f 3272 } else {
mkarlsso 0:8dbd6bd9167f 3273 textDisplay << "Error: Not a valid callback input\r\n";
mkarlsso 0:8dbd6bd9167f 3274 lineError = true;
mkarlsso 0:8dbd6bd9167f 3275 }
mkarlsso 0:8dbd6bd9167f 3276 if (tokens[i+2].compare("up") == 0) {
mkarlsso 0:8dbd6bd9167f 3277 currentTriggerDir = 1;
mkarlsso 0:8dbd6bd9167f 3278 } else if (tokens[i+2].compare("down") == 0) {
mkarlsso 0:8dbd6bd9167f 3279 currentTriggerDir = -1;
mkarlsso 0:8dbd6bd9167f 3280 } else {
mkarlsso 0:8dbd6bd9167f 3281 textDisplay << "Error: No trigger direction given\r\n";
mkarlsso 0:8dbd6bd9167f 3282 lineError = true;
mkarlsso 0:8dbd6bd9167f 3283 }
mkarlsso 0:8dbd6bd9167f 3284
mkarlsso 0:8dbd6bd9167f 3285 } else {
mkarlsso 0:8dbd6bd9167f 3286 if (!lineError) textDisplay << "Error: Not enough arguments for callback statement\r\n";
mkarlsso 0:8dbd6bd9167f 3287 lineError = true;
mkarlsso 0:8dbd6bd9167f 3288 }
mkarlsso 0:8dbd6bd9167f 3289 if (sz > 3) {
mkarlsso 0:8dbd6bd9167f 3290 if (!((sz == 4) && (tokens[i+3].compare("do") == 0))) {
mkarlsso 0:8dbd6bd9167f 3291 textDisplay << "Error: Too many arguments in callback statement\r\n";
mkarlsso 0:8dbd6bd9167f 3292 lineError = true;
mkarlsso 0:8dbd6bd9167f 3293 }
mkarlsso 0:8dbd6bd9167f 3294 }
mkarlsso 0:8dbd6bd9167f 3295
mkarlsso 0:8dbd6bd9167f 3296 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3297 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3298 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3299
mkarlsso 0:8dbd6bd9167f 3300 } else {
mkarlsso 0:8dbd6bd9167f 3301 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3302 lineError = true;
mkarlsso 0:8dbd6bd9167f 3303 }
mkarlsso 0:8dbd6bd9167f 3304 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3305
mkarlsso 0:8dbd6bd9167f 3306 blockDepth = 1;
mkarlsso 0:8dbd6bd9167f 3307 i = i+2;
mkarlsso 0:8dbd6bd9167f 3308 //create new event and attach it to the port
mkarlsso 0:8dbd6bd9167f 3309 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 0:8dbd6bd9167f 3310 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3311 if (currentTriggerDir == 1) {
mkarlsso 0:8dbd6bd9167f 3312
mkarlsso 0:8dbd6bd9167f 3313 portVector[currentTriggerPort-1].setTriggerUpEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3314 } else {
mkarlsso 0:8dbd6bd9167f 3315
mkarlsso 0:8dbd6bd9167f 3316 portVector[currentTriggerPort-1].setTriggerDownEvent(tmpEventPtrArray.back());
mkarlsso 0:8dbd6bd9167f 3317 }
mkarlsso 0:8dbd6bd9167f 3318
mkarlsso 0:8dbd6bd9167f 3319 }
mkarlsso 0:8dbd6bd9167f 3320 }
mkarlsso 0:8dbd6bd9167f 3321
mkarlsso 0:8dbd6bd9167f 3322 //if starts an if block----------------------------------------------
mkarlsso 0:8dbd6bd9167f 3323 //examples: if x < 10 && y == 1 do; if a==1 do in 1000
mkarlsso 0:8dbd6bd9167f 3324 } else if (tokens[i].compare("if") == 0) { //a new if block
mkarlsso 0:8dbd6bd9167f 3325 if (ifBlockInit || whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3326 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3327 lineError = true;
mkarlsso 0:8dbd6bd9167f 3328 }
mkarlsso 0:8dbd6bd9167f 3329
mkarlsso 0:8dbd6bd9167f 3330 ifBlockInit = true;
mkarlsso 0:8dbd6bd9167f 3331 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3332 bool eventDefined = false;
mkarlsso 0:8dbd6bd9167f 3333 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3334 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3335 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3336 eventDefined = true;
mkarlsso 0:8dbd6bd9167f 3337 } else {
mkarlsso 0:8dbd6bd9167f 3338 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3339 lineError = true;
mkarlsso 0:8dbd6bd9167f 3340 }
mkarlsso 0:8dbd6bd9167f 3341 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3342 textDisplay.debug("If statement\r\n");
mkarlsso 0:8dbd6bd9167f 3343 //this is a regular event
mkarlsso 0:8dbd6bd9167f 3344 //tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso 0:8dbd6bd9167f 3345 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3346
mkarlsso 0:8dbd6bd9167f 3347 if ((!elseFlag) && ((!thenFlag))) {
mkarlsso 0:8dbd6bd9167f 3348 tmpEventPtrArray.back()->blockType = 1; //this is an if block
mkarlsso 0:8dbd6bd9167f 3349 blockDepth = blockDepth + 1;
mkarlsso 0:8dbd6bd9167f 3350 } else if (elseFlag) {
mkarlsso 0:8dbd6bd9167f 3351 tmpEventPtrArray.back()->blockType = 3; //this is an else if block
mkarlsso 0:8dbd6bd9167f 3352 } else if (thenFlag) {
mkarlsso 0:8dbd6bd9167f 3353 tmpEventPtrArray.back()->blockType = 7; //this is a then if block
mkarlsso 0:8dbd6bd9167f 3354 }
mkarlsso 0:8dbd6bd9167f 3355 }
mkarlsso 0:8dbd6bd9167f 3356
mkarlsso 0:8dbd6bd9167f 3357 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3358 //combine the condition tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 3359 tmpString = "";
mkarlsso 0:8dbd6bd9167f 3360 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 3361 if (tokens[j].compare("do") != 0) {
mkarlsso 0:8dbd6bd9167f 3362 i++;
mkarlsso 0:8dbd6bd9167f 3363 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 3364 } else {
mkarlsso 0:8dbd6bd9167f 3365 break;
mkarlsso 0:8dbd6bd9167f 3366 }
mkarlsso 0:8dbd6bd9167f 3367 }
mkarlsso 0:8dbd6bd9167f 3368 //adds the conditions to the current event
mkarlsso 0:8dbd6bd9167f 3369
mkarlsso 0:8dbd6bd9167f 3370 if (!evaluateConditions(tmpString, tmpEventPtrArray.back())) lineError = true;
mkarlsso 0:8dbd6bd9167f 3371 }
mkarlsso 0:8dbd6bd9167f 3372
mkarlsso 0:8dbd6bd9167f 3373 if (lineError && eventDefined) {
mkarlsso 0:8dbd6bd9167f 3374 tmpEvent->release();
mkarlsso 0:8dbd6bd9167f 3375 }
mkarlsso 0:8dbd6bd9167f 3376
mkarlsso 0:8dbd6bd9167f 3377
mkarlsso 0:8dbd6bd9167f 3378 //else starts an else block-------------------------------------
mkarlsso 0:8dbd6bd9167f 3379 //examples: else do in 500; else if x==7 do
mkarlsso 0:8dbd6bd9167f 3380 } else if (tokens[i].compare("else") == 0) { //an else block
mkarlsso 0:8dbd6bd9167f 3381 if (ifBlockInit || whileBlockInit || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3382 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3383 lineError = true;
mkarlsso 0:8dbd6bd9167f 3384 }
mkarlsso 0:8dbd6bd9167f 3385 textDisplay.debug("Else statement\r\n");
mkarlsso 0:8dbd6bd9167f 3386 //callbacks can't have else conditions
mkarlsso 0:8dbd6bd9167f 3387 if ((!lineError) && (blockDepth < 2) && ((currentTriggerPort > -1)||(currentFunction > -1))) {
mkarlsso 0:8dbd6bd9167f 3388 textDisplay << "Error: else statement can not occur after a trigger block or outside a block\r\n";
mkarlsso 0:8dbd6bd9167f 3389 lineError = true;
mkarlsso 0:8dbd6bd9167f 3390 }
mkarlsso 0:8dbd6bd9167f 3391
mkarlsso 0:8dbd6bd9167f 3392 //check to make sure we are in an 'if' block
mkarlsso 0:8dbd6bd9167f 3393 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 1) && (tmpEventPtrArray.back()->blockType != 3)) { //not currently in an 'if' or 'else if' block
mkarlsso 0:8dbd6bd9167f 3394 textDisplay << "Error: else statement can only occur in an 'if' block\r\n";
mkarlsso 0:8dbd6bd9167f 3395 lineError = true;
mkarlsso 0:8dbd6bd9167f 3396 }
mkarlsso 0:8dbd6bd9167f 3397 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3398 elseFlag = true;
mkarlsso 0:8dbd6bd9167f 3399 expectingDoStatement = true;
mkarlsso 0:8dbd6bd9167f 3400
mkarlsso 0:8dbd6bd9167f 3401 }
mkarlsso 0:8dbd6bd9167f 3402 } else if (tokens[i].compare("then") == 0) { //a then block
mkarlsso 0:8dbd6bd9167f 3403 if (ifBlockInit || whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3404 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3405 lineError = true;
mkarlsso 0:8dbd6bd9167f 3406 }
mkarlsso 0:8dbd6bd9167f 3407
mkarlsso 0:8dbd6bd9167f 3408 //trigger blocks can't have else conditions
mkarlsso 0:8dbd6bd9167f 3409 if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso 0:8dbd6bd9167f 3410 textDisplay << "Error: 'then' statement can only occur after a 'while' block\r\n";
mkarlsso 0:8dbd6bd9167f 3411 lineError = true;
mkarlsso 0:8dbd6bd9167f 3412 }
mkarlsso 0:8dbd6bd9167f 3413
mkarlsso 0:8dbd6bd9167f 3414 //check to make sure we are in a 'while' block
mkarlsso 0:8dbd6bd9167f 3415 if ((!lineError) && (tmpEventPtrArray.back()->blockType != 5)) { //not currently in a while block
mkarlsso 0:8dbd6bd9167f 3416 textDisplay << "Error: 'then' statement can only occur in a 'while' block\r\n";
mkarlsso 0:8dbd6bd9167f 3417 lineError = true;
mkarlsso 0:8dbd6bd9167f 3418 }
mkarlsso 0:8dbd6bd9167f 3419 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3420 thenFlag = true;
mkarlsso 0:8dbd6bd9167f 3421 expectingDoStatement = true;
mkarlsso 0:8dbd6bd9167f 3422
mkarlsso 0:8dbd6bd9167f 3423 }
mkarlsso 0:8dbd6bd9167f 3424 //while starts a while block----------------------------------------
mkarlsso 0:8dbd6bd9167f 3425 //example: while x<10 do every 100
mkarlsso 0:8dbd6bd9167f 3426 // ...
mkarlsso 0:8dbd6bd9167f 3427 // end
mkarlsso 0:8dbd6bd9167f 3428 } else if (tokens[i].compare("while") == 0) { //a new while block
mkarlsso 0:8dbd6bd9167f 3429 if (ifBlockInit || whileBlockInit) {
mkarlsso 0:8dbd6bd9167f 3430 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3431 lineError = true;
mkarlsso 0:8dbd6bd9167f 3432 }
mkarlsso 0:8dbd6bd9167f 3433 textDisplay.debug("While statement\r\n");
mkarlsso 0:8dbd6bd9167f 3434
mkarlsso 0:8dbd6bd9167f 3435 if ((currentTriggerPort > 0) || (currentFunction > -1)) { //check to make sure we are inside a trigger block
mkarlsso 0:8dbd6bd9167f 3436
mkarlsso 0:8dbd6bd9167f 3437
mkarlsso 0:8dbd6bd9167f 3438 } else {
mkarlsso 0:8dbd6bd9167f 3439 textDisplay << "Error: a statement block must be placed inside a callback or function.\r\n";
mkarlsso 0:8dbd6bd9167f 3440 lineError = true;
mkarlsso 0:8dbd6bd9167f 3441 }
mkarlsso 0:8dbd6bd9167f 3442 //whileBlockInit = true;
mkarlsso 0:8dbd6bd9167f 3443 currentDelay = 0;
mkarlsso 0:8dbd6bd9167f 3444
mkarlsso 0:8dbd6bd9167f 3445 tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso 0:8dbd6bd9167f 3446 if (tmpEvent != NULL) {
mkarlsso 0:8dbd6bd9167f 3447 tmpEvent->isUsed = true;
mkarlsso 0:8dbd6bd9167f 3448 tmpEvent->setTimeLag(currentDelay);
mkarlsso 0:8dbd6bd9167f 3449 } else {
mkarlsso 0:8dbd6bd9167f 3450 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3451 lineError = true;
mkarlsso 0:8dbd6bd9167f 3452 }
mkarlsso 0:8dbd6bd9167f 3453
mkarlsso 0:8dbd6bd9167f 3454 //tmpEvent = new event(queuePtr);
mkarlsso 0:8dbd6bd9167f 3455
mkarlsso 0:8dbd6bd9167f 3456
mkarlsso 0:8dbd6bd9167f 3457 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3458 //combine the condition tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 3459 tmpString = "";
mkarlsso 0:8dbd6bd9167f 3460 for (unsigned j = i+1; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 3461 if (tokens[j].compare("do") != 0) {
mkarlsso 0:8dbd6bd9167f 3462 i++;
mkarlsso 0:8dbd6bd9167f 3463 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 3464 } else {
mkarlsso 0:8dbd6bd9167f 3465 break;
mkarlsso 0:8dbd6bd9167f 3466 }
mkarlsso 0:8dbd6bd9167f 3467 }
mkarlsso 0:8dbd6bd9167f 3468 //adds the conditions to the current event
mkarlsso 0:8dbd6bd9167f 3469 if (!evaluateConditions(tmpString, tmpEvent)) lineError = true;
mkarlsso 0:8dbd6bd9167f 3470 }
mkarlsso 0:8dbd6bd9167f 3471
mkarlsso 0:8dbd6bd9167f 3472 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3473 if ((i+3) < sz) {
mkarlsso 0:8dbd6bd9167f 3474 if ((tokens[i+1].compare("do") == 0) && (tokens[i+2].compare("every") == 0)) {
mkarlsso 0:8dbd6bd9167f 3475
mkarlsso 0:8dbd6bd9167f 3476 if (isNumber(tokens[i+3])) {
mkarlsso 0:8dbd6bd9167f 3477 uint32_t period = atoi(tokens[i+3].data());
mkarlsso 0:8dbd6bd9167f 3478 if (period > 0) {
mkarlsso 0:8dbd6bd9167f 3479
mkarlsso 0:8dbd6bd9167f 3480
mkarlsso 0:8dbd6bd9167f 3481 //tmpEvent->whileLoopPeriod = period;
mkarlsso 0:8dbd6bd9167f 3482 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 0:8dbd6bd9167f 3483 if (!elseFlag) {
mkarlsso 0:8dbd6bd9167f 3484 tmpEvent->blockType = 5; //this is a while block
mkarlsso 0:8dbd6bd9167f 3485
mkarlsso 0:8dbd6bd9167f 3486 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3487 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 3488 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3489 lineError = true;
mkarlsso 0:8dbd6bd9167f 3490 } else {
mkarlsso 0:8dbd6bd9167f 3491 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3492 }
mkarlsso 0:8dbd6bd9167f 3493 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3494 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3495
mkarlsso 0:8dbd6bd9167f 3496 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3497 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3498 } else {
mkarlsso 0:8dbd6bd9167f 3499 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 0:8dbd6bd9167f 3500 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3501 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3502 }
mkarlsso 0:8dbd6bd9167f 3503 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3504 } else {
mkarlsso 0:8dbd6bd9167f 3505 textDisplay << "Error: loop period must be a positive integer.\r\n";
mkarlsso 0:8dbd6bd9167f 3506 lineError = true;
mkarlsso 0:8dbd6bd9167f 3507 }
mkarlsso 0:8dbd6bd9167f 3508 } else if (findIntVariable(tokens[i+3])!=NULL) {
mkarlsso 0:8dbd6bd9167f 3509
mkarlsso 0:8dbd6bd9167f 3510 int* period = findIntVariable(tokens[i+3]);
mkarlsso 0:8dbd6bd9167f 3511 //tmpEvent->whileLoopPeriodVar = period;
mkarlsso 0:8dbd6bd9167f 3512 tmpEvent->setWhileLoopPeriod(period);
mkarlsso 0:8dbd6bd9167f 3513 if (!elseFlag) {
mkarlsso 0:8dbd6bd9167f 3514 tmpEvent->blockType = 5; //this is a while block
mkarlsso 0:8dbd6bd9167f 3515
mkarlsso 0:8dbd6bd9167f 3516 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3517 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 3518 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3519 lineError = true;
mkarlsso 0:8dbd6bd9167f 3520 } else {
mkarlsso 0:8dbd6bd9167f 3521 tmpAction->set(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3522 }
mkarlsso 0:8dbd6bd9167f 3523 //tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso 0:8dbd6bd9167f 3524 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3525
mkarlsso 0:8dbd6bd9167f 3526 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3527 blockDepth = blockDepth+1;
mkarlsso 0:8dbd6bd9167f 3528 } else {
mkarlsso 0:8dbd6bd9167f 3529 tmpEvent->blockType = 6; //this is an else while block
mkarlsso 0:8dbd6bd9167f 3530 tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3531 tmpEventPtrArray.push_back(tmpEvent);
mkarlsso 0:8dbd6bd9167f 3532 }
mkarlsso 0:8dbd6bd9167f 3533 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3534 }
mkarlsso 0:8dbd6bd9167f 3535 } else {
mkarlsso 0:8dbd6bd9167f 3536 textDisplay << "Error: expected a 'do every' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3537 lineError = true;
mkarlsso 0:8dbd6bd9167f 3538 }
mkarlsso 0:8dbd6bd9167f 3539 } else {
mkarlsso 0:8dbd6bd9167f 3540 textDisplay << "Error: expected a 'do every' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3541 lineError = true;
mkarlsso 0:8dbd6bd9167f 3542 }
mkarlsso 0:8dbd6bd9167f 3543 }
mkarlsso 0:8dbd6bd9167f 3544
mkarlsso 0:8dbd6bd9167f 3545 //if the line contains an '=' sign,the equality is evaulated-------------------------
mkarlsso 0:8dbd6bd9167f 3546 //examples: a = 1; a = b + 5; a = random(100); portout[2] = 1; portout[2] = flip
mkarlsso 0:8dbd6bd9167f 3547 } else if ((tmpLine.find_first_of("=") != std::string::npos) ) { //an expression
mkarlsso 0:8dbd6bd9167f 3548 if (ifBlockInit || whileBlockInit || elseFlag || expectingDoStatement) {
mkarlsso 0:8dbd6bd9167f 3549 textDisplay << "Error: expected a 'do' statement\r\n";
mkarlsso 0:8dbd6bd9167f 3550 lineError = true;
mkarlsso 0:8dbd6bd9167f 3551 }
mkarlsso 0:8dbd6bd9167f 3552
mkarlsso 0:8dbd6bd9167f 3553 wholeLineEvaluated = true;
mkarlsso 0:8dbd6bd9167f 3554 tmpString = "";
mkarlsso 0:8dbd6bd9167f 3555 int spacesBeforeEqualSign = 0;
mkarlsso 0:8dbd6bd9167f 3556 bool countSpaces = true;
mkarlsso 0:8dbd6bd9167f 3557 //combine the tokens without whitespaces
mkarlsso 0:8dbd6bd9167f 3558 for (unsigned j = i; j < sz; j++) {
mkarlsso 0:8dbd6bd9167f 3559 tmpString.append(tokens[j]);
mkarlsso 0:8dbd6bd9167f 3560 if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 3561 if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 3562 countSpaces = false;
mkarlsso 0:8dbd6bd9167f 3563 } else if (countSpaces) {
mkarlsso 0:8dbd6bd9167f 3564 spacesBeforeEqualSign++;
mkarlsso 0:8dbd6bd9167f 3565 }
mkarlsso 0:8dbd6bd9167f 3566 }
mkarlsso 0:8dbd6bd9167f 3567 if (!lineError && spacesBeforeEqualSign > 1) {
mkarlsso 0:8dbd6bd9167f 3568 textDisplay << "Error: Variable can't have a space in it.\r\n";
mkarlsso 0:8dbd6bd9167f 3569 lineError = true;
mkarlsso 0:8dbd6bd9167f 3570 }
mkarlsso 0:8dbd6bd9167f 3571
mkarlsso 0:8dbd6bd9167f 3572 if (!lineError) {
mkarlsso 0:8dbd6bd9167f 3573 if (blockDepth > 0) {
mkarlsso 0:8dbd6bd9167f 3574 textDisplay.debug("Variable assignment statement\r\n");
mkarlsso 0:8dbd6bd9167f 3575 //action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 0:8dbd6bd9167f 3576 action* tmpAction = evaluateAssignmentForAction(tmpString.data());
mkarlsso 0:8dbd6bd9167f 3577 if (tmpAction != NULL) {
mkarlsso 0:8dbd6bd9167f 3578 tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso 0:8dbd6bd9167f 3579
mkarlsso 0:8dbd6bd9167f 3580 } else {
mkarlsso 0:8dbd6bd9167f 3581 lineError = true;
mkarlsso 0:8dbd6bd9167f 3582 }
mkarlsso 0:8dbd6bd9167f 3583
mkarlsso 0:8dbd6bd9167f 3584 } else { //assignment was written outside of any block structure, so execute now
mkarlsso 0:8dbd6bd9167f 3585
mkarlsso 0:8dbd6bd9167f 3586
mkarlsso 0:8dbd6bd9167f 3587 //action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso 0:8dbd6bd9167f 3588 action* tmpAction = evaluateAssignmentForAction(tmpString.data());
mkarlsso 0:8dbd6bd9167f 3589
mkarlsso 0:8dbd6bd9167f 3590 if (tmpAction != NULL) {
mkarlsso 0:8dbd6bd9167f 3591 tmpAction->execute();
mkarlsso 0:8dbd6bd9167f 3592
mkarlsso 0:8dbd6bd9167f 3593 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3594 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3595 } else {
mkarlsso 0:8dbd6bd9167f 3596 lineError = true;
mkarlsso 0:8dbd6bd9167f 3597 }
mkarlsso 0:8dbd6bd9167f 3598 }
mkarlsso 0:8dbd6bd9167f 3599 }
mkarlsso 0:8dbd6bd9167f 3600 } else {
mkarlsso 0:8dbd6bd9167f 3601 //if there was no match to any of the above, an error is given
mkarlsso 0:8dbd6bd9167f 3602 textDisplay << "Error: statement not understood.\r\n";
mkarlsso 0:8dbd6bd9167f 3603 lineError = true;
mkarlsso 0:8dbd6bd9167f 3604 }
mkarlsso 0:8dbd6bd9167f 3605
mkarlsso 0:8dbd6bd9167f 3606 if (lineError) {
mkarlsso 5:abee20c0bf2a 3607 textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 3608 break; //stop parsing the rest of the line if an error was detected
mkarlsso 0:8dbd6bd9167f 3609 }
mkarlsso 0:8dbd6bd9167f 3610 if (wholeLineEvaluated) { //some of the tokens forces the whole line to be avaluated at once
mkarlsso 0:8dbd6bd9167f 3611 i = sz; //skip ahead to end of the line
mkarlsso 0:8dbd6bd9167f 3612 }
mkarlsso 0:8dbd6bd9167f 3613
mkarlsso 0:8dbd6bd9167f 3614 }
mkarlsso 0:8dbd6bd9167f 3615
mkarlsso 0:8dbd6bd9167f 3616 //if there was an error, we quit compiling the code
mkarlsso 0:8dbd6bd9167f 3617 if (lineError) {
mkarlsso 3:d7b0a0890d96 3618
mkarlsso 0:8dbd6bd9167f 3619 textDisplay << "Line text: ";
mkarlsso 5:abee20c0bf2a 3620 /*
mkarlsso 0:8dbd6bd9167f 3621 while (!tokens.empty()) {
mkarlsso 0:8dbd6bd9167f 3622 textDisplay << tokens.front()<< " ";
mkarlsso 5:abee20c0bf2a 3623 //tokens.erase(tokens.begin());
mkarlsso 5:abee20c0bf2a 3624 }*/
mkarlsso 5:abee20c0bf2a 3625
mkarlsso 5:abee20c0bf2a 3626 //Display the line with the syntax error
mkarlsso 5:abee20c0bf2a 3627 for (int tokInd = 0; tokInd < tokens.size(); tokInd++) {
mkarlsso 5:abee20c0bf2a 3628 textDisplay << tokens.at(tokInd) << " ";
mkarlsso 0:8dbd6bd9167f 3629 }
mkarlsso 0:8dbd6bd9167f 3630 textDisplay << "\r\n";
mkarlsso 5:abee20c0bf2a 3631 textDisplay.flush();
mkarlsso 3:d7b0a0890d96 3632
mkarlsso 0:8dbd6bd9167f 3633 currentBlock.resetBuffer();
mkarlsso 5:abee20c0bf2a 3634
mkarlsso 5:abee20c0bf2a 3635 //Clear the line tokens
mkarlsso 0:8dbd6bd9167f 3636 while (!tokens.empty()) {
mkarlsso 0:8dbd6bd9167f 3637 tokens.pop_back();
mkarlsso 0:8dbd6bd9167f 3638 }
mkarlsso 5:abee20c0bf2a 3639
mkarlsso 5:abee20c0bf2a 3640 if (tmpEventPtrArray.size() > 0) {
mkarlsso 5:abee20c0bf2a 3641 tmpEventPtrArray.at(0)->release(); //release the unfinished block (and all children)
mkarlsso 5:abee20c0bf2a 3642 }
mkarlsso 5:abee20c0bf2a 3643 while (tmpEventPtrArray.size() > 0){
mkarlsso 5:abee20c0bf2a 3644 tmpEventPtrArray.pop_back();
mkarlsso 5:abee20c0bf2a 3645 }
mkarlsso 5:abee20c0bf2a 3646
mkarlsso 5:abee20c0bf2a 3647
mkarlsso 3:d7b0a0890d96 3648 //delete tmpEvent;
mkarlsso 5:abee20c0bf2a 3649 /*
mkarlsso 5:abee20c0bf2a 3650 if (tmpEvent != NULL) {
mkarlsso 5:abee20c0bf2a 3651 tmpEvent->release();
mkarlsso 5:abee20c0bf2a 3652 }
mkarlsso 5:abee20c0bf2a 3653 */
mkarlsso 0:8dbd6bd9167f 3654 } else {
mkarlsso 0:8dbd6bd9167f 3655
mkarlsso 5:abee20c0bf2a 3656 //Clear the line tokens
mkarlsso 0:8dbd6bd9167f 3657 while (!tokens.empty()) {
mkarlsso 0:8dbd6bd9167f 3658 tokens.pop_back();
mkarlsso 0:8dbd6bd9167f 3659 }
mkarlsso 0:8dbd6bd9167f 3660 //currentBlock.pop_back();
mkarlsso 0:8dbd6bd9167f 3661
mkarlsso 0:8dbd6bd9167f 3662 }
mkarlsso 0:8dbd6bd9167f 3663
mkarlsso 0:8dbd6bd9167f 3664 }
mkarlsso 0:8dbd6bd9167f 3665
mkarlsso 0:8dbd6bd9167f 3666 //make sure that all blocks have a matching end statement
mkarlsso 0:8dbd6bd9167f 3667
mkarlsso 0:8dbd6bd9167f 3668
mkarlsso 0:8dbd6bd9167f 3669 if ((!lineError)&&(blockDepth > 0)) {
mkarlsso 0:8dbd6bd9167f 3670 textDisplay << "Error: Missing 1 or more end statements\r\n";
mkarlsso 0:8dbd6bd9167f 3671 lineError = true;
mkarlsso 0:8dbd6bd9167f 3672 currentBlock.resetBuffer();
mkarlsso 0:8dbd6bd9167f 3673 }
mkarlsso 0:8dbd6bd9167f 3674
mkarlsso 0:8dbd6bd9167f 3675 if ((!lineError)&&(blockDepth == 0)) {
mkarlsso 0:8dbd6bd9167f 3676 textDisplay.send("~~~\r\n");
mkarlsso 0:8dbd6bd9167f 3677 }
mkarlsso 0:8dbd6bd9167f 3678
mkarlsso 0:8dbd6bd9167f 3679 //displayMemoryLeft();
mkarlsso 0:8dbd6bd9167f 3680 //DisplayRAMBanks();
mkarlsso 0:8dbd6bd9167f 3681
mkarlsso 0:8dbd6bd9167f 3682 }
mkarlsso 0:8dbd6bd9167f 3683
mkarlsso 0:8dbd6bd9167f 3684
mkarlsso 0:8dbd6bd9167f 3685 //used to return a pointer to a variable, if it exists
mkarlsso 0:8dbd6bd9167f 3686 int* scriptStream::findIntVariable(string nameInput) {
mkarlsso 0:8dbd6bd9167f 3687
mkarlsso 0:8dbd6bd9167f 3688 textDisplay.debug("Finding variable: ");
mkarlsso 0:8dbd6bd9167f 3689 textDisplay.debug(nameInput.data());
mkarlsso 0:8dbd6bd9167f 3690 int* outPtr = NULL;
mkarlsso 0:8dbd6bd9167f 3691 bool foundIt = false;
mkarlsso 0:8dbd6bd9167f 3692 if (nameInput.find("portout") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 3693 int pos1 = nameInput.find("portout[")+8;
mkarlsso 0:8dbd6bd9167f 3694 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 3695 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3696 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 3697 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3698 outPtr = &portVector[portnum-1].outState;
mkarlsso 0:8dbd6bd9167f 3699 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3700 }
mkarlsso 0:8dbd6bd9167f 3701 } else if (nameInput.find("portin") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 3702 int pos1 = nameInput.find("portin[")+7;
mkarlsso 0:8dbd6bd9167f 3703 int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 3704 int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3705 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 3706 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3707 outPtr = &portVector[portnum-1].inState;
mkarlsso 0:8dbd6bd9167f 3708 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3709 }
mkarlsso 0:8dbd6bd9167f 3710 }
mkarlsso 0:8dbd6bd9167f 3711
mkarlsso 0:8dbd6bd9167f 3712 if (!foundIt) {
mkarlsso 0:8dbd6bd9167f 3713 std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso 0:8dbd6bd9167f 3714 int start = 0;
mkarlsso 0:8dbd6bd9167f 3715 int end = nameInput.length()-1;
mkarlsso 0:8dbd6bd9167f 3716
mkarlsso 0:8dbd6bd9167f 3717 for (unsigned i = 0; i < sz; i++) {
mkarlsso 0:8dbd6bd9167f 3718
mkarlsso 0:8dbd6bd9167f 3719
mkarlsso 0:8dbd6bd9167f 3720 if ((findStringLoc(nameInput.data(),globalVariables[i]->tag,start,end) != -1) && (strlen(globalVariables[i]->tag)==(end-start+1))) {
mkarlsso 0:8dbd6bd9167f 3721 outPtr = &globalVariables[i]->value;
mkarlsso 0:8dbd6bd9167f 3722 break;
mkarlsso 0:8dbd6bd9167f 3723 }
mkarlsso 0:8dbd6bd9167f 3724 /*
mkarlsso 0:8dbd6bd9167f 3725 if (nameInput.compare(globalVariables[i]->tag) == 0) {
mkarlsso 0:8dbd6bd9167f 3726 outPtr = &globalVariables[i]->value;
mkarlsso 0:8dbd6bd9167f 3727 break;
mkarlsso 0:8dbd6bd9167f 3728 }*/
mkarlsso 0:8dbd6bd9167f 3729 }
mkarlsso 0:8dbd6bd9167f 3730 }
mkarlsso 0:8dbd6bd9167f 3731 textDisplay.debug("...done\r\n");
mkarlsso 0:8dbd6bd9167f 3732
mkarlsso 0:8dbd6bd9167f 3733 return outPtr;
mkarlsso 0:8dbd6bd9167f 3734 }
mkarlsso 0:8dbd6bd9167f 3735
mkarlsso 0:8dbd6bd9167f 3736
mkarlsso 0:8dbd6bd9167f 3737 //used to return a pointer to a variable, if it exists
mkarlsso 0:8dbd6bd9167f 3738 int* scriptStream::findIntVariable(const char* nameInput, int start, int end) {
mkarlsso 0:8dbd6bd9167f 3739
mkarlsso 0:8dbd6bd9167f 3740 textDisplay.debug("Finding variable...");
mkarlsso 0:8dbd6bd9167f 3741 int* outPtr = NULL;
mkarlsso 0:8dbd6bd9167f 3742 bool foundIt = false;
mkarlsso 0:8dbd6bd9167f 3743
mkarlsso 0:8dbd6bd9167f 3744 if (findStringLoc(nameInput,"portout[",start,end) != -1) {
mkarlsso 0:8dbd6bd9167f 3745 int pos1 = findStringLoc(nameInput,"portout[",start,end)+8;
mkarlsso 0:8dbd6bd9167f 3746 int pos2 = findStringLoc(nameInput, "]",pos1,end);
mkarlsso 0:8dbd6bd9167f 3747 if ((pos1 == -1)||(pos2 == -1)) {
mkarlsso 0:8dbd6bd9167f 3748 //syntax error
mkarlsso 0:8dbd6bd9167f 3749 return NULL;
mkarlsso 0:8dbd6bd9167f 3750 }
mkarlsso 0:8dbd6bd9167f 3751
mkarlsso 0:8dbd6bd9167f 3752 //int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 3753 long int portnum = strtol(nameInput+pos1,NULL,10);
mkarlsso 0:8dbd6bd9167f 3754 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3755 outPtr = &portVector[(int)portnum-1].outState;
mkarlsso 0:8dbd6bd9167f 3756 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3757 }
mkarlsso 0:8dbd6bd9167f 3758 } else if (findStringLoc(nameInput,"portin[",start,end) != -1) {
mkarlsso 0:8dbd6bd9167f 3759 int pos1 = findStringLoc(nameInput,"portin[",start,end)+7;
mkarlsso 0:8dbd6bd9167f 3760 int pos2 = findStringLoc(nameInput, "]",pos1,end);
mkarlsso 0:8dbd6bd9167f 3761 if ((pos1 == -1)||(pos2 == -1)) {
mkarlsso 0:8dbd6bd9167f 3762 //syntax error
mkarlsso 0:8dbd6bd9167f 3763 return NULL;
mkarlsso 0:8dbd6bd9167f 3764 }
mkarlsso 0:8dbd6bd9167f 3765 long int portnum = strtol(nameInput+pos1,NULL,10);
mkarlsso 0:8dbd6bd9167f 3766
mkarlsso 0:8dbd6bd9167f 3767 if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso 0:8dbd6bd9167f 3768 outPtr = &portVector[(int)portnum-1].inState;
mkarlsso 0:8dbd6bd9167f 3769 foundIt = true;
mkarlsso 0:8dbd6bd9167f 3770 }
mkarlsso 0:8dbd6bd9167f 3771 }
mkarlsso 0:8dbd6bd9167f 3772
mkarlsso 0:8dbd6bd9167f 3773 if (!foundIt) {
mkarlsso 0:8dbd6bd9167f 3774 std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso 0:8dbd6bd9167f 3775 for (unsigned i = 0; i < sz; i++) {
mkarlsso 0:8dbd6bd9167f 3776 //const char* varName = globalVariables[i]->tag.data();
mkarlsso 0:8dbd6bd9167f 3777 if ((findStringLoc(nameInput,globalVariables[i]->tag,start,end) != -1) && (strlen(globalVariables[i]->tag)==(end-start+1))) {
mkarlsso 0:8dbd6bd9167f 3778 outPtr = &globalVariables[i]->value;
mkarlsso 0:8dbd6bd9167f 3779 break;
mkarlsso 0:8dbd6bd9167f 3780 }
mkarlsso 0:8dbd6bd9167f 3781 }
mkarlsso 0:8dbd6bd9167f 3782 }
mkarlsso 0:8dbd6bd9167f 3783 textDisplay.debug("done\r\n");
mkarlsso 0:8dbd6bd9167f 3784
mkarlsso 0:8dbd6bd9167f 3785 return outPtr;
mkarlsso 0:8dbd6bd9167f 3786 }
mkarlsso 0:8dbd6bd9167f 3787
mkarlsso 0:8dbd6bd9167f 3788 bool scriptStream::createIntVariable(string nameInput) {
mkarlsso 0:8dbd6bd9167f 3789 if (findIntVariable(nameInput) == NULL) {
mkarlsso 0:8dbd6bd9167f 3790 globalVariables.push_back(new intVariable(nameInput, 0));
mkarlsso 0:8dbd6bd9167f 3791 return true;
mkarlsso 0:8dbd6bd9167f 3792 } else {
mkarlsso 0:8dbd6bd9167f 3793 return false;
mkarlsso 0:8dbd6bd9167f 3794 }
mkarlsso 0:8dbd6bd9167f 3795 }
mkarlsso 0:8dbd6bd9167f 3796
mkarlsso 0:8dbd6bd9167f 3797 action* scriptStream::evaluateAssignmentForAction(const char* expression) {
mkarlsso 0:8dbd6bd9167f 3798
mkarlsso 0:8dbd6bd9167f 3799 //action* tmpAction = new action(); //create a new action
mkarlsso 0:8dbd6bd9167f 3800 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 3801 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 3802 textDisplay << "Error: no action memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3803 return NULL;
mkarlsso 0:8dbd6bd9167f 3804 }
mkarlsso 0:8dbd6bd9167f 3805 int stringInd;
mkarlsso 0:8dbd6bd9167f 3806 int stringInd2;
mkarlsso 0:8dbd6bd9167f 3807 int afterEqualLoc;
mkarlsso 0:8dbd6bd9167f 3808 int beforeEqualLoc;
mkarlsso 0:8dbd6bd9167f 3809 int lastCharLoc = strlen(expression)-1;
mkarlsso 0:8dbd6bd9167f 3810 int multiplierInt = 1;
mkarlsso 0:8dbd6bd9167f 3811 //string afterEqual;
mkarlsso 0:8dbd6bd9167f 3812 //string beforeEqual;
mkarlsso 0:8dbd6bd9167f 3813 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 3814 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 3815 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 3816 int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 3817
mkarlsso 0:8dbd6bd9167f 3818 stringInd = findStringLoc(expression,"=",0,strlen(expression)-1); //location of = sign, if it exists
mkarlsso 0:8dbd6bd9167f 3819 if (stringInd == -1) {
mkarlsso 0:8dbd6bd9167f 3820 //Make sure there is an equal sign
mkarlsso 0:8dbd6bd9167f 3821 return NULL;
mkarlsso 0:8dbd6bd9167f 3822 }
mkarlsso 0:8dbd6bd9167f 3823
mkarlsso 0:8dbd6bd9167f 3824 beforeEqualLoc = stringInd-1;
mkarlsso 0:8dbd6bd9167f 3825 afterEqualLoc = stringInd+1;
mkarlsso 0:8dbd6bd9167f 3826
mkarlsso 0:8dbd6bd9167f 3827 //location of +/- sign (only one allowed)
mkarlsso 0:8dbd6bd9167f 3828 stringInd2 = findStringLoc(expression,"+",afterEqualLoc,strlen(expression)-1);
mkarlsso 0:8dbd6bd9167f 3829 if (stringInd2 == -1) {
mkarlsso 0:8dbd6bd9167f 3830 stringInd2 = findStringLoc(expression,"-",afterEqualLoc,strlen(expression)-1);
mkarlsso 0:8dbd6bd9167f 3831 multiplierInt = -1;
mkarlsso 0:8dbd6bd9167f 3832
mkarlsso 0:8dbd6bd9167f 3833 }
mkarlsso 3:d7b0a0890d96 3834
mkarlsso 0:8dbd6bd9167f 3835 tmpVar = findIntVariable(expression,0,beforeEqualLoc); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 3836 if (findStringLoc(expression,"portout[",0,beforeEqualLoc) != -1) { //set the output of a digital port
mkarlsso 0:8dbd6bd9167f 3837 textDisplay.debug("Portout assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3838 int pos1 = findStringLoc(expression,"portout[",0,beforeEqualLoc)+8;
mkarlsso 0:8dbd6bd9167f 3839 int pos2 = findStringLoc(expression,"]",pos1,beforeEqualLoc)-1;
mkarlsso 0:8dbd6bd9167f 3840 if (pos2 < pos1) {
mkarlsso 0:8dbd6bd9167f 3841 textDisplay << "Error: expected a ] character\r\n";
mkarlsso 0:8dbd6bd9167f 3842 return NULL;
mkarlsso 0:8dbd6bd9167f 3843 }
mkarlsso 0:8dbd6bd9167f 3844
mkarlsso 0:8dbd6bd9167f 3845 int portnum = -1;
mkarlsso 0:8dbd6bd9167f 3846 if (isNum(expression,pos1,pos2)) {
mkarlsso 0:8dbd6bd9167f 3847 portnum = atoi(expression+pos1);
mkarlsso 0:8dbd6bd9167f 3848 }
mkarlsso 0:8dbd6bd9167f 3849 int* tmpVar = findIntVariable(expression, pos1,pos2); //returns pointer to the variable, if given
mkarlsso 0:8dbd6bd9167f 3850 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 3851 if ((tmpVar != NULL)||((portnum > 0) && (portnum <= numPorts))) {
mkarlsso 0:8dbd6bd9167f 3852 if (isNum(expression,afterEqualLoc,lastCharLoc)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 3853 portVal = atoi(expression+afterEqualLoc);
mkarlsso 0:8dbd6bd9167f 3854 if ((portVal == 0) || (portVal == 1)) {
mkarlsso 0:8dbd6bd9167f 3855 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 3856 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 3857 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 3858 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3859 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3860 return NULL;
mkarlsso 0:8dbd6bd9167f 3861 } else {
mkarlsso 0:8dbd6bd9167f 3862 //tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 3863 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 3864 tmpMessage->setMessage(NULL,portnum,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 3865 } else {
mkarlsso 0:8dbd6bd9167f 3866 tmpMessage->setMessage(tmpVar,0,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 3867 }
mkarlsso 0:8dbd6bd9167f 3868 }
mkarlsso 0:8dbd6bd9167f 3869
mkarlsso 0:8dbd6bd9167f 3870
mkarlsso 0:8dbd6bd9167f 3871 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 3872
mkarlsso 0:8dbd6bd9167f 3873 } else {
mkarlsso 0:8dbd6bd9167f 3874 textDisplay << "Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 3875 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3876 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3877 return NULL;
mkarlsso 0:8dbd6bd9167f 3878 }
mkarlsso 0:8dbd6bd9167f 3879 } else if (findStringLoc(expression,"flip",afterEqualLoc,lastCharLoc)!=-1) {
mkarlsso 0:8dbd6bd9167f 3880 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 3881 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 3882 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 3883 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3884 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3885 return NULL;
mkarlsso 0:8dbd6bd9167f 3886 } else {
mkarlsso 0:8dbd6bd9167f 3887 //tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 3888 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 3889 tmpMessage->setMessage(NULL,portnum,-1,portVector);
mkarlsso 0:8dbd6bd9167f 3890 } else {
mkarlsso 0:8dbd6bd9167f 3891 tmpMessage->setMessage(tmpVar,0,-1,portVector);
mkarlsso 0:8dbd6bd9167f 3892 }
mkarlsso 0:8dbd6bd9167f 3893 }
mkarlsso 0:8dbd6bd9167f 3894 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 3895 } else {
mkarlsso 0:8dbd6bd9167f 3896 textDisplay << "Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 3897 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3898 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3899 return NULL;
mkarlsso 0:8dbd6bd9167f 3900 }
mkarlsso 0:8dbd6bd9167f 3901 } else {
mkarlsso 0:8dbd6bd9167f 3902 textDisplay << "Port number not found (must be between 1 and " << numPorts << " or an existing variable)\r\n";
mkarlsso 0:8dbd6bd9167f 3903 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3904 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3905 return NULL;
mkarlsso 0:8dbd6bd9167f 3906 }
mkarlsso 0:8dbd6bd9167f 3907 } else if (findStringLoc(expression,"portin",0,stringInd)!=-1) {
mkarlsso 0:8dbd6bd9167f 3908 textDisplay << "Error: portins can not be set\r\n";
mkarlsso 0:8dbd6bd9167f 3909 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3910 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3911 return NULL;
mkarlsso 0:8dbd6bd9167f 3912 } else if (tmpVar != NULL) {
mkarlsso 0:8dbd6bd9167f 3913 intOperation* tmpOp;
mkarlsso 0:8dbd6bd9167f 3914 intOperation* tmpOp2;
mkarlsso 0:8dbd6bd9167f 3915 if (isNum(expression,afterEqualLoc,lastCharLoc)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 3916 textDisplay.debug("Numeric assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3917 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 0:8dbd6bd9167f 3918 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3919 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3920 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3921 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3922 return NULL;
mkarlsso 0:8dbd6bd9167f 3923 } else {
mkarlsso 0:8dbd6bd9167f 3924 tmpOp->set(tmpVar, "=", atoi(expression+afterEqualLoc));
mkarlsso 0:8dbd6bd9167f 3925 }
mkarlsso 0:8dbd6bd9167f 3926 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3927
mkarlsso 0:8dbd6bd9167f 3928 } else if ((stringInd2 == -1)&&(findStringLoc(expression,"random",afterEqualLoc,lastCharLoc)!=-1)) {
mkarlsso 0:8dbd6bd9167f 3929 //assign random number
mkarlsso 0:8dbd6bd9167f 3930 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 3931 textDisplay.debug("Random number assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3932 int highVal = getRandomParam(expression,afterEqualLoc,lastCharLoc);
mkarlsso 0:8dbd6bd9167f 3933
mkarlsso 0:8dbd6bd9167f 3934 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 3935 //tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 0:8dbd6bd9167f 3936 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3937 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3938 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3939 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3940 return NULL;
mkarlsso 0:8dbd6bd9167f 3941 } else {
mkarlsso 0:8dbd6bd9167f 3942 tmpOp->setRandOp(highVal, "=", tmpVar, false);
mkarlsso 0:8dbd6bd9167f 3943 }
mkarlsso 0:8dbd6bd9167f 3944 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3945
mkarlsso 0:8dbd6bd9167f 3946 } else {
mkarlsso 0:8dbd6bd9167f 3947 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 3948 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3949 return NULL;
mkarlsso 0:8dbd6bd9167f 3950 }
mkarlsso 0:8dbd6bd9167f 3951 } else if ((stringInd2 == -1)&&(findStringLoc(expression,"clock()",afterEqualLoc,lastCharLoc)!=-1)) {
mkarlsso 0:8dbd6bd9167f 3952 //assign clock value
mkarlsso 0:8dbd6bd9167f 3953 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 3954 textDisplay.debug("Clock assignment to variable\r\n");
mkarlsso 0:8dbd6bd9167f 3955 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3956 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3957 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3958 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3959 return NULL;
mkarlsso 0:8dbd6bd9167f 3960 } else {
mkarlsso 0:8dbd6bd9167f 3961 tmpOp->setClockOp(tmpVar); //assigns the current clock value to tmpVar
mkarlsso 0:8dbd6bd9167f 3962 }
mkarlsso 0:8dbd6bd9167f 3963 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 3964
mkarlsso 0:8dbd6bd9167f 3965 } else if (stringInd2 != -1) { //a +/- operation is there
mkarlsso 0:8dbd6bd9167f 3966 textDisplay.debug("equation assignment\r\n");
mkarlsso 0:8dbd6bd9167f 3967 //string multiplier("+");
mkarlsso 0:8dbd6bd9167f 3968 char multiplier[3];
mkarlsso 0:8dbd6bd9167f 3969 if (multiplierInt==1) {
mkarlsso 0:8dbd6bd9167f 3970 strcpy(multiplier,"+");
mkarlsso 0:8dbd6bd9167f 3971 } else {
mkarlsso 0:8dbd6bd9167f 3972 strcpy(multiplier,"-");
mkarlsso 0:8dbd6bd9167f 3973 }
mkarlsso 0:8dbd6bd9167f 3974
mkarlsso 0:8dbd6bd9167f 3975 /*
mkarlsso 0:8dbd6bd9167f 3976 if (afterEqual[stringInd2] == '-') {
mkarlsso 0:8dbd6bd9167f 3977 multiplier = "-";
mkarlsso 0:8dbd6bd9167f 3978 multiplierInt = -1;
mkarlsso 0:8dbd6bd9167f 3979 }*/
mkarlsso 0:8dbd6bd9167f 3980 tmpVar2 = findIntVariable(expression,afterEqualLoc,stringInd2-1); //before the +/- sign
mkarlsso 0:8dbd6bd9167f 3981 tmpVar3 = findIntVariable(expression,stringInd2+1,lastCharLoc); //after the +/- sign
mkarlsso 0:8dbd6bd9167f 3982
mkarlsso 0:8dbd6bd9167f 3983 if ((tmpVar2 != NULL) && isNum(expression,stringInd2+1,lastCharLoc)) { //variable +/- number
mkarlsso 0:8dbd6bd9167f 3984 if (tmpVar2 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 3985 //final sign is += or -=
mkarlsso 0:8dbd6bd9167f 3986 if (multiplierInt==1) {
mkarlsso 0:8dbd6bd9167f 3987 strcpy(multiplier,"+=");
mkarlsso 0:8dbd6bd9167f 3988 } else {
mkarlsso 0:8dbd6bd9167f 3989 strcpy(multiplier,"-=");
mkarlsso 0:8dbd6bd9167f 3990 }
mkarlsso 0:8dbd6bd9167f 3991
mkarlsso 0:8dbd6bd9167f 3992 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 3993 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 3994 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 3995 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 3996 return NULL;
mkarlsso 0:8dbd6bd9167f 3997 } else {
mkarlsso 0:8dbd6bd9167f 3998 tmpOp->set(tmpVar, multiplier, atoi(expression+stringInd2+1));
mkarlsso 0:8dbd6bd9167f 3999 }
mkarlsso 0:8dbd6bd9167f 4000 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4001
mkarlsso 0:8dbd6bd9167f 4002 } else {
mkarlsso 0:8dbd6bd9167f 4003
mkarlsso 0:8dbd6bd9167f 4004 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4005 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4006 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4007 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4008 return NULL;
mkarlsso 0:8dbd6bd9167f 4009 } else {
mkarlsso 0:8dbd6bd9167f 4010
mkarlsso 0:8dbd6bd9167f 4011 tmpOp2->set(tmpVar2,multiplier, atoi(expression+stringInd2+1));
mkarlsso 0:8dbd6bd9167f 4012 //tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4013 }
mkarlsso 0:8dbd6bd9167f 4014
mkarlsso 0:8dbd6bd9167f 4015 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4016 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4017 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4018 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4019 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4020 return NULL;
mkarlsso 0:8dbd6bd9167f 4021 } else {
mkarlsso 0:8dbd6bd9167f 4022 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4023 }
mkarlsso 0:8dbd6bd9167f 4024
mkarlsso 0:8dbd6bd9167f 4025 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4026
mkarlsso 0:8dbd6bd9167f 4027 }
mkarlsso 0:8dbd6bd9167f 4028
mkarlsso 0:8dbd6bd9167f 4029 } else if ((tmpVar3 != NULL) && isNum(expression,afterEqualLoc,stringInd2-1)) { //number +/- variable
mkarlsso 0:8dbd6bd9167f 4030 if (tmpVar3 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 4031 //final sign is += or -=
mkarlsso 0:8dbd6bd9167f 4032 if (multiplierInt==1) {
mkarlsso 0:8dbd6bd9167f 4033 strcpy(multiplier,"+=");
mkarlsso 0:8dbd6bd9167f 4034 } else {
mkarlsso 0:8dbd6bd9167f 4035 strcpy(multiplier,"-=");
mkarlsso 0:8dbd6bd9167f 4036 }
mkarlsso 0:8dbd6bd9167f 4037
mkarlsso 0:8dbd6bd9167f 4038 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4039 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4040 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4041 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4042 return NULL;
mkarlsso 0:8dbd6bd9167f 4043 } else {
mkarlsso 0:8dbd6bd9167f 4044 tmpOp->set(tmpVar, multiplier, atoi(expression+afterEqualLoc));
mkarlsso 0:8dbd6bd9167f 4045 }
mkarlsso 0:8dbd6bd9167f 4046 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4047
mkarlsso 0:8dbd6bd9167f 4048 } else {
mkarlsso 0:8dbd6bd9167f 4049
mkarlsso 0:8dbd6bd9167f 4050 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4051 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4052 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4053 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4054 return NULL;
mkarlsso 0:8dbd6bd9167f 4055 } else {
mkarlsso 0:8dbd6bd9167f 4056 tmpOp2->set(tmpVar3, multiplier, atoi(expression+afterEqualLoc));
mkarlsso 0:8dbd6bd9167f 4057 }
mkarlsso 0:8dbd6bd9167f 4058 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4059
mkarlsso 0:8dbd6bd9167f 4060 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4061 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4062 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4063 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4064 return NULL;
mkarlsso 0:8dbd6bd9167f 4065 } else {
mkarlsso 0:8dbd6bd9167f 4066 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4067 }
mkarlsso 0:8dbd6bd9167f 4068 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4069
mkarlsso 0:8dbd6bd9167f 4070 }
mkarlsso 0:8dbd6bd9167f 4071
mkarlsso 0:8dbd6bd9167f 4072 } else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso 0:8dbd6bd9167f 4073
mkarlsso 0:8dbd6bd9167f 4074 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4075 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4076 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4077 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4078 return NULL;
mkarlsso 0:8dbd6bd9167f 4079 } else {
mkarlsso 0:8dbd6bd9167f 4080 tmpOp2->set(tmpVar2, multiplier, tmpVar3);
mkarlsso 0:8dbd6bd9167f 4081 }
mkarlsso 0:8dbd6bd9167f 4082 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4083
mkarlsso 0:8dbd6bd9167f 4084 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4085 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4086 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4087 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4088 return NULL;
mkarlsso 0:8dbd6bd9167f 4089 } else {
mkarlsso 0:8dbd6bd9167f 4090
mkarlsso 0:8dbd6bd9167f 4091 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4092 }
mkarlsso 0:8dbd6bd9167f 4093 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4094
mkarlsso 0:8dbd6bd9167f 4095 } else if ( isNum(expression,stringInd2+1,lastCharLoc) && isNum(expression,afterEqualLoc,stringInd2-1) ) { //number +/- number
mkarlsso 0:8dbd6bd9167f 4096 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4097 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4098 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4099 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4100 return NULL;
mkarlsso 0:8dbd6bd9167f 4101 } else {
mkarlsso 0:8dbd6bd9167f 4102 tmpOp->set(tmpVar, "=", atoi(expression+afterEqualLoc) + (multiplierInt * atoi(expression+stringInd2+1)) );
mkarlsso 0:8dbd6bd9167f 4103 }
mkarlsso 0:8dbd6bd9167f 4104 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4105
mkarlsso 0:8dbd6bd9167f 4106 } else if ((findStringLoc(expression,"random", afterEqualLoc,stringInd2-1)!=-1) && isNum(expression,stringInd2+1,lastCharLoc)) { //random +/- number
mkarlsso 0:8dbd6bd9167f 4107 int highVal = getRandomParam(expression,afterEqualLoc,stringInd2-1);
mkarlsso 0:8dbd6bd9167f 4108
mkarlsso 0:8dbd6bd9167f 4109 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4110
mkarlsso 0:8dbd6bd9167f 4111
mkarlsso 0:8dbd6bd9167f 4112 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4113 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4114 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4115 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4116 return NULL;
mkarlsso 0:8dbd6bd9167f 4117 } else {
mkarlsso 0:8dbd6bd9167f 4118 tmpOp2->setRandOp(highVal, multiplier, atoi(expression+stringInd2+1),false);
mkarlsso 0:8dbd6bd9167f 4119 }
mkarlsso 0:8dbd6bd9167f 4120 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4121
mkarlsso 0:8dbd6bd9167f 4122 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4123 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4124 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4125 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4126 return NULL;
mkarlsso 0:8dbd6bd9167f 4127 } else {
mkarlsso 0:8dbd6bd9167f 4128 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4129 }
mkarlsso 0:8dbd6bd9167f 4130 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4131
mkarlsso 0:8dbd6bd9167f 4132 } else {
mkarlsso 0:8dbd6bd9167f 4133 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4134 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4135 return NULL;
mkarlsso 0:8dbd6bd9167f 4136 }
mkarlsso 0:8dbd6bd9167f 4137 } else if ((findStringLoc(expression,"random",afterEqualLoc,stringInd2-1)!=-1) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso 0:8dbd6bd9167f 4138 int highVal = getRandomParam(expression,afterEqualLoc,stringInd2-1);
mkarlsso 0:8dbd6bd9167f 4139
mkarlsso 0:8dbd6bd9167f 4140 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4141
mkarlsso 0:8dbd6bd9167f 4142
mkarlsso 0:8dbd6bd9167f 4143 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4144 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4145 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4146 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4147 return NULL;
mkarlsso 0:8dbd6bd9167f 4148 } else {
mkarlsso 0:8dbd6bd9167f 4149 tmpOp2->setRandOp(highVal, multiplier, tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4150 }
mkarlsso 0:8dbd6bd9167f 4151 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4152 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4153 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4154 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4155 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4156 return NULL;
mkarlsso 0:8dbd6bd9167f 4157 } else {
mkarlsso 0:8dbd6bd9167f 4158 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4159 }
mkarlsso 0:8dbd6bd9167f 4160 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4161
mkarlsso 0:8dbd6bd9167f 4162 } else {
mkarlsso 0:8dbd6bd9167f 4163 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4164 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4165 return NULL;
mkarlsso 0:8dbd6bd9167f 4166 }
mkarlsso 0:8dbd6bd9167f 4167
mkarlsso 0:8dbd6bd9167f 4168
mkarlsso 0:8dbd6bd9167f 4169 } else if ((findStringLoc(expression,"random",stringInd2+1,lastCharLoc)!=-1) && isNum(expression,afterEqualLoc,stringInd2-1)) { //number +/- random
mkarlsso 0:8dbd6bd9167f 4170 int highVal = getRandomParam(expression,stringInd2+1,lastCharLoc);
mkarlsso 0:8dbd6bd9167f 4171
mkarlsso 0:8dbd6bd9167f 4172 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4173
mkarlsso 0:8dbd6bd9167f 4174
mkarlsso 0:8dbd6bd9167f 4175 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4176 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4177 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4178 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4179 return NULL;
mkarlsso 0:8dbd6bd9167f 4180 } else {
mkarlsso 0:8dbd6bd9167f 4181
mkarlsso 0:8dbd6bd9167f 4182 tmpOp2->setRandOp(highVal, multiplier, atoi(expression+afterEqualLoc),true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4183 }
mkarlsso 0:8dbd6bd9167f 4184 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4185 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4186 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4187 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4188 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4189 return NULL;
mkarlsso 0:8dbd6bd9167f 4190 } else {
mkarlsso 0:8dbd6bd9167f 4191 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4192 }
mkarlsso 0:8dbd6bd9167f 4193 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4194
mkarlsso 0:8dbd6bd9167f 4195 } else {
mkarlsso 0:8dbd6bd9167f 4196 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4197 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4198 return NULL;
mkarlsso 0:8dbd6bd9167f 4199 }
mkarlsso 0:8dbd6bd9167f 4200 } else if ((findStringLoc(expression,"random",stringInd2+1,lastCharLoc)!=-1) && (tmpVar2 != NULL)) { //variable +/- random
mkarlsso 0:8dbd6bd9167f 4201 int highVal = getRandomParam(expression,stringInd2+1,lastCharLoc);
mkarlsso 0:8dbd6bd9167f 4202
mkarlsso 0:8dbd6bd9167f 4203 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4204
mkarlsso 0:8dbd6bd9167f 4205
mkarlsso 0:8dbd6bd9167f 4206 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4207 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4208 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4209 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4210 return NULL;
mkarlsso 0:8dbd6bd9167f 4211 } else {
mkarlsso 0:8dbd6bd9167f 4212
mkarlsso 0:8dbd6bd9167f 4213 tmpOp2->setRandOp(highVal, multiplier, tmpVar2, true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4214 }
mkarlsso 0:8dbd6bd9167f 4215 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4216 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4217 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4218 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4219 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4220 return NULL;
mkarlsso 0:8dbd6bd9167f 4221 } else {
mkarlsso 0:8dbd6bd9167f 4222 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4223 }
mkarlsso 0:8dbd6bd9167f 4224 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4225
mkarlsso 0:8dbd6bd9167f 4226 } else {
mkarlsso 0:8dbd6bd9167f 4227 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4228 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4229 return NULL;
mkarlsso 0:8dbd6bd9167f 4230 }
mkarlsso 0:8dbd6bd9167f 4231 }
mkarlsso 0:8dbd6bd9167f 4232
mkarlsso 0:8dbd6bd9167f 4233
mkarlsso 0:8dbd6bd9167f 4234 else if ((findStringLoc(expression,"clock()",afterEqualLoc,stringInd2-1)!=-1) && isNum(expression,stringInd2+1,lastCharLoc)) { //clock() +/- number
mkarlsso 0:8dbd6bd9167f 4235
mkarlsso 0:8dbd6bd9167f 4236 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4237 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4238 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4239 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4240 return NULL;
mkarlsso 0:8dbd6bd9167f 4241 } else {
mkarlsso 0:8dbd6bd9167f 4242 tmpOp2->setClockOp(multiplier, atoi(expression+stringInd2+1),false);
mkarlsso 0:8dbd6bd9167f 4243 }
mkarlsso 0:8dbd6bd9167f 4244 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4245
mkarlsso 0:8dbd6bd9167f 4246 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4247 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4248 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4249 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4250 return NULL;
mkarlsso 0:8dbd6bd9167f 4251 } else {
mkarlsso 0:8dbd6bd9167f 4252 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4253 }
mkarlsso 0:8dbd6bd9167f 4254 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4255
mkarlsso 0:8dbd6bd9167f 4256
mkarlsso 0:8dbd6bd9167f 4257 } else if ((findStringLoc(expression,"clock()",afterEqualLoc,stringInd2-1)!=-1) && (tmpVar3 != NULL)) { //clock() +/- variable
mkarlsso 0:8dbd6bd9167f 4258
mkarlsso 0:8dbd6bd9167f 4259
mkarlsso 0:8dbd6bd9167f 4260
mkarlsso 0:8dbd6bd9167f 4261 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4262 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4263 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4264 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4265 return NULL;
mkarlsso 0:8dbd6bd9167f 4266 } else {
mkarlsso 0:8dbd6bd9167f 4267 tmpOp2->setClockOp(multiplier, tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4268 }
mkarlsso 0:8dbd6bd9167f 4269 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4270 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4271 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4272 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4273 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4274 return NULL;
mkarlsso 0:8dbd6bd9167f 4275 } else {
mkarlsso 0:8dbd6bd9167f 4276 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4277 }
mkarlsso 0:8dbd6bd9167f 4278 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4279
mkarlsso 0:8dbd6bd9167f 4280 } else if ((findStringLoc(expression,"clock()",stringInd2+1,lastCharLoc)!=-1) && isNum(expression,afterEqualLoc,lastCharLoc)) { //number +/- clock()
mkarlsso 0:8dbd6bd9167f 4281
mkarlsso 0:8dbd6bd9167f 4282 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4283 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4284 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4285 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4286 return NULL;
mkarlsso 0:8dbd6bd9167f 4287 } else {
mkarlsso 0:8dbd6bd9167f 4288
mkarlsso 0:8dbd6bd9167f 4289 tmpOp2->setClockOp(multiplier, atoi(expression+afterEqualLoc), true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4290 }
mkarlsso 0:8dbd6bd9167f 4291 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4292 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4293 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4294 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4295 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4296 return NULL;
mkarlsso 0:8dbd6bd9167f 4297 } else {
mkarlsso 0:8dbd6bd9167f 4298 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4299 }
mkarlsso 0:8dbd6bd9167f 4300 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4301
mkarlsso 0:8dbd6bd9167f 4302
mkarlsso 0:8dbd6bd9167f 4303 } else if ((findStringLoc(expression,"clock()",stringInd2+1,lastCharLoc)!=-1) && (tmpVar2 != NULL)) { //variable +/- clock()
mkarlsso 0:8dbd6bd9167f 4304
mkarlsso 0:8dbd6bd9167f 4305
mkarlsso 0:8dbd6bd9167f 4306 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4307 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4308 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4309 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4310 return NULL;
mkarlsso 0:8dbd6bd9167f 4311 } else {
mkarlsso 0:8dbd6bd9167f 4312
mkarlsso 0:8dbd6bd9167f 4313 tmpOp2->setClockOp(multiplier, tmpVar2, true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4314 }
mkarlsso 0:8dbd6bd9167f 4315 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4316 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4317 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4318 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4319 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4320 return NULL;
mkarlsso 0:8dbd6bd9167f 4321 } else {
mkarlsso 0:8dbd6bd9167f 4322 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4323 }
mkarlsso 0:8dbd6bd9167f 4324 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4325
mkarlsso 0:8dbd6bd9167f 4326
mkarlsso 0:8dbd6bd9167f 4327 }
mkarlsso 0:8dbd6bd9167f 4328
mkarlsso 0:8dbd6bd9167f 4329 else {
mkarlsso 0:8dbd6bd9167f 4330 textDisplay << "Expression not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 4331 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4332 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4333 return NULL;
mkarlsso 0:8dbd6bd9167f 4334 }
mkarlsso 0:8dbd6bd9167f 4335
mkarlsso 0:8dbd6bd9167f 4336 } else if (findIntVariable(expression,afterEqualLoc,lastCharLoc) != NULL) { //assign value of another variable
mkarlsso 0:8dbd6bd9167f 4337 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4338 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4339 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4340 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4341 return NULL;
mkarlsso 0:8dbd6bd9167f 4342 } else {
mkarlsso 0:8dbd6bd9167f 4343 tmpOp->set(tmpVar, "=", findIntVariable(expression,afterEqualLoc,lastCharLoc));
mkarlsso 0:8dbd6bd9167f 4344 }
mkarlsso 0:8dbd6bd9167f 4345 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4346
mkarlsso 0:8dbd6bd9167f 4347 } else {
mkarlsso 0:8dbd6bd9167f 4348 textDisplay << "Variable not found: " << expression+afterEqualLoc << "\r\n";
mkarlsso 0:8dbd6bd9167f 4349 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4350 return NULL;
mkarlsso 0:8dbd6bd9167f 4351 }
mkarlsso 0:8dbd6bd9167f 4352
mkarlsso 0:8dbd6bd9167f 4353 } else {
mkarlsso 0:8dbd6bd9167f 4354 textDisplay << "Variable not found\r\n";
mkarlsso 0:8dbd6bd9167f 4355 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4356 return NULL;
mkarlsso 0:8dbd6bd9167f 4357 }
mkarlsso 0:8dbd6bd9167f 4358 textDisplay.debug("Assignment successful\r\n");
mkarlsso 0:8dbd6bd9167f 4359 return tmpAction;
mkarlsso 0:8dbd6bd9167f 4360 }
mkarlsso 0:8dbd6bd9167f 4361
mkarlsso 0:8dbd6bd9167f 4362 action* scriptStream::evaluateAssignmentForAction(string expression) {
mkarlsso 0:8dbd6bd9167f 4363
mkarlsso 0:8dbd6bd9167f 4364 //action* tmpAction = new action(); //create a new action
mkarlsso 0:8dbd6bd9167f 4365 action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso 0:8dbd6bd9167f 4366 if (tmpAction == NULL) {
mkarlsso 0:8dbd6bd9167f 4367 textDisplay << "Error: no action memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4368 return NULL;
mkarlsso 0:8dbd6bd9167f 4369 }
mkarlsso 0:8dbd6bd9167f 4370 std::size_t stringInd;
mkarlsso 0:8dbd6bd9167f 4371 std::size_t stringInd2;
mkarlsso 0:8dbd6bd9167f 4372 string afterEqual;
mkarlsso 0:8dbd6bd9167f 4373 string beforeEqual;
mkarlsso 0:8dbd6bd9167f 4374 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 4375 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 4376 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 4377 int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 4378 stringInd = expression.find_first_of("="); //location of = sign, if it exists
mkarlsso 0:8dbd6bd9167f 4379 beforeEqual = expression.substr(0,stringInd); // the string after the = sign
mkarlsso 0:8dbd6bd9167f 4380 afterEqual = expression.substr(stringInd+1,std::string::npos); // the string after the = sign
mkarlsso 0:8dbd6bd9167f 4381 stringInd2 = afterEqual.find_first_of("+-"); //location of +/- sign (only one allowed)
mkarlsso 0:8dbd6bd9167f 4382 tmpVar = findIntVariable(expression.substr(0,stringInd)); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 4383
mkarlsso 0:8dbd6bd9167f 4384 if (beforeEqual.find("portout[") != std::string::npos) { //set the output of a digital port
mkarlsso 0:8dbd6bd9167f 4385 textDisplay.debug("Portout assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4386 int pos1 = beforeEqual.find("portout[")+8;
mkarlsso 0:8dbd6bd9167f 4387 int pos2 = beforeEqual.find_first_of("]",pos1);
mkarlsso 0:8dbd6bd9167f 4388 int portnum = atoi(beforeEqual.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 4389 int* tmpVar = findIntVariable(beforeEqual.substr(pos1,pos2-pos1)); //returns pointer to the variable, if given
mkarlsso 0:8dbd6bd9167f 4390 int portVal = 0;
mkarlsso 0:8dbd6bd9167f 4391 if ((tmpVar != NULL)||((portnum > 0) && (portnum <= numPorts))) {
mkarlsso 0:8dbd6bd9167f 4392 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 4393 portVal = atoi(afterEqual.data());
mkarlsso 0:8dbd6bd9167f 4394 if ((portVal == 0) || (portVal == 1)) {
mkarlsso 0:8dbd6bd9167f 4395 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 4396 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 4397 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 4398 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4399 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4400 return NULL;
mkarlsso 0:8dbd6bd9167f 4401 } else {
mkarlsso 0:8dbd6bd9167f 4402 //tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso 0:8dbd6bd9167f 4403 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 4404 tmpMessage->setMessage(NULL,portnum,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 4405 } else {
mkarlsso 0:8dbd6bd9167f 4406 tmpMessage->setMessage(tmpVar,0,portVal,portVector);
mkarlsso 0:8dbd6bd9167f 4407 }
mkarlsso 0:8dbd6bd9167f 4408 }
mkarlsso 0:8dbd6bd9167f 4409
mkarlsso 0:8dbd6bd9167f 4410
mkarlsso 0:8dbd6bd9167f 4411 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 4412
mkarlsso 0:8dbd6bd9167f 4413 } else {
mkarlsso 0:8dbd6bd9167f 4414 textDisplay << "Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 4415 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4416 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4417 return NULL;
mkarlsso 0:8dbd6bd9167f 4418 }
mkarlsso 0:8dbd6bd9167f 4419 } else if (afterEqual.compare("flip") == 0) {
mkarlsso 0:8dbd6bd9167f 4420 //portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 4421 portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso 0:8dbd6bd9167f 4422 if (tmpMessage == NULL) {
mkarlsso 0:8dbd6bd9167f 4423 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4424 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4425 return NULL;
mkarlsso 0:8dbd6bd9167f 4426 } else {
mkarlsso 0:8dbd6bd9167f 4427 //tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso 0:8dbd6bd9167f 4428 if (tmpVar == NULL) { //a constant port number was given
mkarlsso 0:8dbd6bd9167f 4429 tmpMessage->setMessage(NULL,portnum,-1,portVector);
mkarlsso 0:8dbd6bd9167f 4430 } else {
mkarlsso 0:8dbd6bd9167f 4431 tmpMessage->setMessage(tmpVar,0,-1,portVector);
mkarlsso 0:8dbd6bd9167f 4432 }
mkarlsso 0:8dbd6bd9167f 4433 }
mkarlsso 0:8dbd6bd9167f 4434 tmpAction->set(tmpMessage);
mkarlsso 0:8dbd6bd9167f 4435 } else {
mkarlsso 0:8dbd6bd9167f 4436 textDisplay << "Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n";
mkarlsso 0:8dbd6bd9167f 4437 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4438 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4439 return NULL;
mkarlsso 0:8dbd6bd9167f 4440 }
mkarlsso 0:8dbd6bd9167f 4441 } else {
mkarlsso 0:8dbd6bd9167f 4442 textDisplay << "Port number not found (must be between 1 and " << numPorts << " or an existing variable)\r\n";
mkarlsso 0:8dbd6bd9167f 4443 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4444 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4445 return NULL;
mkarlsso 0:8dbd6bd9167f 4446 }
mkarlsso 0:8dbd6bd9167f 4447 } else if (beforeEqual.find("portin") != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 4448 textDisplay << "Error: portins can not be set\r\n";
mkarlsso 0:8dbd6bd9167f 4449 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4450 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4451 return NULL;
mkarlsso 0:8dbd6bd9167f 4452 } else if (tmpVar != NULL) {
mkarlsso 0:8dbd6bd9167f 4453 intOperation* tmpOp;
mkarlsso 0:8dbd6bd9167f 4454 intOperation* tmpOp2;
mkarlsso 0:8dbd6bd9167f 4455 if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso 0:8dbd6bd9167f 4456 textDisplay.debug("Numeric assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4457 //tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 0:8dbd6bd9167f 4458 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4459 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4460 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4461 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4462 return NULL;
mkarlsso 0:8dbd6bd9167f 4463 } else {
mkarlsso 0:8dbd6bd9167f 4464 tmpOp->set(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso 0:8dbd6bd9167f 4465 }
mkarlsso 0:8dbd6bd9167f 4466 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4467
mkarlsso 0:8dbd6bd9167f 4468 } else if ((stringInd2 == std::string::npos)&&(afterEqual.find("random") != std::string::npos)) {
mkarlsso 0:8dbd6bd9167f 4469 //assign random number
mkarlsso 0:8dbd6bd9167f 4470 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 4471 textDisplay.debug("Random number assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4472 int highVal = getRandomParam(afterEqual);
mkarlsso 0:8dbd6bd9167f 4473
mkarlsso 0:8dbd6bd9167f 4474 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4475 //tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso 0:8dbd6bd9167f 4476 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4477 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4478 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4479 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4480 return NULL;
mkarlsso 0:8dbd6bd9167f 4481 } else {
mkarlsso 0:8dbd6bd9167f 4482 tmpOp->setRandOp(highVal, "=", tmpVar, false);
mkarlsso 0:8dbd6bd9167f 4483 }
mkarlsso 0:8dbd6bd9167f 4484 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4485
mkarlsso 0:8dbd6bd9167f 4486 } else {
mkarlsso 0:8dbd6bd9167f 4487 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4488 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4489 return NULL;
mkarlsso 0:8dbd6bd9167f 4490 }
mkarlsso 0:8dbd6bd9167f 4491 } else if ((stringInd2 == std::string::npos)&&(afterEqual.find("clock()") != std::string::npos)) {
mkarlsso 0:8dbd6bd9167f 4492 //assign clock value
mkarlsso 0:8dbd6bd9167f 4493 //no +/- detected, so its a simple assign
mkarlsso 0:8dbd6bd9167f 4494 textDisplay.debug("Clock assignment to variable\r\n");
mkarlsso 0:8dbd6bd9167f 4495 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4496 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4497 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4498 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4499 return NULL;
mkarlsso 0:8dbd6bd9167f 4500 } else {
mkarlsso 0:8dbd6bd9167f 4501 tmpOp->setClockOp(tmpVar); //assigns the current clock value to tmpVar
mkarlsso 0:8dbd6bd9167f 4502 }
mkarlsso 0:8dbd6bd9167f 4503 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4504
mkarlsso 0:8dbd6bd9167f 4505 } else if (stringInd2 != std::string::npos) { //a +/- operation is there
mkarlsso 0:8dbd6bd9167f 4506 textDisplay.debug("equation assignment\r\n");
mkarlsso 0:8dbd6bd9167f 4507 string multiplier("+");
mkarlsso 0:8dbd6bd9167f 4508 int multiplierInt = 1;
mkarlsso 0:8dbd6bd9167f 4509 if (afterEqual[stringInd2] == '-') {
mkarlsso 0:8dbd6bd9167f 4510 multiplier = "-";
mkarlsso 0:8dbd6bd9167f 4511 multiplierInt = -1;
mkarlsso 0:8dbd6bd9167f 4512 }
mkarlsso 0:8dbd6bd9167f 4513 tmpVar2 = findIntVariable(afterEqual.substr(0,stringInd2)); //before the +/- sign
mkarlsso 0:8dbd6bd9167f 4514 tmpVar3 = findIntVariable(afterEqual.substr(stringInd2+1,std::string::npos)); //after the +/- sign
mkarlsso 0:8dbd6bd9167f 4515
mkarlsso 0:8dbd6bd9167f 4516 if ((tmpVar2 != NULL) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //variable +/- number
mkarlsso 0:8dbd6bd9167f 4517 if (tmpVar2 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 4518 multiplier.append("="); //final sign is += or -=
mkarlsso 0:8dbd6bd9167f 4519 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 0:8dbd6bd9167f 4520 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4521 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4522 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4523 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4524 return NULL;
mkarlsso 0:8dbd6bd9167f 4525 } else {
mkarlsso 0:8dbd6bd9167f 4526 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 0:8dbd6bd9167f 4527 }
mkarlsso 0:8dbd6bd9167f 4528 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4529
mkarlsso 0:8dbd6bd9167f 4530 } else {
mkarlsso 0:8dbd6bd9167f 4531
mkarlsso 0:8dbd6bd9167f 4532 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4533 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4534 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4535 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4536 return NULL;
mkarlsso 0:8dbd6bd9167f 4537 } else {
mkarlsso 0:8dbd6bd9167f 4538
mkarlsso 0:8dbd6bd9167f 4539 tmpOp2->set(tmpVar2,multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso 0:8dbd6bd9167f 4540 //tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4541 }
mkarlsso 0:8dbd6bd9167f 4542
mkarlsso 0:8dbd6bd9167f 4543 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4544 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4545 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4546 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4547 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4548 return NULL;
mkarlsso 0:8dbd6bd9167f 4549 } else {
mkarlsso 0:8dbd6bd9167f 4550 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4551 }
mkarlsso 0:8dbd6bd9167f 4552
mkarlsso 0:8dbd6bd9167f 4553 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4554
mkarlsso 0:8dbd6bd9167f 4555 }
mkarlsso 0:8dbd6bd9167f 4556
mkarlsso 0:8dbd6bd9167f 4557 } else if ((tmpVar3 != NULL) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- variable
mkarlsso 0:8dbd6bd9167f 4558 if (tmpVar3 == tmpVar) {
mkarlsso 0:8dbd6bd9167f 4559 multiplier.append("="); //makes "+=" or "-="
mkarlsso 0:8dbd6bd9167f 4560 //tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 0:8dbd6bd9167f 4561 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4562 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4563 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4564 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4565 return NULL;
mkarlsso 0:8dbd6bd9167f 4566 } else {
mkarlsso 0:8dbd6bd9167f 4567 tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso 0:8dbd6bd9167f 4568 }
mkarlsso 0:8dbd6bd9167f 4569 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4570
mkarlsso 0:8dbd6bd9167f 4571 } else {
mkarlsso 0:8dbd6bd9167f 4572
mkarlsso 0:8dbd6bd9167f 4573 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4574 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4575 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4576 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4577 return NULL;
mkarlsso 0:8dbd6bd9167f 4578 } else {
mkarlsso 0:8dbd6bd9167f 4579 tmpOp2->set(tmpVar3, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso 0:8dbd6bd9167f 4580 }
mkarlsso 0:8dbd6bd9167f 4581 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4582
mkarlsso 0:8dbd6bd9167f 4583 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4584 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4585 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4586 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4587 return NULL;
mkarlsso 0:8dbd6bd9167f 4588 } else {
mkarlsso 0:8dbd6bd9167f 4589 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4590 }
mkarlsso 0:8dbd6bd9167f 4591 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4592
mkarlsso 0:8dbd6bd9167f 4593 }
mkarlsso 0:8dbd6bd9167f 4594
mkarlsso 0:8dbd6bd9167f 4595 } else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso 0:8dbd6bd9167f 4596
mkarlsso 0:8dbd6bd9167f 4597 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4598 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4599 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4600 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4601 return NULL;
mkarlsso 0:8dbd6bd9167f 4602 } else {
mkarlsso 0:8dbd6bd9167f 4603 tmpOp2->set(tmpVar2, multiplier.data(), tmpVar3);
mkarlsso 0:8dbd6bd9167f 4604 }
mkarlsso 0:8dbd6bd9167f 4605 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4606
mkarlsso 0:8dbd6bd9167f 4607 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4608 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4609 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4610 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4611 return NULL;
mkarlsso 0:8dbd6bd9167f 4612 } else {
mkarlsso 0:8dbd6bd9167f 4613
mkarlsso 0:8dbd6bd9167f 4614 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4615 }
mkarlsso 0:8dbd6bd9167f 4616 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4617
mkarlsso 0:8dbd6bd9167f 4618 } else if ( isNumber(afterEqual.substr(stringInd2+1,std::string::npos)) && isNumber(afterEqual.substr(0,stringInd2)) ) { //number +/- number
mkarlsso 0:8dbd6bd9167f 4619 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4620 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4621 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4622 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4623 return NULL;
mkarlsso 0:8dbd6bd9167f 4624 } else {
mkarlsso 0:8dbd6bd9167f 4625 tmpOp->set(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso 0:8dbd6bd9167f 4626 }
mkarlsso 0:8dbd6bd9167f 4627 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4628
mkarlsso 0:8dbd6bd9167f 4629 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //random +/- number
mkarlsso 0:8dbd6bd9167f 4630 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 0:8dbd6bd9167f 4631
mkarlsso 0:8dbd6bd9167f 4632 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4633
mkarlsso 0:8dbd6bd9167f 4634
mkarlsso 0:8dbd6bd9167f 4635 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4636 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4637 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4638 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4639 return NULL;
mkarlsso 0:8dbd6bd9167f 4640 } else {
mkarlsso 0:8dbd6bd9167f 4641 tmpOp2->setRandOp(highVal, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()),false);
mkarlsso 0:8dbd6bd9167f 4642 }
mkarlsso 0:8dbd6bd9167f 4643 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4644
mkarlsso 0:8dbd6bd9167f 4645 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4646 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4647 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4648 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4649 return NULL;
mkarlsso 0:8dbd6bd9167f 4650 } else {
mkarlsso 0:8dbd6bd9167f 4651 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4652 }
mkarlsso 0:8dbd6bd9167f 4653 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4654
mkarlsso 0:8dbd6bd9167f 4655 } else {
mkarlsso 0:8dbd6bd9167f 4656 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4657 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4658 return NULL;
mkarlsso 0:8dbd6bd9167f 4659 }
mkarlsso 0:8dbd6bd9167f 4660 } else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso 0:8dbd6bd9167f 4661 int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso 0:8dbd6bd9167f 4662
mkarlsso 0:8dbd6bd9167f 4663 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4664
mkarlsso 0:8dbd6bd9167f 4665
mkarlsso 0:8dbd6bd9167f 4666 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4667 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4668 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4669 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4670 return NULL;
mkarlsso 0:8dbd6bd9167f 4671 } else {
mkarlsso 0:8dbd6bd9167f 4672 tmpOp2->setRandOp(highVal, multiplier.data(), tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4673 }
mkarlsso 0:8dbd6bd9167f 4674 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4675 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4676 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4677 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4678 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4679 return NULL;
mkarlsso 0:8dbd6bd9167f 4680 } else {
mkarlsso 0:8dbd6bd9167f 4681 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4682 }
mkarlsso 0:8dbd6bd9167f 4683 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4684
mkarlsso 0:8dbd6bd9167f 4685 } else {
mkarlsso 0:8dbd6bd9167f 4686 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4687 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4688 return NULL;
mkarlsso 0:8dbd6bd9167f 4689 }
mkarlsso 0:8dbd6bd9167f 4690
mkarlsso 0:8dbd6bd9167f 4691
mkarlsso 0:8dbd6bd9167f 4692 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- random
mkarlsso 0:8dbd6bd9167f 4693 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 0:8dbd6bd9167f 4694
mkarlsso 0:8dbd6bd9167f 4695 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4696
mkarlsso 0:8dbd6bd9167f 4697
mkarlsso 0:8dbd6bd9167f 4698 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4699 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4700 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4701 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4702 return NULL;
mkarlsso 0:8dbd6bd9167f 4703 } else {
mkarlsso 0:8dbd6bd9167f 4704
mkarlsso 0:8dbd6bd9167f 4705 tmpOp2->setRandOp(highVal, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()),true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4706 }
mkarlsso 0:8dbd6bd9167f 4707 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4708 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4709 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4710 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4711 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4712 return NULL;
mkarlsso 0:8dbd6bd9167f 4713 } else {
mkarlsso 0:8dbd6bd9167f 4714 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4715 }
mkarlsso 0:8dbd6bd9167f 4716 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4717
mkarlsso 0:8dbd6bd9167f 4718 } else {
mkarlsso 0:8dbd6bd9167f 4719 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4720 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4721 return NULL;
mkarlsso 0:8dbd6bd9167f 4722 }
mkarlsso 0:8dbd6bd9167f 4723 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && (tmpVar2 != NULL)) { //variable +/- random
mkarlsso 0:8dbd6bd9167f 4724 int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso 0:8dbd6bd9167f 4725
mkarlsso 0:8dbd6bd9167f 4726 if (highVal > 0) {
mkarlsso 0:8dbd6bd9167f 4727
mkarlsso 0:8dbd6bd9167f 4728
mkarlsso 0:8dbd6bd9167f 4729 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4730 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4731 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4732 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4733 return NULL;
mkarlsso 0:8dbd6bd9167f 4734 } else {
mkarlsso 0:8dbd6bd9167f 4735
mkarlsso 0:8dbd6bd9167f 4736 tmpOp2->setRandOp(highVal, multiplier.data(), tmpVar2, true); //the "true" signifies that the rand value came last
mkarlsso 0:8dbd6bd9167f 4737 }
mkarlsso 0:8dbd6bd9167f 4738 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4739 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4740 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4741 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4742 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4743 return NULL;
mkarlsso 0:8dbd6bd9167f 4744 } else {
mkarlsso 0:8dbd6bd9167f 4745 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4746 }
mkarlsso 0:8dbd6bd9167f 4747 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4748
mkarlsso 0:8dbd6bd9167f 4749 } else {
mkarlsso 0:8dbd6bd9167f 4750 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4751 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4752 return NULL;
mkarlsso 0:8dbd6bd9167f 4753 }
mkarlsso 0:8dbd6bd9167f 4754 }
mkarlsso 0:8dbd6bd9167f 4755
mkarlsso 0:8dbd6bd9167f 4756
mkarlsso 0:8dbd6bd9167f 4757
mkarlsso 0:8dbd6bd9167f 4758
mkarlsso 0:8dbd6bd9167f 4759
mkarlsso 0:8dbd6bd9167f 4760 else if ((afterEqual.substr(0,stringInd2).find("clock()") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //clock() +/- number
mkarlsso 0:8dbd6bd9167f 4761
mkarlsso 0:8dbd6bd9167f 4762
mkarlsso 0:8dbd6bd9167f 4763
mkarlsso 0:8dbd6bd9167f 4764 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4765 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4766 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4767 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4768 return NULL;
mkarlsso 0:8dbd6bd9167f 4769 } else {
mkarlsso 0:8dbd6bd9167f 4770 tmpOp2->setClockOp(multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()),false);
mkarlsso 0:8dbd6bd9167f 4771 }
mkarlsso 0:8dbd6bd9167f 4772 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4773
mkarlsso 0:8dbd6bd9167f 4774 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4775 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4776 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4777 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4778 return NULL;
mkarlsso 0:8dbd6bd9167f 4779 } else {
mkarlsso 0:8dbd6bd9167f 4780 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4781 }
mkarlsso 0:8dbd6bd9167f 4782 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4783
mkarlsso 0:8dbd6bd9167f 4784
mkarlsso 0:8dbd6bd9167f 4785 } else if ((afterEqual.substr(0,stringInd2).find("clock()") != std::string::npos) && (tmpVar3 != NULL)) { //clock() +/- variable
mkarlsso 0:8dbd6bd9167f 4786
mkarlsso 0:8dbd6bd9167f 4787
mkarlsso 0:8dbd6bd9167f 4788
mkarlsso 0:8dbd6bd9167f 4789 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4790 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4791 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4792 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4793 return NULL;
mkarlsso 0:8dbd6bd9167f 4794 } else {
mkarlsso 0:8dbd6bd9167f 4795 tmpOp2->setClockOp(multiplier.data(), tmpVar3, false);
mkarlsso 0:8dbd6bd9167f 4796 }
mkarlsso 0:8dbd6bd9167f 4797 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4798 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4799 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4800 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4801 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4802 return NULL;
mkarlsso 0:8dbd6bd9167f 4803 } else {
mkarlsso 0:8dbd6bd9167f 4804 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4805 }
mkarlsso 0:8dbd6bd9167f 4806 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4807
mkarlsso 0:8dbd6bd9167f 4808
mkarlsso 0:8dbd6bd9167f 4809
mkarlsso 0:8dbd6bd9167f 4810
mkarlsso 0:8dbd6bd9167f 4811 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("clock()") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- clock()
mkarlsso 0:8dbd6bd9167f 4812
mkarlsso 0:8dbd6bd9167f 4813
mkarlsso 0:8dbd6bd9167f 4814
mkarlsso 0:8dbd6bd9167f 4815 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4816 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4817 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4818 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4819 return NULL;
mkarlsso 0:8dbd6bd9167f 4820 } else {
mkarlsso 0:8dbd6bd9167f 4821
mkarlsso 0:8dbd6bd9167f 4822 tmpOp2->setClockOp(multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()),true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4823 }
mkarlsso 0:8dbd6bd9167f 4824 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4825 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4826 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4827 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4828 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4829 return NULL;
mkarlsso 0:8dbd6bd9167f 4830 } else {
mkarlsso 0:8dbd6bd9167f 4831 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4832 }
mkarlsso 0:8dbd6bd9167f 4833 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4834
mkarlsso 0:8dbd6bd9167f 4835
mkarlsso 0:8dbd6bd9167f 4836 } else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("clock()") != std::string::npos) && (tmpVar2 != NULL)) { //variable +/- clock()
mkarlsso 0:8dbd6bd9167f 4837
mkarlsso 0:8dbd6bd9167f 4838
mkarlsso 0:8dbd6bd9167f 4839 tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4840 if (tmpOp2 == NULL) {
mkarlsso 0:8dbd6bd9167f 4841 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4842 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4843 return NULL;
mkarlsso 0:8dbd6bd9167f 4844 } else {
mkarlsso 0:8dbd6bd9167f 4845
mkarlsso 0:8dbd6bd9167f 4846 tmpOp2->setClockOp(multiplier.data(), tmpVar2, true); //the "true" signifies that clock() came last
mkarlsso 0:8dbd6bd9167f 4847 }
mkarlsso 0:8dbd6bd9167f 4848 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4849 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4850 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4851 tmpOp2->release();
mkarlsso 0:8dbd6bd9167f 4852 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4853 return NULL;
mkarlsso 0:8dbd6bd9167f 4854 } else {
mkarlsso 0:8dbd6bd9167f 4855 tmpOp->set(tmpVar, tmpOp2);
mkarlsso 0:8dbd6bd9167f 4856 }
mkarlsso 0:8dbd6bd9167f 4857 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4858
mkarlsso 0:8dbd6bd9167f 4859
mkarlsso 0:8dbd6bd9167f 4860 }
mkarlsso 0:8dbd6bd9167f 4861
mkarlsso 0:8dbd6bd9167f 4862 else {
mkarlsso 0:8dbd6bd9167f 4863 textDisplay << "Expression not understood: " << afterEqual << "\r\n";
mkarlsso 0:8dbd6bd9167f 4864 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4865 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4866 return NULL;
mkarlsso 0:8dbd6bd9167f 4867 }
mkarlsso 0:8dbd6bd9167f 4868
mkarlsso 0:8dbd6bd9167f 4869 } else if (findIntVariable(afterEqual) != NULL) { //assign value of another variable
mkarlsso 0:8dbd6bd9167f 4870 //tmpOp = new intOperation(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 0:8dbd6bd9167f 4871 tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso 0:8dbd6bd9167f 4872 if (tmpOp == NULL) {
mkarlsso 0:8dbd6bd9167f 4873 textDisplay << "Error: no memory slots available.\r\n";
mkarlsso 0:8dbd6bd9167f 4874 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4875 return NULL;
mkarlsso 0:8dbd6bd9167f 4876 } else {
mkarlsso 0:8dbd6bd9167f 4877 tmpOp->set(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso 0:8dbd6bd9167f 4878 }
mkarlsso 0:8dbd6bd9167f 4879 tmpAction->set(tmpOp);
mkarlsso 0:8dbd6bd9167f 4880
mkarlsso 0:8dbd6bd9167f 4881 } else {
mkarlsso 0:8dbd6bd9167f 4882 textDisplay << "Variable not found: " << afterEqual << "\r\n";
mkarlsso 0:8dbd6bd9167f 4883 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4884 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4885 return NULL;
mkarlsso 0:8dbd6bd9167f 4886 }
mkarlsso 0:8dbd6bd9167f 4887
mkarlsso 0:8dbd6bd9167f 4888 } else {
mkarlsso 0:8dbd6bd9167f 4889 textDisplay << "Variable not found\r\n";
mkarlsso 0:8dbd6bd9167f 4890 //delete tmpAction;
mkarlsso 0:8dbd6bd9167f 4891 tmpAction->release();
mkarlsso 0:8dbd6bd9167f 4892 return NULL;
mkarlsso 0:8dbd6bd9167f 4893 }
mkarlsso 0:8dbd6bd9167f 4894 textDisplay.debug("Assignment successful\r\n");
mkarlsso 0:8dbd6bd9167f 4895 return tmpAction;
mkarlsso 0:8dbd6bd9167f 4896 }
mkarlsso 0:8dbd6bd9167f 4897
mkarlsso 0:8dbd6bd9167f 4898 /*
mkarlsso 0:8dbd6bd9167f 4899 bool scriptStream::isOutsideParenth(string& expression,std::size_t foundItem) {
mkarlsso 0:8dbd6bd9167f 4900
mkarlsso 0:8dbd6bd9167f 4901 int pDepth = 0; // How many nested parentheses
mkarlsso 0:8dbd6bd9167f 4902
mkarlsso 0:8dbd6bd9167f 4903 if (foundItem < expression.length()) {
mkarlsso 0:8dbd6bd9167f 4904 for (int i = 0; i <= foundItem; i++) {
mkarlsso 0:8dbd6bd9167f 4905 if (expression[i] == '(') {
mkarlsso 0:8dbd6bd9167f 4906 pDepth++;
mkarlsso 0:8dbd6bd9167f 4907 } else if (expression[i] == ')') {
mkarlsso 0:8dbd6bd9167f 4908 pDepth--;
mkarlsso 0:8dbd6bd9167f 4909 }
mkarlsso 0:8dbd6bd9167f 4910 }
mkarlsso 0:8dbd6bd9167f 4911 if (pDepth<=0) {
mkarlsso 0:8dbd6bd9167f 4912
mkarlsso 0:8dbd6bd9167f 4913 return true;
mkarlsso 0:8dbd6bd9167f 4914 } else {
mkarlsso 0:8dbd6bd9167f 4915
mkarlsso 0:8dbd6bd9167f 4916 return false;
mkarlsso 0:8dbd6bd9167f 4917 }
mkarlsso 0:8dbd6bd9167f 4918 } else {
mkarlsso 0:8dbd6bd9167f 4919 return true;
mkarlsso 0:8dbd6bd9167f 4920 }
mkarlsso 0:8dbd6bd9167f 4921
mkarlsso 0:8dbd6bd9167f 4922 }
mkarlsso 0:8dbd6bd9167f 4923
mkarlsso 0:8dbd6bd9167f 4924 std::size_t scriptStream::findFirstOrOutsideParenth(string& expression) {
mkarlsso 0:8dbd6bd9167f 4925
mkarlsso 0:8dbd6bd9167f 4926 std::size_t foundItem = expression.find("||");
mkarlsso 0:8dbd6bd9167f 4927 while (foundItem != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 4928 if (isOutsideParenth(expression,foundItem)) {
mkarlsso 0:8dbd6bd9167f 4929 break;
mkarlsso 0:8dbd6bd9167f 4930 }
mkarlsso 0:8dbd6bd9167f 4931 foundItem = expression.find("||",foundItem+1);
mkarlsso 0:8dbd6bd9167f 4932 }
mkarlsso 0:8dbd6bd9167f 4933 return foundItem;
mkarlsso 0:8dbd6bd9167f 4934 }
mkarlsso 0:8dbd6bd9167f 4935
mkarlsso 0:8dbd6bd9167f 4936 std::size_t scriptStream::findFirstAndOutsideParenth(string& expression) {
mkarlsso 0:8dbd6bd9167f 4937
mkarlsso 0:8dbd6bd9167f 4938 std::size_t foundItem = expression.find("&&");
mkarlsso 0:8dbd6bd9167f 4939 while (foundItem != std::string::npos) {
mkarlsso 0:8dbd6bd9167f 4940 if (isOutsideParenth(expression,foundItem)){
mkarlsso 0:8dbd6bd9167f 4941 break;
mkarlsso 0:8dbd6bd9167f 4942 }
mkarlsso 0:8dbd6bd9167f 4943 foundItem = expression.find("&&",foundItem+1);
mkarlsso 0:8dbd6bd9167f 4944 }
mkarlsso 0:8dbd6bd9167f 4945 return foundItem;
mkarlsso 0:8dbd6bd9167f 4946 }
mkarlsso 0:8dbd6bd9167f 4947
mkarlsso 0:8dbd6bd9167f 4948 condition* scriptStream::parseConditions(string& expression) {
mkarlsso 0:8dbd6bd9167f 4949 //This function is used to parse a condition string
mkarlsso 0:8dbd6bd9167f 4950 //such as (x < y && x != z) || (y == 2)
mkarlsso 0:8dbd6bd9167f 4951 //This function first identifies the root node of the logic tree
mkarlsso 0:8dbd6bd9167f 4952 //based on operator precedence ( () > && > || ), and then recursively calls itself
mkarlsso 0:8dbd6bd9167f 4953 //to find the nodes of the branches. The basic building blocks of
mkarlsso 0:8dbd6bd9167f 4954 //the final condition object are arithmatic comparitors (a > b) and
mkarlsso 0:8dbd6bd9167f 4955 //other condition objects.
mkarlsso 0:8dbd6bd9167f 4956
mkarlsso 0:8dbd6bd9167f 4957
mkarlsso 0:8dbd6bd9167f 4958
mkarlsso 0:8dbd6bd9167f 4959 condition* newCondition = NULL;
mkarlsso 0:8dbd6bd9167f 4960 bool singleCondition = false; //no compound conditions
mkarlsso 0:8dbd6bd9167f 4961 string afterComparator;
mkarlsso 0:8dbd6bd9167f 4962 string beforeComparator;
mkarlsso 0:8dbd6bd9167f 4963
mkarlsso 0:8dbd6bd9167f 4964 std::size_t found;
mkarlsso 0:8dbd6bd9167f 4965
mkarlsso 0:8dbd6bd9167f 4966 //To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso 0:8dbd6bd9167f 4967 //so we look for OR conditions first
mkarlsso 0:8dbd6bd9167f 4968 char currentOperator = OR_CONDITION;
mkarlsso 0:8dbd6bd9167f 4969
mkarlsso 0:8dbd6bd9167f 4970 found = findFirstOrOutsideParenth(expression);
mkarlsso 0:8dbd6bd9167f 4971 if (found==std::string::npos) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso 0:8dbd6bd9167f 4972 currentOperator = AND_CONDITION;
mkarlsso 0:8dbd6bd9167f 4973
mkarlsso 0:8dbd6bd9167f 4974 found = findFirstAndOutsideParenth(expression);
mkarlsso 0:8dbd6bd9167f 4975 }
mkarlsso 0:8dbd6bd9167f 4976 if (found==std::string::npos) { //no or/and conditions outside parentheses found
mkarlsso 0:8dbd6bd9167f 4977 //if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso 0:8dbd6bd9167f 4978 bool removedParenth = false;
mkarlsso 0:8dbd6bd9167f 4979 if ((expression[0] == '(') && (expression[expression.length()-1] == ')')) {
mkarlsso 0:8dbd6bd9167f 4980
mkarlsso 0:8dbd6bd9167f 4981 expression = expression.substr(1,expression.length()-2);
mkarlsso 0:8dbd6bd9167f 4982 removedParenth = true;
mkarlsso 0:8dbd6bd9167f 4983 }
mkarlsso 0:8dbd6bd9167f 4984 if (removedParenth) { //we removed parentheses, so try again
mkarlsso 0:8dbd6bd9167f 4985 textDisplay.debug("Condition: parenth removed\r\n");
mkarlsso 0:8dbd6bd9167f 4986 return parseConditions(expression);
mkarlsso 0:8dbd6bd9167f 4987 } else {
mkarlsso 0:8dbd6bd9167f 4988 singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso 0:8dbd6bd9167f 4989 }
mkarlsso 0:8dbd6bd9167f 4990 }
mkarlsso 0:8dbd6bd9167f 4991
mkarlsso 0:8dbd6bd9167f 4992 if (singleCondition) { //no compound conditions found
mkarlsso 0:8dbd6bd9167f 4993 textDisplay.debug("Single condition: ");
mkarlsso 0:8dbd6bd9167f 4994 std::size_t equalStringInd;
mkarlsso 0:8dbd6bd9167f 4995 std::size_t greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 4996 std::size_t lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 4997 std::size_t notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 4998 std::size_t greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 4999 std::size_t lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5000 std::size_t generalCompareStringInd;
mkarlsso 0:8dbd6bd9167f 5001
mkarlsso 0:8dbd6bd9167f 5002
mkarlsso 0:8dbd6bd9167f 5003 string tmpCondition = expression;
mkarlsso 0:8dbd6bd9167f 5004 string compareString;
mkarlsso 0:8dbd6bd9167f 5005 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 5006 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 5007 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 5008 int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 5009
mkarlsso 0:8dbd6bd9167f 5010 int offset = 0;
mkarlsso 0:8dbd6bd9167f 5011 equalStringInd = tmpCondition.find("=="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5012 greaterOrEqualStringInd = tmpCondition.find(">="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5013 lessThanOrEqualStringInd = tmpCondition.find("<="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5014 notEqualStringInd = tmpCondition.find("!="); //location of comparator
mkarlsso 0:8dbd6bd9167f 5015 greaterThanStringInd = tmpCondition.find_first_of(">"); //location of comparator
mkarlsso 0:8dbd6bd9167f 5016 lessThanStringInd = tmpCondition.find_first_of("<"); //location of comparator
mkarlsso 0:8dbd6bd9167f 5017
mkarlsso 0:8dbd6bd9167f 5018 if ((equalStringInd != std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5019 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5020
mkarlsso 0:8dbd6bd9167f 5021 generalCompareStringInd = equalStringInd;
mkarlsso 0:8dbd6bd9167f 5022 compareString = "==";
mkarlsso 0:8dbd6bd9167f 5023 textDisplay.debug("==\r\n");
mkarlsso 0:8dbd6bd9167f 5024 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd != std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5025 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5026
mkarlsso 0:8dbd6bd9167f 5027 generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5028 compareString = ">=";
mkarlsso 0:8dbd6bd9167f 5029 textDisplay.debug(">=\r\n");
mkarlsso 0:8dbd6bd9167f 5030 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5031 (lessThanOrEqualStringInd != std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5032
mkarlsso 0:8dbd6bd9167f 5033 generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5034 compareString = "<=";
mkarlsso 0:8dbd6bd9167f 5035 textDisplay.debug("<=\r\n");
mkarlsso 0:8dbd6bd9167f 5036 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5037 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd != std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5038
mkarlsso 0:8dbd6bd9167f 5039 generalCompareStringInd = notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5040 compareString = "!=";
mkarlsso 0:8dbd6bd9167f 5041 textDisplay.debug("!=\r\n");
mkarlsso 0:8dbd6bd9167f 5042 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5043 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5044 (greaterThanStringInd != std::string::npos) && (lessThanStringInd == std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5045
mkarlsso 0:8dbd6bd9167f 5046 generalCompareStringInd = greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 5047 compareString = ">";
mkarlsso 0:8dbd6bd9167f 5048 offset = 1;
mkarlsso 0:8dbd6bd9167f 5049 textDisplay.debug(">\r\n");
mkarlsso 0:8dbd6bd9167f 5050 } else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5051 (lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso 0:8dbd6bd9167f 5052 (greaterThanStringInd == std::string::npos) && (lessThanStringInd != std::string::npos)){
mkarlsso 0:8dbd6bd9167f 5053
mkarlsso 0:8dbd6bd9167f 5054 generalCompareStringInd = lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5055 compareString = "<";
mkarlsso 0:8dbd6bd9167f 5056 offset = 1;
mkarlsso 0:8dbd6bd9167f 5057 textDisplay.debug("<\r\n");
mkarlsso 0:8dbd6bd9167f 5058
mkarlsso 0:8dbd6bd9167f 5059 }else {
mkarlsso 0:8dbd6bd9167f 5060 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5061 return 0;
mkarlsso 0:8dbd6bd9167f 5062 }
mkarlsso 0:8dbd6bd9167f 5063 textDisplay.debug("Allocating memory for condition...");
mkarlsso 0:8dbd6bd9167f 5064 intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso 0:8dbd6bd9167f 5065
mkarlsso 0:8dbd6bd9167f 5066 if (newCompare == NULL) {
mkarlsso 0:8dbd6bd9167f 5067 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5068 return NULL;
mkarlsso 0:8dbd6bd9167f 5069 }
mkarlsso 0:8dbd6bd9167f 5070 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5071 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5072 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5073 return NULL;
mkarlsso 0:8dbd6bd9167f 5074 }
mkarlsso 0:8dbd6bd9167f 5075 textDisplay.debug("success.\r\n");
mkarlsso 0:8dbd6bd9167f 5076 beforeComparator.reserve(tmpCondition.length());
mkarlsso 0:8dbd6bd9167f 5077 textDisplay << beforeComparator.capacity();
mkarlsso 0:8dbd6bd9167f 5078 textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 5079
mkarlsso 0:8dbd6bd9167f 5080 afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5081
mkarlsso 0:8dbd6bd9167f 5082 beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso 0:8dbd6bd9167f 5083
mkarlsso 0:8dbd6bd9167f 5084 tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5085 if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso 0:8dbd6bd9167f 5086 tmpVar2 = findIntVariable(afterComparator); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5087 if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso 0:8dbd6bd9167f 5088 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso 0:8dbd6bd9167f 5089 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5090 textDisplay.debug("Compare variable to variable\r\n");
mkarlsso 0:8dbd6bd9167f 5091 newCompare->set(tmpVar,compareString.data(),tmpVar2);
mkarlsso 0:8dbd6bd9167f 5092 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5093
mkarlsso 0:8dbd6bd9167f 5094
mkarlsso 0:8dbd6bd9167f 5095 } else if (isNumber(afterComparator)) {
mkarlsso 0:8dbd6bd9167f 5096 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 0:8dbd6bd9167f 5097 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5098 textDisplay.debug("Compare variable to number\r\n");
mkarlsso 0:8dbd6bd9167f 5099 newCompare->set(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 0:8dbd6bd9167f 5100 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5101
mkarlsso 0:8dbd6bd9167f 5102
mkarlsso 0:8dbd6bd9167f 5103 } //more here
mkarlsso 0:8dbd6bd9167f 5104
mkarlsso 0:8dbd6bd9167f 5105 } else {
mkarlsso 0:8dbd6bd9167f 5106 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5107
mkarlsso 0:8dbd6bd9167f 5108 return NULL;
mkarlsso 0:8dbd6bd9167f 5109 }
mkarlsso 0:8dbd6bd9167f 5110
mkarlsso 0:8dbd6bd9167f 5111 } else { //this is a compound condition (with either && or ||)
mkarlsso 0:8dbd6bd9167f 5112 textDisplay.debug("Compound condition\r\n");
mkarlsso 0:8dbd6bd9167f 5113 afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5114 beforeComparator = expression.substr(0,found);
mkarlsso 0:8dbd6bd9167f 5115 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5116 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5117 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5118 return NULL;
mkarlsso 0:8dbd6bd9167f 5119 } else {
mkarlsso 0:8dbd6bd9167f 5120 newCondition->isUsed = true; //reserve the condition slot;
mkarlsso 0:8dbd6bd9167f 5121 }
mkarlsso 0:8dbd6bd9167f 5122 //recursively call this function to parse the sub conditions
mkarlsso 0:8dbd6bd9167f 5123 condition* cond1 = parseConditions(beforeComparator);
mkarlsso 0:8dbd6bd9167f 5124 if (cond1 == NULL) {
mkarlsso 0:8dbd6bd9167f 5125 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5126 return NULL;
mkarlsso 0:8dbd6bd9167f 5127 }
mkarlsso 0:8dbd6bd9167f 5128 condition* cond2 = parseConditions(afterComparator);
mkarlsso 0:8dbd6bd9167f 5129 if (cond2 == NULL) {
mkarlsso 0:8dbd6bd9167f 5130 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5131 cond1->release();
mkarlsso 0:8dbd6bd9167f 5132 return NULL;
mkarlsso 0:8dbd6bd9167f 5133 }
mkarlsso 0:8dbd6bd9167f 5134 newCondition->set(cond1,currentOperator, cond2);
mkarlsso 0:8dbd6bd9167f 5135
mkarlsso 0:8dbd6bd9167f 5136 }
mkarlsso 0:8dbd6bd9167f 5137
mkarlsso 0:8dbd6bd9167f 5138 return newCondition; //all went well, so return the newly made condition
mkarlsso 0:8dbd6bd9167f 5139
mkarlsso 0:8dbd6bd9167f 5140 }*/
mkarlsso 0:8dbd6bd9167f 5141
mkarlsso 0:8dbd6bd9167f 5142
mkarlsso 0:8dbd6bd9167f 5143 bool scriptStream::isOutsideParenth(const char* expression,int foundItem,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5144
mkarlsso 0:8dbd6bd9167f 5145 int pDepth = 0; // How many nested parentheses
mkarlsso 0:8dbd6bd9167f 5146
mkarlsso 0:8dbd6bd9167f 5147 if ((foundItem >= start)&&(foundItem<=end)&&(foundItem < strlen(expression))&&(end < strlen(expression))&&(start <= end)&&(start>=0)) {
mkarlsso 0:8dbd6bd9167f 5148 for (int i = start; i <= foundItem; i++) {
mkarlsso 0:8dbd6bd9167f 5149 if (expression[i] == '(') {
mkarlsso 0:8dbd6bd9167f 5150 pDepth++;
mkarlsso 0:8dbd6bd9167f 5151 } else if (expression[i] == ')') {
mkarlsso 0:8dbd6bd9167f 5152 pDepth--;
mkarlsso 0:8dbd6bd9167f 5153 }
mkarlsso 0:8dbd6bd9167f 5154 }
mkarlsso 0:8dbd6bd9167f 5155 if (pDepth<=0) {
mkarlsso 0:8dbd6bd9167f 5156
mkarlsso 0:8dbd6bd9167f 5157 return true;
mkarlsso 0:8dbd6bd9167f 5158 } else {
mkarlsso 0:8dbd6bd9167f 5159
mkarlsso 0:8dbd6bd9167f 5160 return false;
mkarlsso 0:8dbd6bd9167f 5161 }
mkarlsso 0:8dbd6bd9167f 5162 } else {
mkarlsso 0:8dbd6bd9167f 5163 //error handling defaults in a true condition
mkarlsso 0:8dbd6bd9167f 5164 return true;
mkarlsso 0:8dbd6bd9167f 5165 }
mkarlsso 0:8dbd6bd9167f 5166
mkarlsso 0:8dbd6bd9167f 5167 }
mkarlsso 0:8dbd6bd9167f 5168
mkarlsso 0:8dbd6bd9167f 5169 int scriptStream::findFirstOrOutsideParenth(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5170
mkarlsso 0:8dbd6bd9167f 5171 int foundItem = findStringLoc(expression,"||",start,end);
mkarlsso 0:8dbd6bd9167f 5172 while (foundItem != -1) {
mkarlsso 0:8dbd6bd9167f 5173 if (isOutsideParenth(expression,foundItem,start,end)) {
mkarlsso 0:8dbd6bd9167f 5174 //it's out side of ()
mkarlsso 0:8dbd6bd9167f 5175 break;
mkarlsso 0:8dbd6bd9167f 5176 }
mkarlsso 0:8dbd6bd9167f 5177 //not outside ()
mkarlsso 0:8dbd6bd9167f 5178 foundItem = findStringLoc(expression,"||",foundItem+1,end);
mkarlsso 0:8dbd6bd9167f 5179 }
mkarlsso 0:8dbd6bd9167f 5180 return foundItem;
mkarlsso 0:8dbd6bd9167f 5181 }
mkarlsso 0:8dbd6bd9167f 5182
mkarlsso 0:8dbd6bd9167f 5183 int scriptStream::findFirstAndOutsideParenth(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5184
mkarlsso 0:8dbd6bd9167f 5185 int foundItem = findStringLoc(expression,"&&",start,end);
mkarlsso 0:8dbd6bd9167f 5186 while (foundItem != -1) {
mkarlsso 0:8dbd6bd9167f 5187 if (isOutsideParenth(expression,foundItem,start,end)){
mkarlsso 0:8dbd6bd9167f 5188 break;
mkarlsso 0:8dbd6bd9167f 5189 }
mkarlsso 0:8dbd6bd9167f 5190 foundItem = findStringLoc(expression,"||",foundItem+1,end);
mkarlsso 0:8dbd6bd9167f 5191 }
mkarlsso 0:8dbd6bd9167f 5192 return foundItem;
mkarlsso 0:8dbd6bd9167f 5193 }
mkarlsso 0:8dbd6bd9167f 5194
mkarlsso 0:8dbd6bd9167f 5195
mkarlsso 0:8dbd6bd9167f 5196 condition* scriptStream::parseConditions(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5197
mkarlsso 0:8dbd6bd9167f 5198
mkarlsso 0:8dbd6bd9167f 5199 //This function is used to parse a condition string
mkarlsso 0:8dbd6bd9167f 5200 //such as (x < y && x != z) || (y == 2)
mkarlsso 0:8dbd6bd9167f 5201 //This function first identifies the root node of the logic tree
mkarlsso 0:8dbd6bd9167f 5202 //based on operator precedence ( () > && > || ), and then recursively calls itself
mkarlsso 0:8dbd6bd9167f 5203 //to find the nodes of the branches. The basic building blocks of
mkarlsso 0:8dbd6bd9167f 5204 //the final condition object are arithmatic comparitors (a > b) and
mkarlsso 0:8dbd6bd9167f 5205 //other condition objects.
mkarlsso 0:8dbd6bd9167f 5206
mkarlsso 0:8dbd6bd9167f 5207
mkarlsso 0:8dbd6bd9167f 5208
mkarlsso 0:8dbd6bd9167f 5209 condition* newCondition = NULL;
mkarlsso 0:8dbd6bd9167f 5210 bool singleCondition = false; //no compound conditions
mkarlsso 0:8dbd6bd9167f 5211 //string afterComparator;
mkarlsso 0:8dbd6bd9167f 5212 //string beforeComparator;
mkarlsso 0:8dbd6bd9167f 5213 int afterComparatorLoc;
mkarlsso 0:8dbd6bd9167f 5214 int beforeComparatorLoc;
mkarlsso 0:8dbd6bd9167f 5215
mkarlsso 0:8dbd6bd9167f 5216
mkarlsso 0:8dbd6bd9167f 5217
mkarlsso 0:8dbd6bd9167f 5218 int found;
mkarlsso 0:8dbd6bd9167f 5219
mkarlsso 0:8dbd6bd9167f 5220 //To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso 0:8dbd6bd9167f 5221 //so we look for OR conditions first
mkarlsso 0:8dbd6bd9167f 5222 char currentOperator = OR_CONDITION;
mkarlsso 0:8dbd6bd9167f 5223
mkarlsso 0:8dbd6bd9167f 5224 found = findFirstOrOutsideParenth(expression,start,end);
mkarlsso 0:8dbd6bd9167f 5225 if (found==-1) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso 0:8dbd6bd9167f 5226 currentOperator = AND_CONDITION;
mkarlsso 0:8dbd6bd9167f 5227
mkarlsso 0:8dbd6bd9167f 5228 found = findFirstAndOutsideParenth(expression,start,end);
mkarlsso 0:8dbd6bd9167f 5229 }
mkarlsso 0:8dbd6bd9167f 5230 if (found==-1) { //no or/and conditions outside parentheses found
mkarlsso 0:8dbd6bd9167f 5231 //if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso 0:8dbd6bd9167f 5232 bool removedParenth = false;
mkarlsso 0:8dbd6bd9167f 5233 if ((expression[start] == '(') && (expression[end] == ')')) {
mkarlsso 0:8dbd6bd9167f 5234
mkarlsso 0:8dbd6bd9167f 5235 start++;
mkarlsso 0:8dbd6bd9167f 5236 end--;
mkarlsso 0:8dbd6bd9167f 5237
mkarlsso 0:8dbd6bd9167f 5238 //expression = expression.substr(1,expression.length()-2);
mkarlsso 0:8dbd6bd9167f 5239 removedParenth = true;
mkarlsso 0:8dbd6bd9167f 5240 }
mkarlsso 0:8dbd6bd9167f 5241 if (removedParenth) { //we removed parentheses, so try again
mkarlsso 0:8dbd6bd9167f 5242 textDisplay.debug("Condition: parenth removed\r\n");
mkarlsso 0:8dbd6bd9167f 5243 return parseConditions(expression,start,end);
mkarlsso 0:8dbd6bd9167f 5244 } else {
mkarlsso 0:8dbd6bd9167f 5245 singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso 0:8dbd6bd9167f 5246 }
mkarlsso 0:8dbd6bd9167f 5247 }
mkarlsso 0:8dbd6bd9167f 5248
mkarlsso 0:8dbd6bd9167f 5249 if (singleCondition) { //no compound conditions found
mkarlsso 0:8dbd6bd9167f 5250 textDisplay.debug("Single condition: ");
mkarlsso 0:8dbd6bd9167f 5251 int equalStringInd;
mkarlsso 0:8dbd6bd9167f 5252 int greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5253 int lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5254 int notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5255 int greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 5256 int lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5257 int generalCompareStringInd;
mkarlsso 0:8dbd6bd9167f 5258
mkarlsso 0:8dbd6bd9167f 5259
mkarlsso 0:8dbd6bd9167f 5260 //string tmpCondition = expression;
mkarlsso 0:8dbd6bd9167f 5261 char compareString[3];
mkarlsso 0:8dbd6bd9167f 5262 //The expression might have up to three variables
mkarlsso 0:8dbd6bd9167f 5263 int* tmpVar;
mkarlsso 0:8dbd6bd9167f 5264 int* tmpVar2;
mkarlsso 0:8dbd6bd9167f 5265 //int* tmpVar3;
mkarlsso 0:8dbd6bd9167f 5266
mkarlsso 0:8dbd6bd9167f 5267 int offset = 0;
mkarlsso 0:8dbd6bd9167f 5268 equalStringInd = findStringLoc(expression,"==",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5269 greaterOrEqualStringInd = findStringLoc(expression,">=",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5270 lessThanOrEqualStringInd = findStringLoc(expression,"<=",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5271 notEqualStringInd = findStringLoc(expression,"!=",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5272 greaterThanStringInd = findStringLoc(expression,">",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5273 lessThanStringInd = findStringLoc(expression,"<",start,end); //location of comparator
mkarlsso 0:8dbd6bd9167f 5274
mkarlsso 0:8dbd6bd9167f 5275 if ((equalStringInd != -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5276 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5277
mkarlsso 0:8dbd6bd9167f 5278 generalCompareStringInd = equalStringInd;
mkarlsso 0:8dbd6bd9167f 5279 strcpy(compareString,"==");
mkarlsso 0:8dbd6bd9167f 5280 //compareString = "==";
mkarlsso 0:8dbd6bd9167f 5281 textDisplay.debug("==\r\n");
mkarlsso 0:8dbd6bd9167f 5282 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd != -1) &&
mkarlsso 0:8dbd6bd9167f 5283 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5284
mkarlsso 0:8dbd6bd9167f 5285 generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5286 strcpy(compareString,">=");
mkarlsso 0:8dbd6bd9167f 5287 //compareString = ">=";
mkarlsso 0:8dbd6bd9167f 5288 textDisplay.debug(">=\r\n");
mkarlsso 0:8dbd6bd9167f 5289 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5290 (lessThanOrEqualStringInd != -1) && (notEqualStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5291
mkarlsso 0:8dbd6bd9167f 5292 generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5293 strcpy(compareString,"<=");
mkarlsso 0:8dbd6bd9167f 5294 //compareString = "<=";
mkarlsso 0:8dbd6bd9167f 5295 textDisplay.debug("<=\r\n");
mkarlsso 0:8dbd6bd9167f 5296 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5297 (lessThanOrEqualStringInd == -1) && (notEqualStringInd != -1)){
mkarlsso 0:8dbd6bd9167f 5298
mkarlsso 0:8dbd6bd9167f 5299 generalCompareStringInd = notEqualStringInd;
mkarlsso 0:8dbd6bd9167f 5300 strcpy(compareString,"!=");
mkarlsso 0:8dbd6bd9167f 5301 //compareString = "!=";
mkarlsso 0:8dbd6bd9167f 5302 textDisplay.debug("!=\r\n");
mkarlsso 0:8dbd6bd9167f 5303 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5304 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5305 (greaterThanStringInd != -1) && (lessThanStringInd == -1)){
mkarlsso 0:8dbd6bd9167f 5306
mkarlsso 0:8dbd6bd9167f 5307 generalCompareStringInd = greaterThanStringInd;
mkarlsso 0:8dbd6bd9167f 5308 strcpy(compareString,">");
mkarlsso 0:8dbd6bd9167f 5309 //compareString = ">";
mkarlsso 0:8dbd6bd9167f 5310 offset = 1;
mkarlsso 0:8dbd6bd9167f 5311 textDisplay.debug(">\r\n");
mkarlsso 0:8dbd6bd9167f 5312 } else if ((equalStringInd == -1) && (greaterOrEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5313 (lessThanOrEqualStringInd == -1) && (notEqualStringInd == -1) &&
mkarlsso 0:8dbd6bd9167f 5314 (greaterThanStringInd == -1) && (lessThanStringInd != -1)){
mkarlsso 0:8dbd6bd9167f 5315
mkarlsso 0:8dbd6bd9167f 5316 generalCompareStringInd = lessThanStringInd;
mkarlsso 0:8dbd6bd9167f 5317 strcpy(compareString,"<");
mkarlsso 0:8dbd6bd9167f 5318 //compareString = "<";
mkarlsso 0:8dbd6bd9167f 5319 offset = 1;
mkarlsso 0:8dbd6bd9167f 5320 textDisplay.debug("<\r\n");
mkarlsso 0:8dbd6bd9167f 5321
mkarlsso 0:8dbd6bd9167f 5322 }else {
mkarlsso 0:8dbd6bd9167f 5323 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5324 return 0;
mkarlsso 0:8dbd6bd9167f 5325 }
mkarlsso 0:8dbd6bd9167f 5326 textDisplay.debug("Allocating memory for condition...");
mkarlsso 0:8dbd6bd9167f 5327 intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso 0:8dbd6bd9167f 5328
mkarlsso 0:8dbd6bd9167f 5329 if (newCompare == NULL) {
mkarlsso 0:8dbd6bd9167f 5330 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5331 return NULL;
mkarlsso 0:8dbd6bd9167f 5332 }
mkarlsso 0:8dbd6bd9167f 5333 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5334 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5335 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5336 return NULL;
mkarlsso 0:8dbd6bd9167f 5337 }
mkarlsso 0:8dbd6bd9167f 5338 textDisplay.debug("success.\r\n");
mkarlsso 0:8dbd6bd9167f 5339 //beforeComparator.reserve(tmpCondition.length());
mkarlsso 0:8dbd6bd9167f 5340 //textDisplay << beforeComparator.capacity();
mkarlsso 0:8dbd6bd9167f 5341 //textDisplay.flush();
mkarlsso 0:8dbd6bd9167f 5342
mkarlsso 0:8dbd6bd9167f 5343 afterComparatorLoc = generalCompareStringInd+2-offset;
mkarlsso 0:8dbd6bd9167f 5344 beforeComparatorLoc = generalCompareStringInd-1;
mkarlsso 0:8dbd6bd9167f 5345
mkarlsso 0:8dbd6bd9167f 5346 //afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5347 //beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso 0:8dbd6bd9167f 5348
mkarlsso 0:8dbd6bd9167f 5349 //tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5350 tmpVar = findIntVariable(expression,start,beforeComparatorLoc);
mkarlsso 0:8dbd6bd9167f 5351
mkarlsso 0:8dbd6bd9167f 5352 if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso 0:8dbd6bd9167f 5353 tmpVar2 = findIntVariable(expression, afterComparatorLoc, end); //returns pointer to the variable
mkarlsso 0:8dbd6bd9167f 5354 if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso 0:8dbd6bd9167f 5355 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso 0:8dbd6bd9167f 5356 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5357 textDisplay.debug("Compare variable to variable\r\n");
mkarlsso 0:8dbd6bd9167f 5358 newCompare->set(tmpVar,compareString,tmpVar2);
mkarlsso 0:8dbd6bd9167f 5359 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5360
mkarlsso 0:8dbd6bd9167f 5361
mkarlsso 0:8dbd6bd9167f 5362 } else if (isNum(expression, afterComparatorLoc, end)) {
mkarlsso 0:8dbd6bd9167f 5363 //intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso 0:8dbd6bd9167f 5364 //currentEvent->addCondition(new condition(newCompare));
mkarlsso 0:8dbd6bd9167f 5365 textDisplay.debug("Compare variable to number\r\n");
mkarlsso 0:8dbd6bd9167f 5366 newCompare->set(tmpVar,compareString,atoi(expression+afterComparatorLoc));
mkarlsso 0:8dbd6bd9167f 5367 newCondition->set(newCompare);
mkarlsso 0:8dbd6bd9167f 5368
mkarlsso 0:8dbd6bd9167f 5369
mkarlsso 0:8dbd6bd9167f 5370 } else {
mkarlsso 0:8dbd6bd9167f 5371 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5372 return NULL;
mkarlsso 0:8dbd6bd9167f 5373 }//more here
mkarlsso 0:8dbd6bd9167f 5374
mkarlsso 0:8dbd6bd9167f 5375 } else {
mkarlsso 0:8dbd6bd9167f 5376 textDisplay << "Condition not understood: " << expression << "\r\n";
mkarlsso 0:8dbd6bd9167f 5377
mkarlsso 0:8dbd6bd9167f 5378 return NULL;
mkarlsso 0:8dbd6bd9167f 5379 }
mkarlsso 0:8dbd6bd9167f 5380
mkarlsso 0:8dbd6bd9167f 5381 } else { //this is a compound condition (with either && or ||)
mkarlsso 0:8dbd6bd9167f 5382 textDisplay.debug("Compound condition\r\n");
mkarlsso 0:8dbd6bd9167f 5383 afterComparatorLoc = found+2;
mkarlsso 0:8dbd6bd9167f 5384 beforeComparatorLoc = found-1;
mkarlsso 0:8dbd6bd9167f 5385 //afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso 0:8dbd6bd9167f 5386 //beforeComparator = expression.substr(0,found);
mkarlsso 0:8dbd6bd9167f 5387 newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso 0:8dbd6bd9167f 5388 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5389 textDisplay << "Error: No memory slots available.";
mkarlsso 0:8dbd6bd9167f 5390 return NULL;
mkarlsso 0:8dbd6bd9167f 5391 } else {
mkarlsso 0:8dbd6bd9167f 5392 newCondition->isUsed = true; //reserve the condition slot;
mkarlsso 0:8dbd6bd9167f 5393 }
mkarlsso 0:8dbd6bd9167f 5394 //recursively call this function to parse the sub conditions
mkarlsso 0:8dbd6bd9167f 5395 condition* cond1 = parseConditions(expression,start,beforeComparatorLoc);
mkarlsso 0:8dbd6bd9167f 5396 if (cond1 == NULL) {
mkarlsso 0:8dbd6bd9167f 5397 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5398 return NULL;
mkarlsso 0:8dbd6bd9167f 5399 }
mkarlsso 0:8dbd6bd9167f 5400 condition* cond2 = parseConditions(expression,afterComparatorLoc,end);
mkarlsso 0:8dbd6bd9167f 5401 if (cond2 == NULL) {
mkarlsso 0:8dbd6bd9167f 5402 newCondition->release();
mkarlsso 0:8dbd6bd9167f 5403 cond1->release();
mkarlsso 0:8dbd6bd9167f 5404 return NULL;
mkarlsso 0:8dbd6bd9167f 5405 }
mkarlsso 0:8dbd6bd9167f 5406 newCondition->set(cond1,currentOperator, cond2);
mkarlsso 0:8dbd6bd9167f 5407
mkarlsso 0:8dbd6bd9167f 5408 }
mkarlsso 0:8dbd6bd9167f 5409
mkarlsso 0:8dbd6bd9167f 5410 return newCondition; //all went well, so return the newly made condition
mkarlsso 0:8dbd6bd9167f 5411
mkarlsso 0:8dbd6bd9167f 5412
mkarlsso 0:8dbd6bd9167f 5413 }
mkarlsso 0:8dbd6bd9167f 5414
mkarlsso 0:8dbd6bd9167f 5415
mkarlsso 0:8dbd6bd9167f 5416
mkarlsso 0:8dbd6bd9167f 5417
mkarlsso 0:8dbd6bd9167f 5418 bool scriptStream::evaluateConditions(string& expression, event* currentEvent) {
mkarlsso 0:8dbd6bd9167f 5419 //calls the function to parse the condition string. The condition pointer is then
mkarlsso 0:8dbd6bd9167f 5420 //attached to the event
mkarlsso 0:8dbd6bd9167f 5421
mkarlsso 0:8dbd6bd9167f 5422 condition* newCondition = NULL;
mkarlsso 0:8dbd6bd9167f 5423 //newCondition = parseConditions(expression);
mkarlsso 0:8dbd6bd9167f 5424 newCondition = parseConditions(expression.data(),0,expression.length()-1);
mkarlsso 0:8dbd6bd9167f 5425 if (newCondition == NULL) {
mkarlsso 0:8dbd6bd9167f 5426 return false;
mkarlsso 0:8dbd6bd9167f 5427 } else {
mkarlsso 0:8dbd6bd9167f 5428 currentEvent->addCondition(newCondition);
mkarlsso 0:8dbd6bd9167f 5429 return true;
mkarlsso 0:8dbd6bd9167f 5430 }
mkarlsso 0:8dbd6bd9167f 5431 }
mkarlsso 0:8dbd6bd9167f 5432
mkarlsso 0:8dbd6bd9167f 5433 int scriptStream::getRandomParam(const char* expression,int start, int end) {
mkarlsso 0:8dbd6bd9167f 5434
mkarlsso 0:8dbd6bd9167f 5435 int pos1 = findStringLoc(expression,"random(",start,end)+7;
mkarlsso 0:8dbd6bd9167f 5436 int pos2 = findStringLoc(expression,")",pos1,end);
mkarlsso 0:8dbd6bd9167f 5437 if (pos2 == -1) {
mkarlsso 0:8dbd6bd9167f 5438 textDisplay << "Error: bad syntax\r\n";
mkarlsso 0:8dbd6bd9167f 5439 return 0;
mkarlsso 0:8dbd6bd9167f 5440 }
mkarlsso 0:8dbd6bd9167f 5441
mkarlsso 0:8dbd6bd9167f 5442 int highVal = atoi(expression+pos1);
mkarlsso 0:8dbd6bd9167f 5443
mkarlsso 0:8dbd6bd9167f 5444 if ((highVal > 0)) {
mkarlsso 0:8dbd6bd9167f 5445 return highVal;
mkarlsso 0:8dbd6bd9167f 5446 } else {
mkarlsso 0:8dbd6bd9167f 5447 textDisplay << "Error: random parameter must be 1 or more\r\n";
mkarlsso 0:8dbd6bd9167f 5448 return 0;
mkarlsso 0:8dbd6bd9167f 5449 }
mkarlsso 0:8dbd6bd9167f 5450 }
mkarlsso 0:8dbd6bd9167f 5451
mkarlsso 0:8dbd6bd9167f 5452 int scriptStream::getRandomParam(string expression) {
mkarlsso 0:8dbd6bd9167f 5453
mkarlsso 0:8dbd6bd9167f 5454 int pos1 = expression.find("random(")+7;
mkarlsso 0:8dbd6bd9167f 5455 int pos2 = expression.find_first_of(")",pos1);
mkarlsso 0:8dbd6bd9167f 5456 int highVal = atoi(expression.substr(pos1,pos2-pos1).data());
mkarlsso 0:8dbd6bd9167f 5457
mkarlsso 0:8dbd6bd9167f 5458 if ((highVal > 0)) {
mkarlsso 0:8dbd6bd9167f 5459 return highVal;
mkarlsso 0:8dbd6bd9167f 5460 } else {
mkarlsso 0:8dbd6bd9167f 5461 textDisplay << "Error: random parameter must be 1 or more\r\n";
mkarlsso 0:8dbd6bd9167f 5462 return 0;
mkarlsso 0:8dbd6bd9167f 5463 }
mkarlsso 0:8dbd6bd9167f 5464 }
mkarlsso 0:8dbd6bd9167f 5465
mkarlsso 0:8dbd6bd9167f 5466 int scriptStream::findStringLoc(const char *refString, const char *findString,int start,int end) {
mkarlsso 0:8dbd6bd9167f 5467 //look for 'findString' inside 'refString', only considering characters in between 'start' and 'end'
mkarlsso 0:8dbd6bd9167f 5468 //return -1 if not found
mkarlsso 0:8dbd6bd9167f 5469
mkarlsso 0:8dbd6bd9167f 5470 if ((start < strlen(refString))&&(end < strlen(refString))&&(end >= start)) {
mkarlsso 0:8dbd6bd9167f 5471 const char* charPtr = strstr(refString+start,findString);
mkarlsso 0:8dbd6bd9167f 5472 //if found, make sure it was containted within the start and end bounds
mkarlsso 0:8dbd6bd9167f 5473 if ((charPtr != NULL) && ((int)(charPtr-refString) <= (end-strlen(findString)+1))) {
mkarlsso 0:8dbd6bd9167f 5474 return (int)(charPtr-refString);
mkarlsso 0:8dbd6bd9167f 5475 }
mkarlsso 0:8dbd6bd9167f 5476 }
mkarlsso 0:8dbd6bd9167f 5477 return -1;
mkarlsso 0:8dbd6bd9167f 5478 }
mkarlsso 0:8dbd6bd9167f 5479
mkarlsso 0:8dbd6bd9167f 5480 bool scriptStream::isNum(const char *expression, int start, int end) {
mkarlsso 0:8dbd6bd9167f 5481
mkarlsso 0:8dbd6bd9167f 5482 if ((start>0)&&(end<strlen(expression))&&(start<=end)) {
mkarlsso 0:8dbd6bd9167f 5483
mkarlsso 0:8dbd6bd9167f 5484 bool outcome = true;
mkarlsso 0:8dbd6bd9167f 5485 while (start <= end) {
mkarlsso 0:8dbd6bd9167f 5486 //look for any digit, or a - sign
mkarlsso 0:8dbd6bd9167f 5487 if (!((expression[start] >= 45) && (expression[start] <= 57) && (expression[start] != 46) && (expression[start] != 47))) {
mkarlsso 0:8dbd6bd9167f 5488 outcome = false;
mkarlsso 0:8dbd6bd9167f 5489 break;
mkarlsso 0:8dbd6bd9167f 5490 }
mkarlsso 0:8dbd6bd9167f 5491 start++;
mkarlsso 0:8dbd6bd9167f 5492 }
mkarlsso 0:8dbd6bd9167f 5493 return outcome;
mkarlsso 0:8dbd6bd9167f 5494 }
mkarlsso 0:8dbd6bd9167f 5495 return false;
mkarlsso 0:8dbd6bd9167f 5496 }
mkarlsso 0:8dbd6bd9167f 5497
mkarlsso 0:8dbd6bd9167f 5498 bool scriptStream::areStringsSame(const char *str1, const char *str2, int start, int end) {
mkarlsso 0:8dbd6bd9167f 5499 if ((findStringLoc(str1,str2,start,end) != -1) && (strlen(str2)==(end-start+1))) {
mkarlsso 0:8dbd6bd9167f 5500 return true;
mkarlsso 0:8dbd6bd9167f 5501 } else {
mkarlsso 0:8dbd6bd9167f 5502 return false;
mkarlsso 0:8dbd6bd9167f 5503 }
mkarlsso 0:8dbd6bd9167f 5504
mkarlsso 0:8dbd6bd9167f 5505
mkarlsso 0:8dbd6bd9167f 5506 }
mkarlsso 0:8dbd6bd9167f 5507
mkarlsso 5:abee20c0bf2a 5508 void scriptStream::clearEnvironmentVariables(int clearMode) {
mkarlsso 5:abee20c0bf2a 5509 //Modes:
mkarlsso 5:abee20c0bf2a 5510
mkarlsso 5:abee20c0bf2a 5511 //clear callbacks, functions, and queue
mkarlsso 5:abee20c0bf2a 5512 if (clearMode & BLOCKMEMORYTYPES) {
mkarlsso 5:abee20c0bf2a 5513 for (int pNum = 0; pNum < NUMPORTS; pNum++) {
mkarlsso 5:abee20c0bf2a 5514 //delete portVector[pNum]->triggerUpEventPtr;
mkarlsso 5:abee20c0bf2a 5515 if (portVector[pNum].triggerUpEventPtr != NULL) {
mkarlsso 5:abee20c0bf2a 5516 portVector[pNum].triggerUpEventPtr->release();
mkarlsso 5:abee20c0bf2a 5517 }
mkarlsso 5:abee20c0bf2a 5518 portVector[pNum].triggerUpEventPtr = NULL;
mkarlsso 5:abee20c0bf2a 5519
mkarlsso 5:abee20c0bf2a 5520 //delete portVector[pNum]->triggerDownEventPtr;
mkarlsso 5:abee20c0bf2a 5521 if (portVector[pNum].triggerDownEventPtr != NULL) {
mkarlsso 5:abee20c0bf2a 5522 portVector[pNum].triggerDownEventPtr->release();
mkarlsso 5:abee20c0bf2a 5523 }
mkarlsso 5:abee20c0bf2a 5524 portVector[pNum].triggerDownEventPtr = NULL;
mkarlsso 5:abee20c0bf2a 5525
mkarlsso 5:abee20c0bf2a 5526 }
mkarlsso 5:abee20c0bf2a 5527 for (int i = 0; i < NUMFUNCTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5528 functionSpotTaken[i] = false;
mkarlsso 5:abee20c0bf2a 5529 functionEventArray[i] = NULL;
mkarlsso 5:abee20c0bf2a 5530 }
mkarlsso 5:abee20c0bf2a 5531 for (int i = 0; i < NUMEVENTS; i++) {
mkarlsso 5:abee20c0bf2a 5532 eventBlock[i].release();
mkarlsso 5:abee20c0bf2a 5533 }
mkarlsso 5:abee20c0bf2a 5534 for (int i = 0; i < NUMCONDITIONS; i++) {
mkarlsso 5:abee20c0bf2a 5535 conditionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5536 }
mkarlsso 5:abee20c0bf2a 5537 for (int i = 0; i < NUMINTCOMPARE; i++) {
mkarlsso 5:abee20c0bf2a 5538 intCompareBlock[i].release();
mkarlsso 5:abee20c0bf2a 5539 }
mkarlsso 5:abee20c0bf2a 5540 for (int i = 0; i < NUMACTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5541 actionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5542 }
mkarlsso 5:abee20c0bf2a 5543 for (int i = 0; i < NUMPORTMESSAGES; i++) {
mkarlsso 5:abee20c0bf2a 5544 portMessageBlock[i].release();
mkarlsso 5:abee20c0bf2a 5545 }
mkarlsso 5:abee20c0bf2a 5546 for (int i = 0; i < NUMINTOPERATIONS; i++) {
mkarlsso 5:abee20c0bf2a 5547 intOperationBlock[i].release();
mkarlsso 5:abee20c0bf2a 5548 }
mkarlsso 5:abee20c0bf2a 5549 for (int i = 0; i < NUMDISPLAYACTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5550 displayActionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5551 }
mkarlsso 5:abee20c0bf2a 5552 for (int i = 0; i <NUMTRIGGERACTIONS; i++) {
mkarlsso 5:abee20c0bf2a 5553 triggerFunctionActionBlock[i].release();
mkarlsso 5:abee20c0bf2a 5554 }
mkarlsso 5:abee20c0bf2a 5555
mkarlsso 5:abee20c0bf2a 5556 queuePtr->eraseQueue();
mkarlsso 5:abee20c0bf2a 5557 }
mkarlsso 5:abee20c0bf2a 5558
mkarlsso 5:abee20c0bf2a 5559 if (clearMode & VARIABLEMEMORYTYPES) {
mkarlsso 5:abee20c0bf2a 5560 while (!globalVariables.empty()) {
mkarlsso 5:abee20c0bf2a 5561 delete globalVariables.back();
mkarlsso 5:abee20c0bf2a 5562 globalVariables.pop_back();
mkarlsso 5:abee20c0bf2a 5563 }
mkarlsso 5:abee20c0bf2a 5564 }
mkarlsso 5:abee20c0bf2a 5565
mkarlsso 5:abee20c0bf2a 5566 if (clearMode & ENVSETTINGSMEMORYTYPES) {
mkarlsso 5:abee20c0bf2a 5567 //set all environment settings to default values
mkarlsso 5:abee20c0bf2a 5568 broadCastStateChanges = true;
mkarlsso 5:abee20c0bf2a 5569 for (int i=0;i<NUMPORTS;i++) {
mkarlsso 5:abee20c0bf2a 5570 system->setPortUpdatesOn(i);
mkarlsso 5:abee20c0bf2a 5571 }
mkarlsso 5:abee20c0bf2a 5572 }
mkarlsso 5:abee20c0bf2a 5573
mkarlsso 5:abee20c0bf2a 5574
mkarlsso 5:abee20c0bf2a 5575
mkarlsso 5:abee20c0bf2a 5576 }
mkarlsso 5:abee20c0bf2a 5577