Mattias Karlsson / Mbed 2 deprecated stateScript_v2

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

Dependencies:   SMARTWAV mbed

behave.cpp@7:5fe7329751d4, 2017-02-07 (annotated)

Committer:
mkarlsso
Date:
Tue Feb 07 18:45:25 2017 +0000
Revision:
7:5fe7329751d4
Parent:
6:6a6761a47951
Child:
8:872b843a3053
Fixed flip command for digital outputs

Who changed what in which revision?

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