Mattias Karlsson / Mbed 2 deprecated stateScript_v2

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

Dependencies:   SMARTWAV mbed

behave.cpp@3:d7b0a0890d96, 2015-10-10 (annotated)

Committer:
mkarlsso
Date:
Sat Oct 10 22:37:17 2015 +0000
Revision:
3:d7b0a0890d96
Parent:
2:35266b266eaa
Child:
4:abee20c0bf2a
Changes ports for new PCB board

Who changed what in which revision?

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