Andy Lustig / Mbed 2 deprecated stateScript_v2_karpovalab

Karpova Lab fork of stateScript

Dependencies:   SMARTWAV SOMO_II mbed

Fork of stateScript_v2_karpova by Andy Lustig

behave.cpp@2:35266b266eaa, 2015-06-03 (annotated)

Committer:
mkarlsso
Date:
Wed Jun 03 23:41:16 2015 +0000
Revision:
2:35266b266eaa
Parent:
0:8dbd6bd9167f
Child:
3:d7b0a0890d96
Working version with proper interrupt pausing during dIn update

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