Mattias Karlsson / Mbed 2 deprecated stateScript_v2

Microcontroller firmware that uses a simple, yet powerful scripting language to control the timing of input and output events with high temporal resolution. Written by Mattias Karlsson

Dependencies:   SMARTWAV mbed

behave.cpp@6:6a6761a47951, 2016-06-10 (annotated)

Committer:
mkarlsso
Date:
Fri Jun 10 21:22:34 2016 +0000
Revision:
6:6a6761a47951
Parent:
5:67d67d452545
Child:
7:5fe7329751d4
Fixed an issue where events were not being debounced properly.

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