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@6:67d67d452545, 2016-01-21 (annotated)

Committer:
mkarlsso
Date:
Thu Jan 21 14:28:46 2016 +0000
Revision:
6:67d67d452545
Parent:
5:abee20c0bf2a
Child:
7:42aa1e804047
Fixed a small bug in the "trigger" command causing the program to think the chosen function index does not exist as the script is compiled.

Who changed what in which revision?

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