stateScript_v2 - Microcontroller firmware that uses a simple, yet …

Users » mkarlsso » Code » stateScript_v2

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@0:8dbd6bd9167f, 2015-05-19 (annotated)

Committer:: mkarlsso
Date:: Tue May 19 15:45:42 2015 +0000
Revision:: 0:8dbd6bd9167f
Child:: 1:3a050d26d4f6
Child:: 2:35266b266eaa

initial commit

Who changed what in which revision?

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

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	19 May 2015
Imports:	24
Forks:	2
Commits:	9
Dependents:	0
Dependencies:	2
Followers:	2

behave.cpp@0:8dbd6bd9167f, 2015-05-19 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning