Andy Lustig / Mbed 2 deprecated stateScript_v2

fork of StateScript

Dependencies:   mbed SOMO_II

Fork of stateScript_v2 by Mattias Karlsson

behave.cpp@10:f65649c13b5b, 2017-04-28 (annotated)

Committer:
alustig3
Date:
Fri Apr 28 14:47:55 2017 +0000
Revision:
10:f65649c13b5b
Parent:
9:f783bce314cd 
Code is now compatible with FRDM-K64F.; Replaced SMARTWAV with SOMO-II

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