Andy Lustig / Mbed 2 deprecated stateScript_v2

fork of StateScript

Dependencies:   mbed SOMO_II

Fork of stateScript_v2 by Mattias Karlsson

behave.cpp@9:f783bce314cd, 2017-04-26 (annotated)

Committer:
alustig3
Date:
Wed Apr 26 16:40:36 2017 +0000
Revision:
9:f783bce314cd
Parent:
8:872b843a3053
Child:
10:f65649c13b5b
synced with 99b7dc5 of bitbucket development branch

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