stateScript - A scripting environment used to define precise ou…

Users » mkarlsso » Code » stateScript

Mattias Karlsson / Mbed 2 deprecated stateScript

A scripting environment used to define precise output/input temporal relationships.

Dependencies: SMARTWAV mbed HelloWorld

Dependents: perturbRoom_legacy

Fork of HelloWorld by Simon Ford

behave.cpp@3:ae33b7f5a7c1, 2014-07-19 (annotated)

Committer:: mkarlsso
Date:: Sat Jul 19 03:03:36 2014 +0000
Revision:: 3:ae33b7f5a7c1
Parent:: 2:298679fff37c
Child:: 4:34aca2142df9

fixed a = b+c bug

Who changed what in which revision?

User	Revision	Line number	New contents of line
mkarlsso	2:298679fff37c	1	#include "behave.h"
mkarlsso	2:298679fff37c	2	#include <ctype.h>
mkarlsso	2:298679fff37c	3	#include <sstream>
mkarlsso	2:298679fff37c	4
mkarlsso	2:298679fff37c	5	// These external symbols are maintained by the linker to indicate the
mkarlsso	2:298679fff37c	6	// location of various regions in the device's memory. They will be used by
mkarlsso	2:298679fff37c	7	// DisplayRAMBanks() to dump the size of each RAM bank to stdout.
mkarlsso	2:298679fff37c	8	extern unsigned int Image$$RW_IRAM1$$Base;
mkarlsso	2:298679fff37c	9	extern unsigned int Image$$RW_IRAM1$$ZI$$Limit;
mkarlsso	2:298679fff37c	10	extern unsigned int Image$$RW_IRAM2$$Base;
mkarlsso	2:298679fff37c	11	extern unsigned int Image$$RW_IRAM2$$ZI$$Limit;
mkarlsso	2:298679fff37c	12	extern unsigned int Image$$RW_IRAM3$$Base;
mkarlsso	2:298679fff37c	13	extern unsigned int Image$$RW_IRAM3$$ZI$$Limit;
mkarlsso	2:298679fff37c	14
mkarlsso	2:298679fff37c	15	uint32_t* globalTimeKeeperPtr; //this is a pointer to the slave timer (do not change this directly)
mkarlsso	2:298679fff37c	16	extern eventQueue mainQueue;
mkarlsso	2:298679fff37c	17	extern digitalPort* portVector[];
mkarlsso	2:298679fff37c	18
mkarlsso	2:298679fff37c	19	extern Serial pc;
mkarlsso	2:298679fff37c	20	extern bool resetTimer;
mkarlsso	2:298679fff37c	21	extern bool clockSlave;
mkarlsso	2:298679fff37c	22	extern bool changeToSlave;
mkarlsso	2:298679fff37c	23	extern bool changeToStandAlone;
mkarlsso	2:298679fff37c	24	extern outputStream textDisplay;
mkarlsso	2:298679fff37c	25	extern int currentDIOstate[2];
mkarlsso	2:298679fff37c	26	extern bool broadCastStateChanges;
mkarlsso	2:298679fff37c	27	extern bool textStreaming;
mkarlsso	2:298679fff37c	28
mkarlsso	2:298679fff37c	29
mkarlsso	2:298679fff37c	30	//static pools of memory for each object type
mkarlsso	2:298679fff37c	31	extern event eventBlock[NUMEVENTS];
mkarlsso	2:298679fff37c	32	extern condition conditionBlock[NUMCONDITIONS];
mkarlsso	2:298679fff37c	33	extern intCompare intCompareBlock[NUMINTCOMPARE];
mkarlsso	2:298679fff37c	34	extern action actionBlock[NUMACTIONS];
mkarlsso	2:298679fff37c	35	extern portMessage portMessageBlock[NUMPORTMESSAGES];
mkarlsso	2:298679fff37c	36	extern intOperation intOperationBlock[NUMINTOPERATIONS];
mkarlsso	2:298679fff37c	37	extern displayAction displayActionBlock[NUMDISPLAYACTIONS];
mkarlsso	2:298679fff37c	38
mkarlsso	2:298679fff37c	39	//used to find the first available object in the staticly defined pools of memory
mkarlsso	2:298679fff37c	40	template<class T> T* findFirstUnUsed(T a[], const int arrayLength) {
mkarlsso	2:298679fff37c	41
mkarlsso	2:298679fff37c	42	T* returnPtr = NULL;
mkarlsso	2:298679fff37c	43	for (int i = 0; i < arrayLength; i++) {
mkarlsso	2:298679fff37c	44	if (!a[i].isUsed) {
mkarlsso	2:298679fff37c	45	returnPtr = &a[i];
mkarlsso	2:298679fff37c	46	break;
mkarlsso	2:298679fff37c	47	}
mkarlsso	2:298679fff37c	48	}
mkarlsso	2:298679fff37c	49	return returnPtr;
mkarlsso	2:298679fff37c	50	}
mkarlsso	2:298679fff37c	51
mkarlsso	2:298679fff37c	52	//used to count the number of available objects in the memory pool
mkarlsso	2:298679fff37c	53	template<class T> int countUnUsed(T a[], const int arrayLength) {
mkarlsso	2:298679fff37c	54
mkarlsso	2:298679fff37c	55	int count = 0;
mkarlsso	2:298679fff37c	56	for (int i = 0; i < arrayLength; i++) {
mkarlsso	2:298679fff37c	57	if (!a[i].isUsed) {
mkarlsso	2:298679fff37c	58	count++;
mkarlsso	2:298679fff37c	59	}
mkarlsso	2:298679fff37c	60	}
mkarlsso	2:298679fff37c	61	return count;
mkarlsso	2:298679fff37c	62	}
mkarlsso	2:298679fff37c	63
mkarlsso	2:298679fff37c	64
mkarlsso	2:298679fff37c	65	void displayMemoryLeft(void) {
mkarlsso	2:298679fff37c	66	pc.printf("Available slots left in memory\r\n");
mkarlsso	2:298679fff37c	67	pc.printf(" Blocks: %d\r\n", countUnUsed(eventBlock, NUMEVENTS));
mkarlsso	2:298679fff37c	68	pc.printf(" Condition containers: %d\r\n", countUnUsed(conditionBlock, NUMCONDITIONS));
mkarlsso	2:298679fff37c	69	pc.printf(" Int compare conditions: %d\r\n", countUnUsed(intCompareBlock, NUMINTCOMPARE));
mkarlsso	2:298679fff37c	70	pc.printf(" Command containers: %d\r\n", countUnUsed(actionBlock, NUMACTIONS));
mkarlsso	2:298679fff37c	71	pc.printf(" Port commands: %d\r\n", countUnUsed(portMessageBlock, NUMPORTMESSAGES));
mkarlsso	2:298679fff37c	72	pc.printf(" Integer operater commands: %d\r\n", countUnUsed(intOperationBlock, NUMINTOPERATIONS));
mkarlsso	2:298679fff37c	73	pc.printf(" Text display commands: %d\r\n", countUnUsed(displayActionBlock, NUMDISPLAYACTIONS));
mkarlsso	2:298679fff37c	74	}
mkarlsso	2:298679fff37c	75
mkarlsso	2:298679fff37c	76	// Displays the size of static allocations for each RAM bank as indicated by
mkarlsso	2:298679fff37c	77	// ARM linker to stdout.
mkarlsso	2:298679fff37c	78	static void DisplayRAMBanks(void) {
mkarlsso	2:298679fff37c	79
mkarlsso	2:298679fff37c	80	pc.printf("Static RAM bank allocations\r\n");
mkarlsso	2:298679fff37c	81	pc.printf(" Main RAM = %u\r\n", (unsigned int)&Image$$RW_IRAM1$$ZI$$Limit -
mkarlsso	2:298679fff37c	82	(unsigned int)&Image$$RW_IRAM1$$Base);
mkarlsso	2:298679fff37c	83	pc.printf(" RAM0 = %u\r\n", (unsigned int)&Image$$RW_IRAM2$$ZI$$Limit -
mkarlsso	2:298679fff37c	84	(unsigned int)&Image$$RW_IRAM2$$Base);
mkarlsso	2:298679fff37c	85	pc.printf(" RAM1 = %u\r\n", (unsigned int)&Image$$RW_IRAM3$$ZI$$Limit -
mkarlsso	2:298679fff37c	86	(unsigned int)&Image$$RW_IRAM3$$Base);
mkarlsso	2:298679fff37c	87	}
mkarlsso	2:298679fff37c	88
mkarlsso	2:298679fff37c	89
mkarlsso	2:298679fff37c	90	bool isNumber(const std::string& s) {
mkarlsso	2:298679fff37c	91	std::string::const_iterator it = s.begin();
mkarlsso	2:298679fff37c	92	while (it != s.end() && isdigit(*it)) ++it;
mkarlsso	2:298679fff37c	93	return !s.empty() && it == s.end();
mkarlsso	2:298679fff37c	94	}
mkarlsso	2:298679fff37c	95
mkarlsso	2:298679fff37c	96	void tokenize(const string& str,
mkarlsso	2:298679fff37c	97	vector<string>& tokens,
mkarlsso	2:298679fff37c	98	const string& delimiters = " ")
mkarlsso	2:298679fff37c	99	{
mkarlsso	2:298679fff37c	100	// Skip delimiters at beginning.
mkarlsso	2:298679fff37c	101	string::size_type lastPos = str.find_first_not_of(delimiters, 0);
mkarlsso	2:298679fff37c	102	// Find first "non-delimiter".
mkarlsso	2:298679fff37c	103	string::size_type pos = str.find_first_of(delimiters, lastPos);
mkarlsso	2:298679fff37c	104
mkarlsso	2:298679fff37c	105	while (string::npos != pos \|\| string::npos != lastPos)
mkarlsso	2:298679fff37c	106	{
mkarlsso	2:298679fff37c	107	// Found a token, add it to the vector.
mkarlsso	2:298679fff37c	108	tokens.push_back(str.substr(lastPos, pos - lastPos));
mkarlsso	2:298679fff37c	109	// Skip delimiters. Note the "not_of"
mkarlsso	2:298679fff37c	110	lastPos = str.find_first_not_of(delimiters, pos);
mkarlsso	2:298679fff37c	111	// Find next "non-delimiter"
mkarlsso	2:298679fff37c	112	pos = str.find_first_of(delimiters, lastPos);
mkarlsso	2:298679fff37c	113	}
mkarlsso	2:298679fff37c	114	}
mkarlsso	2:298679fff37c	115
mkarlsso	2:298679fff37c	116
mkarlsso	2:298679fff37c	117	digitalPort::digitalPort(DigitalOut* DOP, DigitalIn* DIP):
mkarlsso	2:298679fff37c	118	outPin(DOP),
mkarlsso	2:298679fff37c	119	inPin(DIP),
mkarlsso	2:298679fff37c	120	outState(0){
mkarlsso	2:298679fff37c	121
mkarlsso	2:298679fff37c	122	lastInState = getDigitalIn();
mkarlsso	2:298679fff37c	123	inState = getDigitalIn();
mkarlsso	2:298679fff37c	124	lastChangeTime = 0;
mkarlsso	2:298679fff37c	125	lastOutChangeTime = 0;
mkarlsso	2:298679fff37c	126	lastChangeInterval = 0;
mkarlsso	2:298679fff37c	127	lastDownEvent.triggered = false;
mkarlsso	2:298679fff37c	128	lastUpEvent.triggered = false;
mkarlsso	2:298679fff37c	129	triggerUpEventPtr = NULL;
mkarlsso	2:298679fff37c	130	triggerDownEventPtr = NULL;
mkarlsso	2:298679fff37c	131	outStateChanged = false;
mkarlsso	2:298679fff37c	132	}
mkarlsso	2:298679fff37c	133
mkarlsso	2:298679fff37c	134	void digitalPort::setTriggerUpEvent(event* eventInput) {
mkarlsso	2:298679fff37c	135	if (triggerUpEventPtr != NULL) {
mkarlsso	2:298679fff37c	136	//delete triggerUpEventPtr;
mkarlsso	2:298679fff37c	137	triggerUpEventPtr->release();
mkarlsso	2:298679fff37c	138	}
mkarlsso	2:298679fff37c	139	triggerUpEventPtr = eventInput;
mkarlsso	2:298679fff37c	140	}
mkarlsso	2:298679fff37c	141
mkarlsso	2:298679fff37c	142	void digitalPort::setTriggerDownEvent(event* eventInput) {
mkarlsso	2:298679fff37c	143	if (triggerDownEventPtr != NULL) {
mkarlsso	2:298679fff37c	144	//delete triggerDownEventPtr;
mkarlsso	2:298679fff37c	145	triggerDownEventPtr->release();
mkarlsso	2:298679fff37c	146
mkarlsso	2:298679fff37c	147	}
mkarlsso	2:298679fff37c	148	triggerDownEventPtr = eventInput;
mkarlsso	2:298679fff37c	149	}
mkarlsso	2:298679fff37c	150
mkarlsso	2:298679fff37c	151
mkarlsso	2:298679fff37c	152	int digitalPort::getDigitalIn() {
mkarlsso	2:298679fff37c	153	return inPin->read();
mkarlsso	2:298679fff37c	154	}
mkarlsso	2:298679fff37c	155
mkarlsso	2:298679fff37c	156
mkarlsso	2:298679fff37c	157	void digitalPort::setDigitalOut(int outVal) {
mkarlsso	2:298679fff37c	158	if (outVal == -1) {
mkarlsso	2:298679fff37c	159	outVal = 1-outState;
mkarlsso	2:298679fff37c	160	}
mkarlsso	2:298679fff37c	161	outPin->write(outVal);
mkarlsso	2:298679fff37c	162	if (outState != outVal) {
mkarlsso	2:298679fff37c	163	outStateChanged = true;
mkarlsso	2:298679fff37c	164	lastOutChangeTime = *globalTimeKeeperPtr;
mkarlsso	2:298679fff37c	165	}
mkarlsso	2:298679fff37c	166	outState = outVal;
mkarlsso	2:298679fff37c	167	}
mkarlsso	2:298679fff37c	168
mkarlsso	2:298679fff37c	169	//called when a digital in gets triggered
mkarlsso	2:298679fff37c	170	void digitalPort::addStateChange(int newState, uint32_t timeStamp) {
mkarlsso	2:298679fff37c	171
mkarlsso	2:298679fff37c	172	if ((newState == 0) && (!lastDownEvent.triggered)){
mkarlsso	2:298679fff37c	173	lastDownEvent.timeStamp = timeStamp;
mkarlsso	2:298679fff37c	174	lastDownEvent.triggered = true;
mkarlsso	2:298679fff37c	175	} else if ((newState == 1) && (!lastUpEvent.triggered)) {
mkarlsso	2:298679fff37c	176	lastUpEvent.timeStamp = timeStamp;
mkarlsso	2:298679fff37c	177	lastUpEvent.triggered = true;
mkarlsso	2:298679fff37c	178	}
mkarlsso	2:298679fff37c	179	}
mkarlsso	2:298679fff37c	180
mkarlsso	2:298679fff37c	181	bool digitalPort::update() {
mkarlsso	2:298679fff37c	182
mkarlsso	2:298679fff37c	183	bool changed = false;
mkarlsso	2:298679fff37c	184	if ((*globalTimeKeeperPtr - lastChangeTime) > 1) { //prevents flutter triggers when button is pressed
mkarlsso	2:298679fff37c	185	inState = getDigitalIn();
mkarlsso	2:298679fff37c	186	changed = (lastInState != inState);
mkarlsso	2:298679fff37c	187	if (changed) {
mkarlsso	2:298679fff37c	188	if (inState == 1) {
mkarlsso	2:298679fff37c	189	if (lastUpEvent.triggered) {
mkarlsso	2:298679fff37c	190	//there were hardware triggered since the last main loop. We use that time
mkarlsso	2:298679fff37c	191	lastChangeInterval = lastUpEvent.timeStamp - lastChangeTime;
mkarlsso	2:298679fff37c	192	lastChangeTime = lastUpEvent.timeStamp;
mkarlsso	2:298679fff37c	193	} else {
mkarlsso	2:298679fff37c	194	//otherwise we use the current time
mkarlsso	2:298679fff37c	195	lastChangeInterval = *globalTimeKeeperPtr - lastChangeTime;
mkarlsso	2:298679fff37c	196	lastChangeTime = *globalTimeKeeperPtr;
mkarlsso	2:298679fff37c	197	}
mkarlsso	2:298679fff37c	198	if (triggerUpEventPtr != NULL) {triggerUpEventPtr->execute();}
mkarlsso	2:298679fff37c	199	} else if (inState == 0) {
mkarlsso	2:298679fff37c	200	if (lastDownEvent.triggered) {
mkarlsso	2:298679fff37c	201	lastChangeInterval = lastDownEvent.timeStamp - lastChangeTime;
mkarlsso	2:298679fff37c	202	lastChangeTime = lastDownEvent.timeStamp;
mkarlsso	2:298679fff37c	203	} else {
mkarlsso	2:298679fff37c	204	lastChangeInterval = *globalTimeKeeperPtr - lastChangeTime;
mkarlsso	2:298679fff37c	205	lastChangeTime = *globalTimeKeeperPtr;
mkarlsso	2:298679fff37c	206	}
mkarlsso	2:298679fff37c	207	if (triggerDownEventPtr != NULL) {triggerDownEventPtr->execute();}
mkarlsso	2:298679fff37c	208	}
mkarlsso	2:298679fff37c	209
mkarlsso	2:298679fff37c	210	}
mkarlsso	2:298679fff37c	211
mkarlsso	2:298679fff37c	212	lastInState = inState;
mkarlsso	2:298679fff37c	213
mkarlsso	2:298679fff37c	214	}
mkarlsso	2:298679fff37c	215	lastUpEvent.triggered = false;
mkarlsso	2:298679fff37c	216	lastDownEvent.triggered = false;
mkarlsso	2:298679fff37c	217	return changed;
mkarlsso	2:298679fff37c	218	}
mkarlsso	2:298679fff37c	219
mkarlsso	2:298679fff37c	220	int digitalPort::getLastChangeState() {
mkarlsso	2:298679fff37c	221	return lastInState;
mkarlsso	2:298679fff37c	222	}
mkarlsso	2:298679fff37c	223	uint32_t digitalPort::getTimeSinceLastChange() {
mkarlsso	2:298679fff37c	224	return lastChangeInterval;
mkarlsso	2:298679fff37c	225
mkarlsso	2:298679fff37c	226	}
mkarlsso	2:298679fff37c	227
mkarlsso	2:298679fff37c	228	intVariable::intVariable():
mkarlsso	2:298679fff37c	229	value(0),
mkarlsso	2:298679fff37c	230	tag(string("--------------------")) {
mkarlsso	2:298679fff37c	231	isUsed = false;
mkarlsso	2:298679fff37c	232	}
mkarlsso	2:298679fff37c	233
mkarlsso	2:298679fff37c	234	intVariable::intVariable(string tagInput, int initialValue):
mkarlsso	2:298679fff37c	235	value(initialValue),
mkarlsso	2:298679fff37c	236	tag(string(tagInput)) {
mkarlsso	2:298679fff37c	237	isUsed = true;
mkarlsso	2:298679fff37c	238	}
mkarlsso	2:298679fff37c	239
mkarlsso	2:298679fff37c	240	void intVariable::set(string tagInput, int initialValue) {
mkarlsso	2:298679fff37c	241	value = initialValue;
mkarlsso	2:298679fff37c	242	tag = string(tagInput);
mkarlsso	2:298679fff37c	243	isUsed = true;
mkarlsso	2:298679fff37c	244	}
mkarlsso	2:298679fff37c	245
mkarlsso	2:298679fff37c	246	displayAction::displayAction():
mkarlsso	2:298679fff37c	247	dText(string("--------------------------------------------------")),
mkarlsso	2:298679fff37c	248	pcPtr(NULL) {
mkarlsso	2:298679fff37c	249	dVariable = NULL;
mkarlsso	2:298679fff37c	250	isUsed = false;
mkarlsso	2:298679fff37c	251	}
mkarlsso	2:298679fff37c	252
mkarlsso	2:298679fff37c	253	void displayAction::release() {
mkarlsso	2:298679fff37c	254	dText = "--------------------------------------------------";
mkarlsso	2:298679fff37c	255	pcPtr = NULL;
mkarlsso	2:298679fff37c	256	dVariable = NULL;
mkarlsso	2:298679fff37c	257	isUsed = false;
mkarlsso	2:298679fff37c	258	}
mkarlsso	2:298679fff37c	259
mkarlsso	2:298679fff37c	260	displayAction::displayAction(int* variable, string varNameInput, Serial* pcPtrInput):
mkarlsso	2:298679fff37c	261	dVariable(variable),
mkarlsso	2:298679fff37c	262	dText(varNameInput),
mkarlsso	2:298679fff37c	263	pcPtr(pcPtrInput) {
mkarlsso	2:298679fff37c	264	isUsed = true;
mkarlsso	2:298679fff37c	265
mkarlsso	2:298679fff37c	266	}
mkarlsso	2:298679fff37c	267
mkarlsso	2:298679fff37c	268	displayAction::displayAction(string text, Serial* pcPtrInput):
mkarlsso	2:298679fff37c	269	dText(text),
mkarlsso	2:298679fff37c	270	pcPtr(pcPtrInput) {
mkarlsso	2:298679fff37c	271	dVariable = NULL;
mkarlsso	2:298679fff37c	272	isUsed = true;
mkarlsso	2:298679fff37c	273	}
mkarlsso	2:298679fff37c	274
mkarlsso	2:298679fff37c	275	void displayAction::set(int* variable, string varNameInput, Serial* pcPtrInput) {
mkarlsso	2:298679fff37c	276	dVariable = variable;
mkarlsso	2:298679fff37c	277	dText = varNameInput;
mkarlsso	2:298679fff37c	278	pcPtr = pcPtrInput;
mkarlsso	2:298679fff37c	279	isUsed = true;
mkarlsso	2:298679fff37c	280
mkarlsso	2:298679fff37c	281	}
mkarlsso	2:298679fff37c	282
mkarlsso	2:298679fff37c	283	void displayAction::set(string text, Serial* pcPtrInput) {
mkarlsso	2:298679fff37c	284	dText = text;
mkarlsso	2:298679fff37c	285	pcPtr = pcPtrInput;
mkarlsso	2:298679fff37c	286	dVariable = NULL;
mkarlsso	2:298679fff37c	287	isUsed = true;
mkarlsso	2:298679fff37c	288	}
mkarlsso	2:298679fff37c	289
mkarlsso	2:298679fff37c	290	void displayAction::execute() {
mkarlsso	2:298679fff37c	291
mkarlsso	2:298679fff37c	292	ostringstream convert; // stream used for the conversion
mkarlsso	2:298679fff37c	293	convert << *globalTimeKeeperPtr; // insert the textual representation of 'Number' in the characters in the stream
mkarlsso	2:298679fff37c	294
mkarlsso	2:298679fff37c	295	if (dVariable != NULL) {
mkarlsso	2:298679fff37c	296	ostringstream varConvert;
mkarlsso	2:298679fff37c	297	varConvert << *dVariable;
mkarlsso	2:298679fff37c	298	//pcPtr->printf("%d %s = %d\r\n",globalTimeKeeperPtr, dText.data(),dVariable);
mkarlsso	2:298679fff37c	299	textDisplay.send(convert.str() + " " + dText + " = " + varConvert.str() + "\r\n");
mkarlsso	2:298679fff37c	300	} else {
mkarlsso	2:298679fff37c	301	//pcPtr->printf("%d %s\r\n",*globalTimeKeeperPtr, dText.data());
mkarlsso	2:298679fff37c	302	textDisplay.send(convert.str() + " " + dText + "\r\n");
mkarlsso	2:298679fff37c	303
mkarlsso	2:298679fff37c	304	}
mkarlsso	2:298679fff37c	305	}
mkarlsso	2:298679fff37c	306
mkarlsso	2:298679fff37c	307	intCompare::intCompare():
mkarlsso	2:298679fff37c	308	port(NULL) {
mkarlsso	2:298679fff37c	309	cmpVal = NULL;
mkarlsso	2:298679fff37c	310	cmpValGlobal = false;
mkarlsso	2:298679fff37c	311	intVal = NULL;
mkarlsso	2:298679fff37c	312	intOp = NULL;
mkarlsso	2:298679fff37c	313	portValPtr = NULL;
mkarlsso	2:298679fff37c	314	isUsed = false;
mkarlsso	2:298679fff37c	315
mkarlsso	2:298679fff37c	316	}
mkarlsso	2:298679fff37c	317	intCompare::intCompare(digitalPort* portInput, const char* cmpString, int cmpValInput, int whichToUse):
mkarlsso	2:298679fff37c	318	port(portInput) {
mkarlsso	2:298679fff37c	319	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	320	cmpValGlobal = false;
mkarlsso	2:298679fff37c	321	intVal = NULL;
mkarlsso	2:298679fff37c	322	intOp = NULL;
mkarlsso	2:298679fff37c	323	setPointer(cmpString);
mkarlsso	2:298679fff37c	324	isUsed = true;
mkarlsso	2:298679fff37c	325	if (whichToUse == 1) {
mkarlsso	2:298679fff37c	326	portValPtr = &port->inState;
mkarlsso	2:298679fff37c	327	} else {
mkarlsso	2:298679fff37c	328	portValPtr = &port->outState;
mkarlsso	2:298679fff37c	329	}
mkarlsso	2:298679fff37c	330	}
mkarlsso	2:298679fff37c	331
mkarlsso	2:298679fff37c	332	intCompare::intCompare(digitalPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse):
mkarlsso	2:298679fff37c	333	port(portInput),
mkarlsso	2:298679fff37c	334	cmpVal(cmpIntVarInput) {
mkarlsso	2:298679fff37c	335	cmpValGlobal = true;
mkarlsso	2:298679fff37c	336	intVal = NULL;
mkarlsso	2:298679fff37c	337	intOp = NULL;
mkarlsso	2:298679fff37c	338	setPointer(cmpString);
mkarlsso	2:298679fff37c	339	isUsed = true;
mkarlsso	2:298679fff37c	340	if (whichToUse == 1) {
mkarlsso	2:298679fff37c	341	portValPtr = &port->inState;
mkarlsso	2:298679fff37c	342	} else {
mkarlsso	2:298679fff37c	343	portValPtr = &port->outState;
mkarlsso	2:298679fff37c	344	}
mkarlsso	2:298679fff37c	345	}
mkarlsso	2:298679fff37c	346
mkarlsso	2:298679fff37c	347	intCompare::intCompare(int* intVarInput, const char* cmpString, int* cmpIntVarInput):
mkarlsso	2:298679fff37c	348	cmpVal(cmpIntVarInput),
mkarlsso	2:298679fff37c	349	intVal(intVarInput) {
mkarlsso	2:298679fff37c	350	cmpValGlobal = true;
mkarlsso	2:298679fff37c	351	port = NULL;
mkarlsso	2:298679fff37c	352	intOp = NULL;
mkarlsso	2:298679fff37c	353	portValPtr = NULL;
mkarlsso	2:298679fff37c	354	isUsed = true;
mkarlsso	2:298679fff37c	355	setPointer(cmpString);
mkarlsso	2:298679fff37c	356	}
mkarlsso	2:298679fff37c	357
mkarlsso	2:298679fff37c	358	intCompare::intCompare(int* intVarInput, const char* cmpString, int cmpValInput):
mkarlsso	2:298679fff37c	359	intVal(intVarInput){
mkarlsso	2:298679fff37c	360	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	361	cmpValGlobal = false;
mkarlsso	2:298679fff37c	362	port = NULL;
mkarlsso	2:298679fff37c	363	intOp = NULL;
mkarlsso	2:298679fff37c	364	portValPtr = NULL;
mkarlsso	2:298679fff37c	365	isUsed = true;
mkarlsso	2:298679fff37c	366	setPointer(cmpString);
mkarlsso	2:298679fff37c	367	}
mkarlsso	2:298679fff37c	368
mkarlsso	2:298679fff37c	369	intCompare::intCompare(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput):
mkarlsso	2:298679fff37c	370	intVal(intVarInput) {
mkarlsso	2:298679fff37c	371	cmpVal = NULL;
mkarlsso	2:298679fff37c	372	port = NULL;
mkarlsso	2:298679fff37c	373	portValPtr = NULL;
mkarlsso	2:298679fff37c	374	cmpValGlobal = true;
mkarlsso	2:298679fff37c	375	intOp = cmpIntOpInput;
mkarlsso	2:298679fff37c	376	isUsed = true;
mkarlsso	2:298679fff37c	377	setPointer_operation(cmpString);
mkarlsso	2:298679fff37c	378	}
mkarlsso	2:298679fff37c	379
mkarlsso	2:298679fff37c	380	intCompare::intCompare(digitalPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse):
mkarlsso	2:298679fff37c	381	port(portInput) {
mkarlsso	2:298679fff37c	382	cmpVal = NULL;
mkarlsso	2:298679fff37c	383	intVal = NULL;
mkarlsso	2:298679fff37c	384	cmpValGlobal = true;
mkarlsso	2:298679fff37c	385	intOp = cmpIntOpInput;
mkarlsso	2:298679fff37c	386	setPointer_operation(cmpString);
mkarlsso	2:298679fff37c	387	isUsed = true;
mkarlsso	2:298679fff37c	388	if (whichToUse == 1) {
mkarlsso	2:298679fff37c	389	portValPtr = &port->inState;
mkarlsso	2:298679fff37c	390	} else {
mkarlsso	2:298679fff37c	391	portValPtr = &port->outState;
mkarlsso	2:298679fff37c	392	}
mkarlsso	2:298679fff37c	393	}
mkarlsso	2:298679fff37c	394
mkarlsso	2:298679fff37c	395
mkarlsso	2:298679fff37c	396
mkarlsso	2:298679fff37c	397	void intCompare::set(digitalPort* portInput, const char* cmpString, int cmpValInput, int whichToUse) {
mkarlsso	2:298679fff37c	398	port = portInput;
mkarlsso	2:298679fff37c	399	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	400	cmpValGlobal = false;
mkarlsso	2:298679fff37c	401	intVal = NULL;
mkarlsso	2:298679fff37c	402	intOp = NULL;
mkarlsso	2:298679fff37c	403	setPointer(cmpString);
mkarlsso	2:298679fff37c	404	isUsed = true;
mkarlsso	2:298679fff37c	405	if (whichToUse == 1) {
mkarlsso	2:298679fff37c	406	portValPtr = &port->inState;
mkarlsso	2:298679fff37c	407	} else {
mkarlsso	2:298679fff37c	408	portValPtr = &port->outState;
mkarlsso	2:298679fff37c	409	}
mkarlsso	2:298679fff37c	410	}
mkarlsso	2:298679fff37c	411
mkarlsso	2:298679fff37c	412	void intCompare::set(digitalPort* portInput, const char* cmpString, int* cmpIntVarInput, int whichToUse) {
mkarlsso	2:298679fff37c	413	port = portInput;
mkarlsso	2:298679fff37c	414	cmpVal = cmpIntVarInput;
mkarlsso	2:298679fff37c	415	cmpValGlobal = true;
mkarlsso	2:298679fff37c	416	intVal = NULL;
mkarlsso	2:298679fff37c	417	intOp = NULL;
mkarlsso	2:298679fff37c	418	setPointer(cmpString);
mkarlsso	2:298679fff37c	419	isUsed = true;
mkarlsso	2:298679fff37c	420	if (whichToUse == 1) {
mkarlsso	2:298679fff37c	421	portValPtr = &port->inState;
mkarlsso	2:298679fff37c	422	} else {
mkarlsso	2:298679fff37c	423	portValPtr = &port->outState;
mkarlsso	2:298679fff37c	424	}
mkarlsso	2:298679fff37c	425	}
mkarlsso	2:298679fff37c	426
mkarlsso	2:298679fff37c	427	void intCompare::set(int* intVarInput, const char* cmpString, int* cmpIntVarInput) {
mkarlsso	2:298679fff37c	428	cmpVal = cmpIntVarInput;
mkarlsso	2:298679fff37c	429	intVal = intVarInput;
mkarlsso	2:298679fff37c	430	cmpValGlobal = true;
mkarlsso	2:298679fff37c	431	port = NULL;
mkarlsso	2:298679fff37c	432	intOp = NULL;
mkarlsso	2:298679fff37c	433	portValPtr = NULL;
mkarlsso	2:298679fff37c	434	setPointer(cmpString);
mkarlsso	2:298679fff37c	435	isUsed = true;
mkarlsso	2:298679fff37c	436	}
mkarlsso	2:298679fff37c	437
mkarlsso	2:298679fff37c	438	void intCompare::set(int* intVarInput, const char* cmpString, int cmpValInput) {
mkarlsso	2:298679fff37c	439	intVal = intVarInput;
mkarlsso	2:298679fff37c	440	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	441	cmpValGlobal = false;
mkarlsso	2:298679fff37c	442	port = NULL;
mkarlsso	2:298679fff37c	443	intOp = NULL;
mkarlsso	2:298679fff37c	444	portValPtr = NULL;
mkarlsso	2:298679fff37c	445	setPointer(cmpString);
mkarlsso	2:298679fff37c	446	isUsed = true;
mkarlsso	2:298679fff37c	447	}
mkarlsso	2:298679fff37c	448
mkarlsso	2:298679fff37c	449	void intCompare::set(int* intVarInput, const char* cmpString, intOperation* cmpIntOpInput) {
mkarlsso	2:298679fff37c	450	intVal = intVarInput;
mkarlsso	2:298679fff37c	451	cmpVal = NULL;
mkarlsso	2:298679fff37c	452	port = NULL;
mkarlsso	2:298679fff37c	453	portValPtr = NULL;
mkarlsso	2:298679fff37c	454	cmpValGlobal = true;
mkarlsso	2:298679fff37c	455	intOp = cmpIntOpInput;
mkarlsso	2:298679fff37c	456	setPointer_operation(cmpString);
mkarlsso	2:298679fff37c	457	isUsed = true;
mkarlsso	2:298679fff37c	458	}
mkarlsso	2:298679fff37c	459
mkarlsso	2:298679fff37c	460	void intCompare::set(digitalPort* portInput, const char* cmpString, intOperation* cmpIntOpInput, int whichToUse) {
mkarlsso	2:298679fff37c	461	port = portInput;
mkarlsso	2:298679fff37c	462	cmpVal = NULL;
mkarlsso	2:298679fff37c	463	intVal = NULL;
mkarlsso	2:298679fff37c	464	cmpValGlobal = true;
mkarlsso	2:298679fff37c	465	intOp = cmpIntOpInput;
mkarlsso	2:298679fff37c	466	setPointer_operation(cmpString);
mkarlsso	2:298679fff37c	467	isUsed = true;
mkarlsso	2:298679fff37c	468	if (whichToUse == 1) {
mkarlsso	2:298679fff37c	469	portValPtr = &port->inState;
mkarlsso	2:298679fff37c	470	} else {
mkarlsso	2:298679fff37c	471	portValPtr = &port->outState;
mkarlsso	2:298679fff37c	472	}
mkarlsso	2:298679fff37c	473	}
mkarlsso	2:298679fff37c	474
mkarlsso	2:298679fff37c	475
mkarlsso	2:298679fff37c	476
mkarlsso	2:298679fff37c	477	intCompare::~intCompare() {
mkarlsso	2:298679fff37c	478	if (!cmpValGlobal) delete cmpVal; //we only delete the intCompare object if it was created locally
mkarlsso	2:298679fff37c	479	delete intOp;
mkarlsso	2:298679fff37c	480	}
mkarlsso	2:298679fff37c	481
mkarlsso	2:298679fff37c	482	void intCompare::release() {
mkarlsso	2:298679fff37c	483	if (!cmpValGlobal) delete cmpVal; //we only delete the intCompare object if it was created locally
mkarlsso	2:298679fff37c	484	if (intOp != NULL) {
mkarlsso	2:298679fff37c	485	intOp->release();
mkarlsso	2:298679fff37c	486	}
mkarlsso	2:298679fff37c	487	port = NULL;
mkarlsso	2:298679fff37c	488	cmpVal = NULL;
mkarlsso	2:298679fff37c	489	cmpValGlobal = false;
mkarlsso	2:298679fff37c	490	intVal = NULL;
mkarlsso	2:298679fff37c	491	intOp = NULL;
mkarlsso	2:298679fff37c	492	portValPtr = NULL;
mkarlsso	2:298679fff37c	493	isUsed = false;
mkarlsso	2:298679fff37c	494	}
mkarlsso	2:298679fff37c	495
mkarlsso	2:298679fff37c	496
mkarlsso	2:298679fff37c	497	void intCompare::setPointer(const char* cmpString) {
mkarlsso	2:298679fff37c	498	if (strcmp(cmpString, ">") == 0) {
mkarlsso	2:298679fff37c	499	isTruePtr = &intCompare::greaterThan;
mkarlsso	2:298679fff37c	500	}else if (strcmp(cmpString, ">=") == 0) {
mkarlsso	2:298679fff37c	501	isTruePtr = &intCompare::greaterOrEqual;
mkarlsso	2:298679fff37c	502	}else if (strcmp(cmpString, "<") == 0) {
mkarlsso	2:298679fff37c	503	isTruePtr = &intCompare::lessThan;
mkarlsso	2:298679fff37c	504	}else if (strcmp(cmpString, "<=") == 0) {
mkarlsso	2:298679fff37c	505	isTruePtr = &intCompare::lessOrEqual;
mkarlsso	2:298679fff37c	506	}else if (strcmp(cmpString, "==") == 0) {
mkarlsso	2:298679fff37c	507	isTruePtr = &intCompare::equal;
mkarlsso	2:298679fff37c	508	}else if (strcmp(cmpString, "!=") == 0) {
mkarlsso	2:298679fff37c	509	isTruePtr = &intCompare::notEqual;
mkarlsso	2:298679fff37c	510	}
mkarlsso	2:298679fff37c	511	}
mkarlsso	2:298679fff37c	512
mkarlsso	2:298679fff37c	513	void intCompare::setPointer_operation(const char* cmpString) {
mkarlsso	2:298679fff37c	514	if (strcmp(cmpString, ">") == 0) {
mkarlsso	2:298679fff37c	515	isTruePtr = &intCompare::greaterThan_op;
mkarlsso	2:298679fff37c	516	}else if (strcmp(cmpString, ">=") == 0) {
mkarlsso	2:298679fff37c	517	isTruePtr = &intCompare::greaterOrEqual_op;
mkarlsso	2:298679fff37c	518	}else if (strcmp(cmpString, "<") == 0) {
mkarlsso	2:298679fff37c	519	isTruePtr = &intCompare::lessThan_op;
mkarlsso	2:298679fff37c	520	}else if (strcmp(cmpString, "<=") == 0) {
mkarlsso	2:298679fff37c	521	isTruePtr = &intCompare::lessOrEqual_op;
mkarlsso	2:298679fff37c	522	}else if (strcmp(cmpString, "==") == 0) {
mkarlsso	2:298679fff37c	523	isTruePtr = &intCompare::equal_op;
mkarlsso	2:298679fff37c	524	}else if (strcmp(cmpString, "!=") == 0) {
mkarlsso	2:298679fff37c	525	isTruePtr = &intCompare::notEqual_op;
mkarlsso	2:298679fff37c	526	}
mkarlsso	2:298679fff37c	527	}
mkarlsso	2:298679fff37c	528
mkarlsso	2:298679fff37c	529	bool intCompare::isTrue() {
mkarlsso	2:298679fff37c	530	return (this->*isTruePtr)();
mkarlsso	2:298679fff37c	531
mkarlsso	2:298679fff37c	532	}
mkarlsso	2:298679fff37c	533
mkarlsso	2:298679fff37c	534	bool intCompare::notEqual() {
mkarlsso	2:298679fff37c	535	if (intVal != NULL) {
mkarlsso	2:298679fff37c	536	return (intVal != cmpVal);
mkarlsso	2:298679fff37c	537	} else {
mkarlsso	2:298679fff37c	538	return (portValPtr != cmpVal);
mkarlsso	2:298679fff37c	539	}
mkarlsso	2:298679fff37c	540	}
mkarlsso	2:298679fff37c	541
mkarlsso	2:298679fff37c	542	bool intCompare::greaterThan() {
mkarlsso	2:298679fff37c	543	if (intVal != NULL) {
mkarlsso	2:298679fff37c	544	return (intVal > cmpVal);
mkarlsso	2:298679fff37c	545	} else {
mkarlsso	2:298679fff37c	546	return (portValPtr > cmpVal);
mkarlsso	2:298679fff37c	547	}
mkarlsso	2:298679fff37c	548	}
mkarlsso	2:298679fff37c	549
mkarlsso	2:298679fff37c	550	bool intCompare::greaterOrEqual() {
mkarlsso	2:298679fff37c	551	if (intVal != NULL) {
mkarlsso	2:298679fff37c	552	return (intVal >= cmpVal);
mkarlsso	2:298679fff37c	553	} else {
mkarlsso	2:298679fff37c	554	return (portValPtr >= cmpVal);
mkarlsso	2:298679fff37c	555	}
mkarlsso	2:298679fff37c	556	}
mkarlsso	2:298679fff37c	557
mkarlsso	2:298679fff37c	558	bool intCompare::lessThan() {
mkarlsso	2:298679fff37c	559	if (intVal != NULL) {
mkarlsso	2:298679fff37c	560	return (intVal < cmpVal);
mkarlsso	2:298679fff37c	561	} else {
mkarlsso	2:298679fff37c	562	return (portValPtr < cmpVal);
mkarlsso	2:298679fff37c	563	}
mkarlsso	2:298679fff37c	564	}
mkarlsso	2:298679fff37c	565
mkarlsso	2:298679fff37c	566	bool intCompare::lessOrEqual() {
mkarlsso	2:298679fff37c	567	if (intVal != NULL) {
mkarlsso	2:298679fff37c	568	return (intVal <= cmpVal);
mkarlsso	2:298679fff37c	569	} else {
mkarlsso	2:298679fff37c	570	return (portValPtr <= cmpVal);
mkarlsso	2:298679fff37c	571	}
mkarlsso	2:298679fff37c	572	}
mkarlsso	2:298679fff37c	573
mkarlsso	2:298679fff37c	574	bool intCompare::equal() {
mkarlsso	2:298679fff37c	575	if (intVal != NULL) {
mkarlsso	2:298679fff37c	576	return (intVal == cmpVal);
mkarlsso	2:298679fff37c	577	} else {
mkarlsso	2:298679fff37c	578	return (portValPtr == cmpVal);
mkarlsso	2:298679fff37c	579	}
mkarlsso	2:298679fff37c	580	}
mkarlsso	2:298679fff37c	581
mkarlsso	2:298679fff37c	582	bool intCompare::notEqual_op() {
mkarlsso	2:298679fff37c	583	if (intVal != NULL) {
mkarlsso	2:298679fff37c	584	return (*intVal != intOp->execute());
mkarlsso	2:298679fff37c	585	} else {
mkarlsso	2:298679fff37c	586	return (*portValPtr != intOp->execute());
mkarlsso	2:298679fff37c	587	}
mkarlsso	2:298679fff37c	588	}
mkarlsso	2:298679fff37c	589
mkarlsso	2:298679fff37c	590	bool intCompare::greaterThan_op() {
mkarlsso	2:298679fff37c	591	if (intVal != NULL) {
mkarlsso	2:298679fff37c	592	return (*intVal > intOp->execute());
mkarlsso	2:298679fff37c	593	} else {
mkarlsso	2:298679fff37c	594	return (*portValPtr > intOp->execute());
mkarlsso	2:298679fff37c	595	}
mkarlsso	2:298679fff37c	596	}
mkarlsso	2:298679fff37c	597
mkarlsso	2:298679fff37c	598	bool intCompare::greaterOrEqual_op() {
mkarlsso	2:298679fff37c	599	if (intVal != NULL) {
mkarlsso	2:298679fff37c	600	return (*intVal >= intOp->execute());
mkarlsso	2:298679fff37c	601	} else {
mkarlsso	2:298679fff37c	602	return (*portValPtr >= intOp->execute());
mkarlsso	2:298679fff37c	603	}
mkarlsso	2:298679fff37c	604	}
mkarlsso	2:298679fff37c	605
mkarlsso	2:298679fff37c	606	bool intCompare::lessThan_op() {
mkarlsso	2:298679fff37c	607	if (intVal != NULL) {
mkarlsso	2:298679fff37c	608	return (*intVal < intOp->execute());
mkarlsso	2:298679fff37c	609	} else {
mkarlsso	2:298679fff37c	610	return (*portValPtr < intOp->execute());
mkarlsso	2:298679fff37c	611	}
mkarlsso	2:298679fff37c	612	}
mkarlsso	2:298679fff37c	613
mkarlsso	2:298679fff37c	614	bool intCompare::lessOrEqual_op() {
mkarlsso	2:298679fff37c	615	if (intVal != NULL) {
mkarlsso	2:298679fff37c	616	return (*intVal <= intOp->execute());
mkarlsso	2:298679fff37c	617	} else {
mkarlsso	2:298679fff37c	618	return (*portValPtr <= intOp->execute());
mkarlsso	2:298679fff37c	619	}
mkarlsso	2:298679fff37c	620	}
mkarlsso	2:298679fff37c	621
mkarlsso	2:298679fff37c	622	bool intCompare::equal_op() {
mkarlsso	2:298679fff37c	623	if (intVal != NULL) {
mkarlsso	2:298679fff37c	624	return (*intVal == intOp->execute());
mkarlsso	2:298679fff37c	625	} else {
mkarlsso	2:298679fff37c	626	return (*portValPtr == intOp->execute());
mkarlsso	2:298679fff37c	627	}
mkarlsso	2:298679fff37c	628	}
mkarlsso	2:298679fff37c	629
mkarlsso	2:298679fff37c	630	intOperation::intOperation():
mkarlsso	2:298679fff37c	631	randHigh(-1) {
mkarlsso	2:298679fff37c	632	cmpVal = NULL;
mkarlsso	2:298679fff37c	633	intVal = NULL;
mkarlsso	2:298679fff37c	634	opPtr = NULL;
mkarlsso	2:298679fff37c	635	executePtr = NULL;
mkarlsso	2:298679fff37c	636	cmpValGlobal = false;
mkarlsso	2:298679fff37c	637	isUsed = false;
mkarlsso	2:298679fff37c	638
mkarlsso	2:298679fff37c	639	}
mkarlsso	2:298679fff37c	640
mkarlsso	2:298679fff37c	641	intOperation::intOperation(int randParam, const char* cmpString, int cmpValInput):
mkarlsso	2:298679fff37c	642	randHigh(randParam) {
mkarlsso	2:298679fff37c	643	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	644	intVal = NULL;
mkarlsso	2:298679fff37c	645	opPtr = NULL;
mkarlsso	2:298679fff37c	646	cmpValGlobal = false;
mkarlsso	2:298679fff37c	647	isUsed = true;
mkarlsso	2:298679fff37c	648	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	649	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	650	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	651	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	652	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	653	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	654	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	655	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	656	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	657	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	658	}
mkarlsso	2:298679fff37c	659
mkarlsso	2:298679fff37c	660	}
mkarlsso	2:298679fff37c	661
mkarlsso	2:298679fff37c	662	intOperation::intOperation(int randParam, const char* cmpString, int* cmpIntVarInput):
mkarlsso	2:298679fff37c	663	randHigh(randParam),
mkarlsso	2:298679fff37c	664	cmpVal(cmpIntVarInput) {
mkarlsso	2:298679fff37c	665	intVal = NULL;
mkarlsso	2:298679fff37c	666	opPtr = NULL;
mkarlsso	2:298679fff37c	667	cmpValGlobal = true;
mkarlsso	2:298679fff37c	668	isUsed = true;
mkarlsso	2:298679fff37c	669	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	670	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	671	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	672	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	673	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	674	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	675	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	676	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	677	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	678	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	679	}
mkarlsso	2:298679fff37c	680	}
mkarlsso	2:298679fff37c	681
mkarlsso	2:298679fff37c	682	intOperation::intOperation(int* intVarInput, const char* cmpString, int cmpValInput):
mkarlsso	2:298679fff37c	683	intVal(intVarInput) {
mkarlsso	2:298679fff37c	684	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	685	randHigh = -1;
mkarlsso	2:298679fff37c	686	opPtr = NULL;
mkarlsso	2:298679fff37c	687	cmpValGlobal = false;
mkarlsso	2:298679fff37c	688	isUsed = true;
mkarlsso	2:298679fff37c	689	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	690	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	691	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	692	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	693	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	694	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	695	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	696	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	697	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	698	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	699	}
mkarlsso	2:298679fff37c	700	}
mkarlsso	2:298679fff37c	701
mkarlsso	2:298679fff37c	702	intOperation::intOperation(int* intVarInput, const char* cmpString, int* cmpIntVarInput):
mkarlsso	2:298679fff37c	703	cmpVal(cmpIntVarInput),
mkarlsso	2:298679fff37c	704	intVal(intVarInput) {
mkarlsso	2:298679fff37c	705	randHigh = -1;
mkarlsso	2:298679fff37c	706	opPtr = NULL;
mkarlsso	2:298679fff37c	707	cmpValGlobal = true;
mkarlsso	2:298679fff37c	708	isUsed = true;
mkarlsso	2:298679fff37c	709	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	710	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	711	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	712	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	713	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	714	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	715	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	716	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	717	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	718	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	719	}
mkarlsso	2:298679fff37c	720	}
mkarlsso	2:298679fff37c	721
mkarlsso	2:298679fff37c	722	intOperation::intOperation(int* intVarInput, intOperation* operationInput):
mkarlsso	2:298679fff37c	723	intVal(intVarInput) {
mkarlsso	2:298679fff37c	724	cmpVal = NULL;
mkarlsso	2:298679fff37c	725	randHigh = -1;
mkarlsso	2:298679fff37c	726	opPtr = operationInput;
mkarlsso	2:298679fff37c	727	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	728	isUsed = true;
mkarlsso	2:298679fff37c	729	}
mkarlsso	2:298679fff37c	730
mkarlsso	2:298679fff37c	731	void intOperation::set(int randParam, const char* cmpString, int cmpValInput) {
mkarlsso	2:298679fff37c	732	randHigh = randParam;
mkarlsso	2:298679fff37c	733	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	734	intVal = NULL;
mkarlsso	2:298679fff37c	735	opPtr = NULL;
mkarlsso	2:298679fff37c	736	cmpValGlobal = false;
mkarlsso	2:298679fff37c	737	isUsed = true;
mkarlsso	2:298679fff37c	738	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	739	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	740	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	741	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	742	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	743	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	744	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	745	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	746	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	747	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	748	}
mkarlsso	2:298679fff37c	749
mkarlsso	2:298679fff37c	750	}
mkarlsso	2:298679fff37c	751
mkarlsso	2:298679fff37c	752	void intOperation::set(int randParam, const char* cmpString, int* cmpIntVarInput) {
mkarlsso	2:298679fff37c	753	randHigh = randParam;
mkarlsso	2:298679fff37c	754	cmpVal = cmpIntVarInput;
mkarlsso	2:298679fff37c	755	intVal = NULL;
mkarlsso	2:298679fff37c	756	opPtr = NULL;
mkarlsso	2:298679fff37c	757	cmpValGlobal = true;
mkarlsso	2:298679fff37c	758	isUsed = true;
mkarlsso	2:298679fff37c	759	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	760	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	761	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	762	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	763	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	764	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	765	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	766	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	767	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	768	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	769	}
mkarlsso	2:298679fff37c	770	}
mkarlsso	2:298679fff37c	771
mkarlsso	2:298679fff37c	772	void intOperation::set(int* intVarInput, const char* cmpString, int cmpValInput) {
mkarlsso	3:ae33b7f5a7c1	773
mkarlsso	2:298679fff37c	774	intVal = intVarInput;
mkarlsso	2:298679fff37c	775	cmpVal = new int(cmpValInput);
mkarlsso	2:298679fff37c	776	randHigh = -1;
mkarlsso	2:298679fff37c	777	opPtr = NULL;
mkarlsso	2:298679fff37c	778	cmpValGlobal = false;
mkarlsso	2:298679fff37c	779	isUsed = true;
mkarlsso	2:298679fff37c	780	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	781	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	782	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	783	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	784	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	785	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	786	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	787	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	788	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	789	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	790	}
mkarlsso	2:298679fff37c	791	}
mkarlsso	2:298679fff37c	792
mkarlsso	2:298679fff37c	793	void intOperation::set(int* intVarInput, const char* cmpString, int* cmpIntVarInput) {
mkarlsso	2:298679fff37c	794	cmpVal = cmpIntVarInput;
mkarlsso	2:298679fff37c	795	intVal =intVarInput;
mkarlsso	2:298679fff37c	796	randHigh = -1;
mkarlsso	2:298679fff37c	797	opPtr = NULL;
mkarlsso	2:298679fff37c	798	cmpValGlobal = true;
mkarlsso	2:298679fff37c	799	isUsed = true;
mkarlsso	2:298679fff37c	800	if (strcmp(cmpString, "+") == 0) {
mkarlsso	2:298679fff37c	801	executePtr = &intOperation::add;
mkarlsso	2:298679fff37c	802	}else if (strcmp(cmpString, "-") == 0) {
mkarlsso	2:298679fff37c	803	executePtr = &intOperation::subtract;
mkarlsso	2:298679fff37c	804	}else if (strcmp(cmpString, "+=") == 0) {
mkarlsso	2:298679fff37c	805	executePtr = &intOperation::addAndStore;
mkarlsso	2:298679fff37c	806	}else if (strcmp(cmpString, "-=") == 0) {
mkarlsso	2:298679fff37c	807	executePtr = &intOperation::subtractAndStore;
mkarlsso	2:298679fff37c	808	}else if (strcmp(cmpString, "=") == 0) {
mkarlsso	2:298679fff37c	809	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	810	}
mkarlsso	2:298679fff37c	811	}
mkarlsso	2:298679fff37c	812
mkarlsso	2:298679fff37c	813	void intOperation::set(int* intVarInput, intOperation* operationInput) {
mkarlsso	3:ae33b7f5a7c1	814
mkarlsso	2:298679fff37c	815	intVal = intVarInput;
mkarlsso	2:298679fff37c	816	cmpVal = NULL;
mkarlsso	2:298679fff37c	817	randHigh = -1;
mkarlsso	2:298679fff37c	818	opPtr = operationInput;
mkarlsso	2:298679fff37c	819	executePtr = &intOperation::equals;
mkarlsso	2:298679fff37c	820	isUsed = true;
mkarlsso	2:298679fff37c	821
mkarlsso	2:298679fff37c	822	}
mkarlsso	2:298679fff37c	823
mkarlsso	2:298679fff37c	824
mkarlsso	2:298679fff37c	825	intOperation::~intOperation() {
mkarlsso	2:298679fff37c	826	if (!cmpValGlobal) delete cmpVal;
mkarlsso	2:298679fff37c	827	delete opPtr;
mkarlsso	2:298679fff37c	828	}
mkarlsso	2:298679fff37c	829
mkarlsso	2:298679fff37c	830	void intOperation::release() {
mkarlsso	2:298679fff37c	831	if (!cmpValGlobal) delete cmpVal;
mkarlsso	2:298679fff37c	832	if (opPtr != NULL) {
mkarlsso	2:298679fff37c	833	opPtr->release();
mkarlsso	2:298679fff37c	834	}
mkarlsso	2:298679fff37c	835	randHigh = -1;
mkarlsso	2:298679fff37c	836	cmpVal = NULL;
mkarlsso	2:298679fff37c	837	intVal = NULL;
mkarlsso	2:298679fff37c	838	opPtr = NULL;
mkarlsso	2:298679fff37c	839	executePtr = NULL;
mkarlsso	2:298679fff37c	840	cmpValGlobal = false;
mkarlsso	2:298679fff37c	841	isUsed = false;
mkarlsso	2:298679fff37c	842	}
mkarlsso	2:298679fff37c	843
mkarlsso	2:298679fff37c	844
mkarlsso	2:298679fff37c	845	int intOperation::execute() {
mkarlsso	3:ae33b7f5a7c1	846
mkarlsso	2:298679fff37c	847	return (this->*executePtr)();
mkarlsso	2:298679fff37c	848
mkarlsso	3:ae33b7f5a7c1	849
mkarlsso	2:298679fff37c	850	}
mkarlsso	2:298679fff37c	851
mkarlsso	2:298679fff37c	852	int intOperation::add() {
mkarlsso	3:ae33b7f5a7c1	853
mkarlsso	2:298679fff37c	854	if (intVal != NULL) {
mkarlsso	2:298679fff37c	855	return (intVal + cmpVal);
mkarlsso	2:298679fff37c	856	}
mkarlsso	2:298679fff37c	857	else {
mkarlsso	2:298679fff37c	858	//srand(time(NULL));
mkarlsso	2:298679fff37c	859	srand(*globalTimeKeeperPtr);
mkarlsso	2:298679fff37c	860	return (rand() % (randHigh+1)) + *cmpVal;
mkarlsso	2:298679fff37c	861	//return (port->getState() + *cmpVal);
mkarlsso	2:298679fff37c	862	}
mkarlsso	2:298679fff37c	863	}
mkarlsso	2:298679fff37c	864
mkarlsso	2:298679fff37c	865	int intOperation::subtract() {
mkarlsso	2:298679fff37c	866	if (intVal != NULL) {
mkarlsso	2:298679fff37c	867	return (intVal - cmpVal);
mkarlsso	2:298679fff37c	868	}
mkarlsso	2:298679fff37c	869	else {
mkarlsso	2:298679fff37c	870	srand(*globalTimeKeeperPtr);
mkarlsso	2:298679fff37c	871	return (rand() % (randHigh+1)) - *cmpVal;
mkarlsso	2:298679fff37c	872	//return (port->getState() - *cmpVal);
mkarlsso	2:298679fff37c	873	}
mkarlsso	2:298679fff37c	874	}
mkarlsso	2:298679fff37c	875
mkarlsso	2:298679fff37c	876	int intOperation::addAndStore() {
mkarlsso	2:298679fff37c	877	if (intVal != NULL) {
mkarlsso	2:298679fff37c	878	intVal = intVal + *cmpVal;
mkarlsso	2:298679fff37c	879	return *intVal;
mkarlsso	2:298679fff37c	880	}
mkarlsso	2:298679fff37c	881	else {
mkarlsso	2:298679fff37c	882
mkarlsso	2:298679fff37c	883	//Doesn't happen
mkarlsso	2:298679fff37c	884	return 0;
mkarlsso	2:298679fff37c	885	//port->setState(port->getState() + *cmpVal);
mkarlsso	2:298679fff37c	886	//return port->getState();
mkarlsso	2:298679fff37c	887	}
mkarlsso	2:298679fff37c	888
mkarlsso	2:298679fff37c	889	}
mkarlsso	2:298679fff37c	890
mkarlsso	2:298679fff37c	891	int intOperation::subtractAndStore() {
mkarlsso	2:298679fff37c	892	if (intVal != NULL) {
mkarlsso	2:298679fff37c	893	intVal = intVal - *cmpVal;
mkarlsso	2:298679fff37c	894	return *intVal;
mkarlsso	2:298679fff37c	895	} else {
mkarlsso	2:298679fff37c	896	//doesn't happen
mkarlsso	2:298679fff37c	897	return 0;
mkarlsso	2:298679fff37c	898	//port->setState(port->getState() - *cmpVal);
mkarlsso	2:298679fff37c	899	//return port->getState();
mkarlsso	2:298679fff37c	900	}
mkarlsso	2:298679fff37c	901	}
mkarlsso	2:298679fff37c	902
mkarlsso	2:298679fff37c	903	int intOperation::equals() {
mkarlsso	2:298679fff37c	904	if ((intVal != NULL) && (opPtr == NULL)) {
mkarlsso	2:298679fff37c	905	intVal = cmpVal;
mkarlsso	2:298679fff37c	906	return *intVal;
mkarlsso	2:298679fff37c	907	} else if ((intVal != NULL) && (opPtr != NULL)) {
mkarlsso	3:ae33b7f5a7c1	908
mkarlsso	2:298679fff37c	909	*intVal = opPtr->execute();
mkarlsso	2:298679fff37c	910	return *intVal;
mkarlsso	2:298679fff37c	911	} else if (cmpVal != NULL){
mkarlsso	2:298679fff37c	912
mkarlsso	2:298679fff37c	913	srand(*globalTimeKeeperPtr);
mkarlsso	2:298679fff37c	914	*cmpVal = (rand() % (randHigh+1)); //this is how we assign a random number to variable
mkarlsso	2:298679fff37c	915	return *cmpVal;
mkarlsso	2:298679fff37c	916
mkarlsso	2:298679fff37c	917	}
mkarlsso	2:298679fff37c	918	return -1;
mkarlsso	2:298679fff37c	919	}
mkarlsso	2:298679fff37c	920
mkarlsso	2:298679fff37c	921	condition::condition() {
mkarlsso	2:298679fff37c	922	intCmp = NULL;
mkarlsso	2:298679fff37c	923	conditionPtrs[0] = NULL;
mkarlsso	2:298679fff37c	924	conditionPtrs[1] = NULL;
mkarlsso	2:298679fff37c	925	isUsed = false;
mkarlsso	2:298679fff37c	926	conditionType = ARITHMATIC_CONDITION;
mkarlsso	2:298679fff37c	927	}
mkarlsso	2:298679fff37c	928
mkarlsso	2:298679fff37c	929	condition::condition(intCompare* compareInput) {
mkarlsso	2:298679fff37c	930
mkarlsso	2:298679fff37c	931	intCmp = compareInput;
mkarlsso	2:298679fff37c	932	conditionPtrs[0] = NULL;
mkarlsso	2:298679fff37c	933	conditionPtrs[1] = NULL;
mkarlsso	2:298679fff37c	934
mkarlsso	2:298679fff37c	935	isUsed = true;
mkarlsso	2:298679fff37c	936	conditionType = ARITHMATIC_CONDITION;
mkarlsso	2:298679fff37c	937
mkarlsso	2:298679fff37c	938	}
mkarlsso	2:298679fff37c	939
mkarlsso	2:298679fff37c	940	condition::condition(condition* condition1, char condType, condition* condition2) {
mkarlsso	2:298679fff37c	941	intCmp = NULL;
mkarlsso	2:298679fff37c	942	conditionPtrs[0] = condition1;
mkarlsso	2:298679fff37c	943	conditionPtrs[1] = condition2;
mkarlsso	2:298679fff37c	944	isUsed = true;
mkarlsso	2:298679fff37c	945	conditionType = condType;
mkarlsso	2:298679fff37c	946	}
mkarlsso	2:298679fff37c	947
mkarlsso	2:298679fff37c	948	condition::~condition() {
mkarlsso	2:298679fff37c	949	if (intCmp != NULL) {
mkarlsso	2:298679fff37c	950	delete intCmp;
mkarlsso	2:298679fff37c	951	}
mkarlsso	2:298679fff37c	952	}
mkarlsso	2:298679fff37c	953
mkarlsso	2:298679fff37c	954	void condition::release() {
mkarlsso	2:298679fff37c	955	if (intCmp != NULL) {
mkarlsso	2:298679fff37c	956	intCmp->release();
mkarlsso	2:298679fff37c	957	intCmp=NULL;
mkarlsso	2:298679fff37c	958	}
mkarlsso	2:298679fff37c	959	if (conditionPtrs[0] != NULL) {
mkarlsso	2:298679fff37c	960	conditionPtrs[0]->release();
mkarlsso	2:298679fff37c	961	conditionPtrs[1]->release();
mkarlsso	2:298679fff37c	962	conditionPtrs[0]=NULL;
mkarlsso	2:298679fff37c	963	conditionPtrs[1]=NULL;
mkarlsso	2:298679fff37c	964	}
mkarlsso	2:298679fff37c	965	isUsed = false;
mkarlsso	2:298679fff37c	966	}
mkarlsso	2:298679fff37c	967
mkarlsso	2:298679fff37c	968	void condition::set(intCompare* compareInput) {
mkarlsso	2:298679fff37c	969	release();
mkarlsso	2:298679fff37c	970	intCmp = compareInput;
mkarlsso	2:298679fff37c	971	conditionPtrs[0] = NULL;
mkarlsso	2:298679fff37c	972	conditionPtrs[1] = NULL;
mkarlsso	2:298679fff37c	973	isUsed = true;
mkarlsso	2:298679fff37c	974	conditionType = ARITHMATIC_CONDITION;
mkarlsso	2:298679fff37c	975	}
mkarlsso	2:298679fff37c	976
mkarlsso	2:298679fff37c	977	void condition::set(condition* condition1, char condType, condition* condition2) {
mkarlsso	2:298679fff37c	978	release();
mkarlsso	2:298679fff37c	979	intCmp = NULL;
mkarlsso	2:298679fff37c	980	conditionPtrs[0] = condition1;
mkarlsso	2:298679fff37c	981	conditionPtrs[1] = condition2;
mkarlsso	2:298679fff37c	982	isUsed = true;
mkarlsso	2:298679fff37c	983	conditionType = condType;
mkarlsso	2:298679fff37c	984	}
mkarlsso	2:298679fff37c	985
mkarlsso	2:298679fff37c	986	bool condition::isTrue() {
mkarlsso	2:298679fff37c	987
mkarlsso	2:298679fff37c	988
mkarlsso	2:298679fff37c	989	bool result = true;
mkarlsso	2:298679fff37c	990	if (conditionType == ARITHMATIC_CONDITION) {
mkarlsso	2:298679fff37c	991	//pc.printf("Evauating arithmatic condition \r\n");
mkarlsso	2:298679fff37c	992	result = (intCmp->isTrue)();
mkarlsso	2:298679fff37c	993	} else if (conditionType == AND_CONDITION) {
mkarlsso	2:298679fff37c	994	//pc.printf("Evauating AND condition \r\n");
mkarlsso	2:298679fff37c	995	result = conditionPtrs[0]->isTrue() && conditionPtrs[1]->isTrue();
mkarlsso	2:298679fff37c	996	} else if (conditionType == OR_CONDITION) {
mkarlsso	2:298679fff37c	997	//pc.printf("Evauating OR condition \r\n");
mkarlsso	2:298679fff37c	998	result = conditionPtrs[0]->isTrue() \|\| conditionPtrs[1]->isTrue();
mkarlsso	2:298679fff37c	999	}
mkarlsso	2:298679fff37c	1000	return result;
mkarlsso	2:298679fff37c	1001
mkarlsso	2:298679fff37c	1002	}
mkarlsso	2:298679fff37c	1003
mkarlsso	2:298679fff37c	1004	portMessage::portMessage():
mkarlsso	2:298679fff37c	1005	whichToSet(0),
mkarlsso	2:298679fff37c	1006	value(0),
mkarlsso	2:298679fff37c	1007	port(NULL) {
mkarlsso	2:298679fff37c	1008	isUsed = false;
mkarlsso	2:298679fff37c	1009	}
mkarlsso	2:298679fff37c	1010
mkarlsso	2:298679fff37c	1011	void portMessage::release() {
mkarlsso	2:298679fff37c	1012
mkarlsso	2:298679fff37c	1013	whichToSet = 0;
mkarlsso	2:298679fff37c	1014	value = 0;
mkarlsso	2:298679fff37c	1015	port = NULL;
mkarlsso	2:298679fff37c	1016	isUsed = false;
mkarlsso	2:298679fff37c	1017	}
mkarlsso	2:298679fff37c	1018
mkarlsso	2:298679fff37c	1019	/*
mkarlsso	2:298679fff37c	1020	portMessage::portMessage(digitalPort* portIn, int whichToSetIn, int valueIn):
mkarlsso	2:298679fff37c	1021	whichToSet(whichToSetIn),
mkarlsso	2:298679fff37c	1022	value(valueIn),
mkarlsso	2:298679fff37c	1023	port(portIn) {
mkarlsso	2:298679fff37c	1024	isUsed = true;
mkarlsso	2:298679fff37c	1025	}
mkarlsso	2:298679fff37c	1026
mkarlsso	2:298679fff37c	1027	void portMessage::setMessage(digitalPort* portIn, int whichToSetIn, int valueIn) {
mkarlsso	2:298679fff37c	1028	whichToSet = whichToSetIn;
mkarlsso	2:298679fff37c	1029	value = valueIn;
mkarlsso	2:298679fff37c	1030	port = portIn;
mkarlsso	2:298679fff37c	1031	isUsed = true;
mkarlsso	2:298679fff37c	1032	}*/
mkarlsso	2:298679fff37c	1033
mkarlsso	2:298679fff37c	1034	portMessage::portMessage(int* portIn, int whichToSetIn, int valueIn):
mkarlsso	2:298679fff37c	1035	whichToSet(whichToSetIn),
mkarlsso	2:298679fff37c	1036	value(valueIn),
mkarlsso	2:298679fff37c	1037	port(portIn) {
mkarlsso	2:298679fff37c	1038	isUsed = true;
mkarlsso	2:298679fff37c	1039	}
mkarlsso	2:298679fff37c	1040
mkarlsso	2:298679fff37c	1041	void portMessage::setMessage(int* portIn, int whichToSetIn, int valueIn) {
mkarlsso	2:298679fff37c	1042	whichToSet = whichToSetIn;
mkarlsso	2:298679fff37c	1043	value = valueIn;
mkarlsso	2:298679fff37c	1044	port = portIn;
mkarlsso	2:298679fff37c	1045	isUsed = true;
mkarlsso	2:298679fff37c	1046	}
mkarlsso	2:298679fff37c	1047
mkarlsso	2:298679fff37c	1048	void portMessage::execute() {
mkarlsso	2:298679fff37c	1049
mkarlsso	2:298679fff37c	1050	if (port != NULL) {
mkarlsso	2:298679fff37c	1051	if ((port > 0) && (port <= NUMPORTS)) {
mkarlsso	2:298679fff37c	1052	portVector[*port]->setDigitalOut(value);
mkarlsso	2:298679fff37c	1053	} else {
mkarlsso	2:298679fff37c	1054	pc.printf("Error: port index assigned by variable does not exist.");
mkarlsso	2:298679fff37c	1055	}
mkarlsso	2:298679fff37c	1056	} else {
mkarlsso	2:298679fff37c	1057	portVector[whichToSet]->setDigitalOut(value);
mkarlsso	2:298679fff37c	1058	}
mkarlsso	2:298679fff37c	1059
mkarlsso	2:298679fff37c	1060	/*
mkarlsso	2:298679fff37c	1061	if (whichToSet == 1) {
mkarlsso	2:298679fff37c	1062	port->setDigitalOut(value);
mkarlsso	2:298679fff37c	1063	} else if (whichToSet == 2) {
mkarlsso	2:298679fff37c	1064	//port->setState(value);
mkarlsso	2:298679fff37c	1065	}*/
mkarlsso	2:298679fff37c	1066	}
mkarlsso	2:298679fff37c	1067
mkarlsso	2:298679fff37c	1068	action::action():
mkarlsso	2:298679fff37c	1069	actionType(0) {
mkarlsso	2:298679fff37c	1070	op = NULL;
mkarlsso	2:298679fff37c	1071	message = NULL;
mkarlsso	2:298679fff37c	1072	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1073	displayActionPtr = NULL;
mkarlsso	2:298679fff37c	1074	//eventDelay = 0;
mkarlsso	2:298679fff37c	1075	sound = NULL;
mkarlsso	2:298679fff37c	1076	sysCommand = -1;
mkarlsso	2:298679fff37c	1077	isUsed = false;
mkarlsso	2:298679fff37c	1078
mkarlsso	2:298679fff37c	1079	}
mkarlsso	2:298679fff37c	1080
mkarlsso	2:298679fff37c	1081	action::~action() {
mkarlsso	2:298679fff37c	1082	if (eventToCreate != NULL) delete eventToCreate;
mkarlsso	2:298679fff37c	1083	if (op != NULL) delete op;
mkarlsso	2:298679fff37c	1084	if (message != NULL) delete message;
mkarlsso	2:298679fff37c	1085	delete displayActionPtr;
mkarlsso	2:298679fff37c	1086	delete sound;
mkarlsso	2:298679fff37c	1087	}
mkarlsso	2:298679fff37c	1088
mkarlsso	2:298679fff37c	1089	void action::release() {
mkarlsso	2:298679fff37c	1090	if (eventToCreate != NULL) eventToCreate->release();
mkarlsso	2:298679fff37c	1091	if (op != NULL) op->release();
mkarlsso	2:298679fff37c	1092	if (message != NULL) message->release();
mkarlsso	2:298679fff37c	1093	if (displayActionPtr != NULL) displayActionPtr->release();
mkarlsso	2:298679fff37c	1094	delete sound; //still need to make a static soundControl array
mkarlsso	2:298679fff37c	1095
mkarlsso	2:298679fff37c	1096	actionType = 0;
mkarlsso	2:298679fff37c	1097	op = NULL;
mkarlsso	2:298679fff37c	1098	message = NULL;
mkarlsso	2:298679fff37c	1099	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1100	displayActionPtr = NULL;
mkarlsso	2:298679fff37c	1101	//eventDelay = 0;
mkarlsso	2:298679fff37c	1102	sound = NULL;
mkarlsso	2:298679fff37c	1103	sysCommand = -1;
mkarlsso	2:298679fff37c	1104	isUsed = false;
mkarlsso	2:298679fff37c	1105	}
mkarlsso	2:298679fff37c	1106
mkarlsso	2:298679fff37c	1107	action::action(intOperation* opInput):
mkarlsso	2:298679fff37c	1108	actionType(1) {
mkarlsso	2:298679fff37c	1109	op = opInput;
mkarlsso	2:298679fff37c	1110	message = NULL;
mkarlsso	2:298679fff37c	1111	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1112	displayActionPtr= NULL;
mkarlsso	2:298679fff37c	1113	//eventDelay = 0;
mkarlsso	2:298679fff37c	1114	sound = NULL;
mkarlsso	2:298679fff37c	1115	sysCommand = -1;
mkarlsso	2:298679fff37c	1116	isUsed = true;
mkarlsso	2:298679fff37c	1117	}
mkarlsso	2:298679fff37c	1118
mkarlsso	2:298679fff37c	1119	action::action(portMessage* messageInput):
mkarlsso	2:298679fff37c	1120	actionType(2) {
mkarlsso	2:298679fff37c	1121	op = NULL;
mkarlsso	2:298679fff37c	1122	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1123	message = messageInput;
mkarlsso	2:298679fff37c	1124	displayActionPtr= NULL;
mkarlsso	2:298679fff37c	1125	//eventDelay = 0;
mkarlsso	2:298679fff37c	1126	sound = NULL;
mkarlsso	2:298679fff37c	1127	sysCommand = -1;
mkarlsso	2:298679fff37c	1128	isUsed = true;
mkarlsso	2:298679fff37c	1129
mkarlsso	2:298679fff37c	1130	}
mkarlsso	2:298679fff37c	1131
mkarlsso	2:298679fff37c	1132	action::action(event* eventInput):
mkarlsso	2:298679fff37c	1133	actionType(3) {
mkarlsso	2:298679fff37c	1134	op = NULL;
mkarlsso	2:298679fff37c	1135	message = NULL;
mkarlsso	2:298679fff37c	1136	eventToCreate = eventInput;
mkarlsso	2:298679fff37c	1137	displayActionPtr= NULL;
mkarlsso	2:298679fff37c	1138	sound = NULL;
mkarlsso	2:298679fff37c	1139
mkarlsso	2:298679fff37c	1140	//eventDelay = eventInput->timeLag;
mkarlsso	2:298679fff37c	1141
mkarlsso	2:298679fff37c	1142
mkarlsso	2:298679fff37c	1143	sysCommand = -1;
mkarlsso	2:298679fff37c	1144	isUsed = true;
mkarlsso	2:298679fff37c	1145	}
mkarlsso	2:298679fff37c	1146
mkarlsso	2:298679fff37c	1147	/*
mkarlsso	2:298679fff37c	1148	action::action(event* eventInput, uint32_t delay):
mkarlsso	2:298679fff37c	1149	actionType(3) {
mkarlsso	2:298679fff37c	1150	op = NULL;
mkarlsso	2:298679fff37c	1151	message = NULL;
mkarlsso	2:298679fff37c	1152	eventToCreate = eventInput;
mkarlsso	2:298679fff37c	1153	displayActionPtr= NULL;
mkarlsso	2:298679fff37c	1154	sound = NULL;
mkarlsso	2:298679fff37c	1155	eventDelay = delay;
mkarlsso	2:298679fff37c	1156	sysCommand = -1;
mkarlsso	2:298679fff37c	1157	isUsed = true;
mkarlsso	2:298679fff37c	1158
mkarlsso	2:298679fff37c	1159	}*/
mkarlsso	2:298679fff37c	1160
mkarlsso	2:298679fff37c	1161
mkarlsso	2:298679fff37c	1162
mkarlsso	2:298679fff37c	1163	action::action(displayAction* displayInput):
mkarlsso	2:298679fff37c	1164	actionType(4) {
mkarlsso	2:298679fff37c	1165	op = NULL;
mkarlsso	2:298679fff37c	1166	message = NULL;
mkarlsso	2:298679fff37c	1167	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1168	sound = NULL;
mkarlsso	2:298679fff37c	1169	displayActionPtr = displayInput;
mkarlsso	2:298679fff37c	1170	//eventDelay = 0;
mkarlsso	2:298679fff37c	1171	sysCommand = -1;
mkarlsso	2:298679fff37c	1172	isUsed = true;
mkarlsso	2:298679fff37c	1173	}
mkarlsso	2:298679fff37c	1174
mkarlsso	2:298679fff37c	1175	action::action(soundControl* soundInput):
mkarlsso	2:298679fff37c	1176	actionType(5) {
mkarlsso	2:298679fff37c	1177	op = NULL;
mkarlsso	2:298679fff37c	1178	message = NULL;
mkarlsso	2:298679fff37c	1179	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1180	sound = soundInput;
mkarlsso	2:298679fff37c	1181	displayActionPtr = NULL;
mkarlsso	2:298679fff37c	1182	//eventDelay = 0;
mkarlsso	2:298679fff37c	1183	sysCommand = -1;
mkarlsso	2:298679fff37c	1184	isUsed = true;
mkarlsso	2:298679fff37c	1185	}
mkarlsso	2:298679fff37c	1186
mkarlsso	2:298679fff37c	1187	action::action(int8_t sysCommandInput):
mkarlsso	2:298679fff37c	1188	actionType(6) {
mkarlsso	2:298679fff37c	1189	op = NULL;
mkarlsso	2:298679fff37c	1190	message = NULL;
mkarlsso	2:298679fff37c	1191	eventToCreate = NULL;
mkarlsso	2:298679fff37c	1192	sound = NULL;
mkarlsso	2:298679fff37c	1193	displayActionPtr = NULL;
mkarlsso	2:298679fff37c	1194	//eventDelay = 0;
mkarlsso	2:298679fff37c	1195	sysCommand = sysCommandInput;
mkarlsso	2:298679fff37c	1196	isUsed = true;
mkarlsso	2:298679fff37c	1197	}
mkarlsso	2:298679fff37c	1198
mkarlsso	2:298679fff37c	1199	void action::set(intOperation* opInput) {
mkarlsso	2:298679fff37c	1200	actionType = 1;
mkarlsso	2:298679fff37c	1201	op = opInput;
mkarlsso	2:298679fff37c	1202	//eventDelay = 0;
mkarlsso	2:298679fff37c	1203	isUsed = true;
mkarlsso	2:298679fff37c	1204
mkarlsso	2:298679fff37c	1205	}
mkarlsso	2:298679fff37c	1206
mkarlsso	2:298679fff37c	1207	void action::set(portMessage* messageInput) {
mkarlsso	2:298679fff37c	1208	actionType = 2;
mkarlsso	2:298679fff37c	1209	message = messageInput;
mkarlsso	2:298679fff37c	1210	//eventDelay = 0;
mkarlsso	2:298679fff37c	1211	isUsed = true;
mkarlsso	2:298679fff37c	1212
mkarlsso	2:298679fff37c	1213	}
mkarlsso	2:298679fff37c	1214
mkarlsso	2:298679fff37c	1215	void action::set(event* eventInput) {
mkarlsso	2:298679fff37c	1216	actionType = 3;
mkarlsso	2:298679fff37c	1217	eventToCreate = eventInput;
mkarlsso	2:298679fff37c	1218	//eventDelay = eventInput->timeLag;
mkarlsso	2:298679fff37c	1219
mkarlsso	2:298679fff37c	1220	isUsed = true;
mkarlsso	2:298679fff37c	1221
mkarlsso	2:298679fff37c	1222	}
mkarlsso	2:298679fff37c	1223
mkarlsso	2:298679fff37c	1224	/*
mkarlsso	2:298679fff37c	1225	void action::set(event* eventInput, uint32_t delay) {
mkarlsso	2:298679fff37c	1226	actionType = 3;
mkarlsso	2:298679fff37c	1227	eventToCreate = eventInput;
mkarlsso	2:298679fff37c	1228	eventDelay = delay;
mkarlsso	2:298679fff37c	1229	isUsed = true;
mkarlsso	2:298679fff37c	1230
mkarlsso	2:298679fff37c	1231	}*/
mkarlsso	2:298679fff37c	1232
mkarlsso	2:298679fff37c	1233
mkarlsso	2:298679fff37c	1234
mkarlsso	2:298679fff37c	1235	void action::set(displayAction* displayInput) {
mkarlsso	2:298679fff37c	1236	actionType = 4;
mkarlsso	2:298679fff37c	1237	displayActionPtr = displayInput;
mkarlsso	2:298679fff37c	1238	isUsed = true;
mkarlsso	2:298679fff37c	1239	}
mkarlsso	2:298679fff37c	1240
mkarlsso	2:298679fff37c	1241	void action::set(soundControl* soundInput) {
mkarlsso	2:298679fff37c	1242	actionType = 5;
mkarlsso	2:298679fff37c	1243	sound = soundInput;
mkarlsso	2:298679fff37c	1244	isUsed = true;
mkarlsso	2:298679fff37c	1245	}
mkarlsso	2:298679fff37c	1246
mkarlsso	2:298679fff37c	1247	void action::set(int8_t sysCommandInput) {
mkarlsso	2:298679fff37c	1248	actionType = 6;
mkarlsso	2:298679fff37c	1249	sysCommand = sysCommandInput;
mkarlsso	2:298679fff37c	1250	isUsed = true;
mkarlsso	2:298679fff37c	1251	}
mkarlsso	2:298679fff37c	1252
mkarlsso	2:298679fff37c	1253	void action::execute() {
mkarlsso	2:298679fff37c	1254
mkarlsso	2:298679fff37c	1255	if (actionType == 1) {
mkarlsso	2:298679fff37c	1256	op->execute();
mkarlsso	2:298679fff37c	1257	} else if (actionType == 2) {
mkarlsso	2:298679fff37c	1258	message->execute();
mkarlsso	2:298679fff37c	1259	} else if (actionType == 3) {
mkarlsso	2:298679fff37c	1260	this->execute(*globalTimeKeeperPtr); //route to the other overloaded method
mkarlsso	2:298679fff37c	1261	} else if (actionType == 4) {
mkarlsso	2:298679fff37c	1262	displayActionPtr->execute(); //send text via serial
mkarlsso	2:298679fff37c	1263	} else if (actionType == 5) {
mkarlsso	2:298679fff37c	1264	sound->execute(); //operate sound device
mkarlsso	2:298679fff37c	1265	} else if (actionType == 6) {
mkarlsso	2:298679fff37c	1266	switch(sysCommand) {
mkarlsso	2:298679fff37c	1267	case 0:
mkarlsso	2:298679fff37c	1268	mainQueue.eraseQueue();
mkarlsso	2:298679fff37c	1269	break;
mkarlsso	2:298679fff37c	1270	case 1:
mkarlsso	2:298679fff37c	1271	textStreaming = true;
mkarlsso	2:298679fff37c	1272	break;
mkarlsso	2:298679fff37c	1273	case 2:
mkarlsso	2:298679fff37c	1274	textStreaming = false;
mkarlsso	2:298679fff37c	1275	break;
mkarlsso	2:298679fff37c	1276	case 3:
mkarlsso	2:298679fff37c	1277	broadCastStateChanges = true;
mkarlsso	2:298679fff37c	1278	break;
mkarlsso	2:298679fff37c	1279	case 4:
mkarlsso	2:298679fff37c	1280	broadCastStateChanges = false;
mkarlsso	2:298679fff37c	1281	break;
mkarlsso	2:298679fff37c	1282	}
mkarlsso	2:298679fff37c	1283
mkarlsso	2:298679fff37c	1284	}
mkarlsso	2:298679fff37c	1285	}
mkarlsso	2:298679fff37c	1286
mkarlsso	2:298679fff37c	1287	void action::execute(uint32_t blockExecTime) {
mkarlsso	2:298679fff37c	1288
mkarlsso	2:298679fff37c	1289	if (actionType == 1) {
mkarlsso	2:298679fff37c	1290	op->execute();
mkarlsso	2:298679fff37c	1291	} else if (actionType == 2) {
mkarlsso	2:298679fff37c	1292	message->execute();
mkarlsso	2:298679fff37c	1293	} else if (actionType == 3) { //an event block
mkarlsso	2:298679fff37c	1294	//Because time will pass from the begining of the block, any defined delays should be updated
mkarlsso	2:298679fff37c	1295
mkarlsso	2:298679fff37c	1296	//int newDelay = eventDelay-(*globalTimeKeeperPtr-blockExecTime);
mkarlsso	2:298679fff37c	1297	int newDelay;
mkarlsso	2:298679fff37c	1298	if (eventToCreate->timeLagIsConstant) {
mkarlsso	2:298679fff37c	1299	newDelay = eventToCreate->timeLag - (*globalTimeKeeperPtr-blockExecTime);
mkarlsso	2:298679fff37c	1300	} else {
mkarlsso	2:298679fff37c	1301	newDelay = eventToCreate->timeLagVar - (globalTimeKeeperPtr-blockExecTime);
mkarlsso	2:298679fff37c	1302	}
mkarlsso	2:298679fff37c	1303	if (newDelay < 0) {newDelay = 0;}
mkarlsso	2:298679fff37c	1304	eventToCreate->addToQueue(newDelay); //add the event to the queue to be executed later
mkarlsso	2:298679fff37c	1305
mkarlsso	2:298679fff37c	1306	if (eventToCreate->hasWhileLoop) { //this is a while loop
mkarlsso	2:298679fff37c	1307	if (eventToCreate->isConditionTrue()) {
mkarlsso	2:298679fff37c	1308	//newDelay = (blockExecTime + eventToCreate->whileLoopPeriod) - *globalTimeKeeperPtr;
mkarlsso	2:298679fff37c	1309	int tmpPeriod;
mkarlsso	2:298679fff37c	1310	if (eventToCreate->whileLoopPeriodIsConstant) { //constant while loop period
mkarlsso	2:298679fff37c	1311	newDelay = (blockExecTime + eventToCreate->whileLoopPeriod);
mkarlsso	2:298679fff37c	1312	tmpPeriod = eventToCreate->whileLoopPeriod;
mkarlsso	2:298679fff37c	1313	} else {
mkarlsso	2:298679fff37c	1314	tmpPeriod = *eventToCreate->whileLoopPeriodVar;
mkarlsso	2:298679fff37c	1315	if (tmpPeriod < 0) {
mkarlsso	2:298679fff37c	1316	tmpPeriod = 0;
mkarlsso	2:298679fff37c	1317	}
mkarlsso	2:298679fff37c	1318	newDelay = (blockExecTime + tmpPeriod);
mkarlsso	2:298679fff37c	1319	}
mkarlsso	2:298679fff37c	1320	while ( (newDelay-*globalTimeKeeperPtr < 0) && (eventToCreate->isConditionTrue()) ) {
mkarlsso	2:298679fff37c	1321	eventToCreate->execute();
mkarlsso	2:298679fff37c	1322	newDelay = newDelay + tmpPeriod;
mkarlsso	2:298679fff37c	1323
mkarlsso	2:298679fff37c	1324	}
mkarlsso	2:298679fff37c	1325	newDelay = newDelay-*globalTimeKeeperPtr;
mkarlsso	2:298679fff37c	1326	if (newDelay > 0) {
mkarlsso	2:298679fff37c	1327	eventToCreate->addToQueue(newDelay);
mkarlsso	2:298679fff37c	1328	} else {
mkarlsso	2:298679fff37c	1329	eventToCreate->addToQueue(1);
mkarlsso	2:298679fff37c	1330	}
mkarlsso	2:298679fff37c	1331	} else if (eventToCreate->nextElseEventPtr != NULL) {
mkarlsso	2:298679fff37c	1332	eventToCreate->nextElseEventPtr->addToQueue();
mkarlsso	2:298679fff37c	1333
mkarlsso	2:298679fff37c	1334	}
mkarlsso	2:298679fff37c	1335	}
mkarlsso	2:298679fff37c	1336	} else if (actionType == 4) {
mkarlsso	2:298679fff37c	1337	displayActionPtr->execute(); //send text via serial
mkarlsso	2:298679fff37c	1338	} else if (actionType == 5) {
mkarlsso	2:298679fff37c	1339	sound->execute(); //operate sound device
mkarlsso	2:298679fff37c	1340	} else if (actionType == 6) {
mkarlsso	2:298679fff37c	1341	switch(sysCommand) {
mkarlsso	2:298679fff37c	1342	case 0:
mkarlsso	2:298679fff37c	1343	mainQueue.eraseQueue();
mkarlsso	2:298679fff37c	1344	break;
mkarlsso	2:298679fff37c	1345	case 1:
mkarlsso	2:298679fff37c	1346	textStreaming = true;
mkarlsso	2:298679fff37c	1347	break;
mkarlsso	2:298679fff37c	1348	case 2:
mkarlsso	2:298679fff37c	1349	textStreaming = false;
mkarlsso	2:298679fff37c	1350	break;
mkarlsso	2:298679fff37c	1351	case 3:
mkarlsso	2:298679fff37c	1352	broadCastStateChanges = true;
mkarlsso	2:298679fff37c	1353	break;
mkarlsso	2:298679fff37c	1354	case 4:
mkarlsso	2:298679fff37c	1355	broadCastStateChanges = false;
mkarlsso	2:298679fff37c	1356	break;
mkarlsso	2:298679fff37c	1357	}
mkarlsso	2:298679fff37c	1358	}
mkarlsso	2:298679fff37c	1359	}
mkarlsso	2:298679fff37c	1360
mkarlsso	2:298679fff37c	1361	eventQueue::eventQueue(digitalPort** portVectorInput, uint32_t* timeKeeperSlaveInput):
mkarlsso	2:298679fff37c	1362	portVector(portVectorInput),
mkarlsso	2:298679fff37c	1363	timeKeeperPtr(timeKeeperSlaveInput){
mkarlsso	2:298679fff37c	1364
mkarlsso	2:298679fff37c	1365	globalTimeKeeperPtr = timeKeeperPtr;
mkarlsso	2:298679fff37c	1366	queueItem blankEvent;
mkarlsso	2:298679fff37c	1367	blankEvent.timeToExecute = 0;
mkarlsso	2:298679fff37c	1368	blankEvent.eventPtr = NULL;
mkarlsso	2:298679fff37c	1369	queueSize = 100;
mkarlsso	2:298679fff37c	1370	events.resize(queueSize,blankEvent);
mkarlsso	2:298679fff37c	1371
mkarlsso	2:298679fff37c	1372
mkarlsso	2:298679fff37c	1373	}
mkarlsso	2:298679fff37c	1374
mkarlsso	2:298679fff37c	1375	void eventQueue::addEventToQueue(event* eventInput, uint32_t delay) {
mkarlsso	2:298679fff37c	1376	//*updateSlavePtr = false;
mkarlsso	2:298679fff37c	1377	uint32_t eventTime = *timeKeeperPtr + delay;
mkarlsso	2:298679fff37c	1378	//*updateSlavePtr = true;
mkarlsso	2:298679fff37c	1379	//std::vector<queueItem>::size_type sz = events.size();
mkarlsso	2:298679fff37c	1380	//Look for the first empty slot in the queue and place the event there.
mkarlsso	2:298679fff37c	1381	//This means that the events in the queue are out of order, but
mkarlsso	2:298679fff37c	1382	//it prevents us from having to push_pack and pop off all the time.
mkarlsso	2:298679fff37c	1383	for (unsigned i = 0; i < queueSize; i++) {
mkarlsso	2:298679fff37c	1384	if (events[i].eventPtr == NULL) {
mkarlsso	2:298679fff37c	1385	events[i].eventPtr = eventInput;
mkarlsso	2:298679fff37c	1386	events[i].timeToExecute = eventTime;
mkarlsso	2:298679fff37c	1387	break;
mkarlsso	2:298679fff37c	1388	}
mkarlsso	2:298679fff37c	1389	}
mkarlsso	2:298679fff37c	1390	}
mkarlsso	2:298679fff37c	1391
mkarlsso	2:298679fff37c	1392	void eventQueue::eraseQueue() {
mkarlsso	2:298679fff37c	1393	//Erase all events in the queue
mkarlsso	2:298679fff37c	1394	std::vector<queueItem>::size_type sz = events.size();
mkarlsso	2:298679fff37c	1395	for (unsigned i = 0; i < sz; i++) {
mkarlsso	2:298679fff37c	1396	events[i].eventPtr = NULL;
mkarlsso	2:298679fff37c	1397
mkarlsso	2:298679fff37c	1398	}
mkarlsso	2:298679fff37c	1399	}
mkarlsso	2:298679fff37c	1400
mkarlsso	2:298679fff37c	1401
mkarlsso	2:298679fff37c	1402	//check if any of the events in the queue are up for execution
mkarlsso	2:298679fff37c	1403	void eventQueue::check(void) {
mkarlsso	2:298679fff37c	1404
mkarlsso	2:298679fff37c	1405	//*updateSlavePtr = false;
mkarlsso	2:298679fff37c	1406	uint32_t currentTime = *timeKeeperPtr;
mkarlsso	2:298679fff37c	1407	//*updateSlavePtr = true;
mkarlsso	2:298679fff37c	1408	//std::vector<queueItem>::size_type sz = events.size();
mkarlsso	2:298679fff37c	1409	for (unsigned i = 0; i < queueSize; i++) {
mkarlsso	2:298679fff37c	1410	if (events[i].eventPtr != NULL) {
mkarlsso	2:298679fff37c	1411	if(events[i].timeToExecute <= currentTime) {
mkarlsso	2:298679fff37c	1412	if (!events[i].eventPtr->hasWhileLoop) {
mkarlsso	2:298679fff37c	1413	//this is not a while loop, so no need to check if the condition is still true
mkarlsso	2:298679fff37c	1414	events[i].eventPtr->execute();
mkarlsso	2:298679fff37c	1415	} else if (events[i].eventPtr->isConditionTrue()){
mkarlsso	2:298679fff37c	1416	//The event is part of a while loop, so recheck the condition before executing
mkarlsso	2:298679fff37c	1417	events[i].eventPtr->execute();
mkarlsso	2:298679fff37c	1418	//if (events[i].eventPtr->isConditionTrue()) { //is the condition still true?
mkarlsso	2:298679fff37c	1419	int nextTime;
mkarlsso	2:298679fff37c	1420	int tmpPeriod;
mkarlsso	2:298679fff37c	1421	if (events[i].eventPtr->whileLoopPeriodIsConstant) {
mkarlsso	2:298679fff37c	1422	nextTime = (events[i].timeToExecute + events[i].eventPtr->whileLoopPeriod);
mkarlsso	2:298679fff37c	1423	tmpPeriod = events[i].eventPtr->whileLoopPeriod;
mkarlsso	2:298679fff37c	1424	} else {
mkarlsso	2:298679fff37c	1425	tmpPeriod = *events[i].eventPtr->whileLoopPeriodVar;
mkarlsso	2:298679fff37c	1426	if (tmpPeriod < 0) {
mkarlsso	2:298679fff37c	1427	tmpPeriod = 0;
mkarlsso	2:298679fff37c	1428	}
mkarlsso	2:298679fff37c	1429	nextTime = (events[i].timeToExecute + tmpPeriod);
mkarlsso	2:298679fff37c	1430
mkarlsso	2:298679fff37c	1431	}
mkarlsso	2:298679fff37c	1432	//Just in case we are not keeping up, execute the event until we have cought up
mkarlsso	2:298679fff37c	1433	while ((nextTime-*timeKeeperPtr <= 0) && (events[i].eventPtr->isConditionTrue())) {
mkarlsso	2:298679fff37c	1434	events[i].eventPtr->execute();
mkarlsso	2:298679fff37c	1435	nextTime = nextTime+tmpPeriod;
mkarlsso	2:298679fff37c	1436
mkarlsso	2:298679fff37c	1437	}
mkarlsso	2:298679fff37c	1438	nextTime = nextTime - *timeKeeperPtr;
mkarlsso	2:298679fff37c	1439	if (nextTime > 0) {
mkarlsso	2:298679fff37c	1440	//we add the event to the queue (but the condition is rechecked first)
mkarlsso	2:298679fff37c	1441	//if the condition is false, the 'then' statement is added to the queue instead
mkarlsso	2:298679fff37c	1442	events[i].eventPtr->addToQueue(nextTime);
mkarlsso	2:298679fff37c	1443	} else {
mkarlsso	2:298679fff37c	1444	//if we are having trouble keeping up, just add the next event in 1 ms
mkarlsso	2:298679fff37c	1445	events[i].eventPtr->addToQueue(1);
mkarlsso	2:298679fff37c	1446	}
mkarlsso	2:298679fff37c	1447	/*
mkarlsso	2:298679fff37c	1448	} else {
mkarlsso	2:298679fff37c	1449	if (events[i].eventPtr->nextElseEventPtr != NULL) {
mkarlsso	2:298679fff37c	1450	events[i].eventPtr->nextElseEventPtr->addToQueue();
mkarlsso	2:298679fff37c	1451	}
mkarlsso	2:298679fff37c	1452	}*/
mkarlsso	2:298679fff37c	1453
mkarlsso	2:298679fff37c	1454	} else {
mkarlsso	2:298679fff37c	1455	if (events[i].eventPtr->nextElseEventPtr != NULL) {
mkarlsso	2:298679fff37c	1456	events[i].eventPtr->nextElseEventPtr->addToQueue();
mkarlsso	2:298679fff37c	1457	}
mkarlsso	2:298679fff37c	1458	}
mkarlsso	2:298679fff37c	1459	events[i].eventPtr = NULL;
mkarlsso	2:298679fff37c	1460	}
mkarlsso	2:298679fff37c	1461	}
mkarlsso	2:298679fff37c	1462	}
mkarlsso	2:298679fff37c	1463	}
mkarlsso	2:298679fff37c	1464
mkarlsso	2:298679fff37c	1465
mkarlsso	2:298679fff37c	1466	event::event():
mkarlsso	2:298679fff37c	1467	timeLag(0),
mkarlsso	2:298679fff37c	1468	queuePtr(&mainQueue) {
mkarlsso	2:298679fff37c	1469	nextElseEventPtr = NULL;
mkarlsso	2:298679fff37c	1470	conditionToCheck = NULL;
mkarlsso	2:298679fff37c	1471	blockType = 0;
mkarlsso	2:298679fff37c	1472	whileLoopPeriod = 0;
mkarlsso	2:298679fff37c	1473	numConditions = 0;
mkarlsso	2:298679fff37c	1474	numActions = 0;
mkarlsso	2:298679fff37c	1475	isUsed = false;
mkarlsso	2:298679fff37c	1476	timeLagVar = NULL;
mkarlsso	2:298679fff37c	1477	timeLagIsConstant = true;
mkarlsso	2:298679fff37c	1478	whileLoopPeriodIsConstant = true;
mkarlsso	2:298679fff37c	1479	hasWhileLoop = false;
mkarlsso	2:298679fff37c	1480	whileLoopPeriodVar = NULL;
mkarlsso	2:298679fff37c	1481
mkarlsso	2:298679fff37c	1482	}
mkarlsso	2:298679fff37c	1483
mkarlsso	2:298679fff37c	1484	event::event(eventQueue* queueInput):
mkarlsso	2:298679fff37c	1485	timeLag(0),
mkarlsso	2:298679fff37c	1486	queuePtr(&mainQueue) {
mkarlsso	2:298679fff37c	1487	nextElseEventPtr = NULL;
mkarlsso	2:298679fff37c	1488	conditionToCheck = NULL;
mkarlsso	2:298679fff37c	1489	blockType = 0;
mkarlsso	2:298679fff37c	1490	whileLoopPeriod = 0;
mkarlsso	2:298679fff37c	1491	numConditions = 0;
mkarlsso	2:298679fff37c	1492	numActions = 0;
mkarlsso	2:298679fff37c	1493	isUsed = true;
mkarlsso	2:298679fff37c	1494	timeLagVar = NULL;
mkarlsso	2:298679fff37c	1495	timeLagIsConstant = true;
mkarlsso	2:298679fff37c	1496	whileLoopPeriodIsConstant = true;
mkarlsso	2:298679fff37c	1497	hasWhileLoop = false;
mkarlsso	2:298679fff37c	1498	whileLoopPeriodVar = NULL;
mkarlsso	2:298679fff37c	1499
mkarlsso	2:298679fff37c	1500	}
mkarlsso	2:298679fff37c	1501
mkarlsso	2:298679fff37c	1502	event::~event() {
mkarlsso	2:298679fff37c	1503	/*
mkarlsso	2:298679fff37c	1504	while (!conditionArray.empty())
mkarlsso	2:298679fff37c	1505	{
mkarlsso	2:298679fff37c	1506	delete conditionArray.back();
mkarlsso	2:298679fff37c	1507	conditionArray.pop_back();
mkarlsso	2:298679fff37c	1508	}
mkarlsso	2:298679fff37c	1509
mkarlsso	2:298679fff37c	1510	while (!actionArray.empty())
mkarlsso	2:298679fff37c	1511	{
mkarlsso	2:298679fff37c	1512	delete actionArray.back();
mkarlsso	2:298679fff37c	1513	actionArray.pop_back();
mkarlsso	2:298679fff37c	1514	}
mkarlsso	2:298679fff37c	1515
mkarlsso	2:298679fff37c	1516	delete nextElseEventPtr;
mkarlsso	2:298679fff37c	1517	*/
mkarlsso	2:298679fff37c	1518
mkarlsso	2:298679fff37c	1519	}
mkarlsso	2:298679fff37c	1520
mkarlsso	2:298679fff37c	1521	void event::release() {
mkarlsso	2:298679fff37c	1522
mkarlsso	2:298679fff37c	1523	for (int i = 0; i < numActions; i++) {
mkarlsso	2:298679fff37c	1524	actionArray[i]->release();
mkarlsso	2:298679fff37c	1525	}
mkarlsso	2:298679fff37c	1526
mkarlsso	2:298679fff37c	1527	if (conditionToCheck != NULL) {
mkarlsso	2:298679fff37c	1528	conditionToCheck->release();
mkarlsso	2:298679fff37c	1529	conditionToCheck = NULL;
mkarlsso	2:298679fff37c	1530	}
mkarlsso	2:298679fff37c	1531
mkarlsso	2:298679fff37c	1532	if (nextElseEventPtr != NULL) {
mkarlsso	2:298679fff37c	1533	nextElseEventPtr->release();
mkarlsso	2:298679fff37c	1534	}
mkarlsso	2:298679fff37c	1535	timeLag = 0;
mkarlsso	2:298679fff37c	1536	nextElseEventPtr = NULL;
mkarlsso	2:298679fff37c	1537	blockType = 0;
mkarlsso	2:298679fff37c	1538	whileLoopPeriod = 0;
mkarlsso	2:298679fff37c	1539	numConditions = 0;
mkarlsso	2:298679fff37c	1540	numActions = 0;
mkarlsso	2:298679fff37c	1541	isUsed = false;
mkarlsso	2:298679fff37c	1542	timeLagVar = NULL;
mkarlsso	2:298679fff37c	1543	timeLagIsConstant = true;
mkarlsso	2:298679fff37c	1544	whileLoopPeriodIsConstant = true;
mkarlsso	2:298679fff37c	1545	hasWhileLoop = false;
mkarlsso	2:298679fff37c	1546	whileLoopPeriodVar = NULL;
mkarlsso	2:298679fff37c	1547	}
mkarlsso	2:298679fff37c	1548
mkarlsso	2:298679fff37c	1549	void event::setTimeLag(uint32_t timeLagInput) {
mkarlsso	2:298679fff37c	1550	timeLag = timeLagInput;
mkarlsso	2:298679fff37c	1551	timeLagIsConstant = true;
mkarlsso	2:298679fff37c	1552	}
mkarlsso	2:298679fff37c	1553
mkarlsso	2:298679fff37c	1554	void event::setTimeLag(int* timeLagInput) {
mkarlsso	2:298679fff37c	1555	timeLagVar = timeLagInput;
mkarlsso	2:298679fff37c	1556	timeLagIsConstant = false; //time lag is not defined by a constant
mkarlsso	2:298679fff37c	1557	}
mkarlsso	2:298679fff37c	1558
mkarlsso	2:298679fff37c	1559	void event::setWhileLoopPeriod(uint32_t period) {
mkarlsso	2:298679fff37c	1560	whileLoopPeriodIsConstant = true;
mkarlsso	2:298679fff37c	1561	hasWhileLoop = true;
mkarlsso	2:298679fff37c	1562	whileLoopPeriod = period;
mkarlsso	2:298679fff37c	1563
mkarlsso	2:298679fff37c	1564	}
mkarlsso	2:298679fff37c	1565
mkarlsso	2:298679fff37c	1566	void event::setWhileLoopPeriod(int* period) {
mkarlsso	2:298679fff37c	1567	whileLoopPeriodIsConstant = false;
mkarlsso	2:298679fff37c	1568	hasWhileLoop = true;
mkarlsso	2:298679fff37c	1569	whileLoopPeriodVar = period;
mkarlsso	2:298679fff37c	1570
mkarlsso	2:298679fff37c	1571	}
mkarlsso	2:298679fff37c	1572
mkarlsso	2:298679fff37c	1573	void event::addCondition(condition* conditionInput) {
mkarlsso	2:298679fff37c	1574	if (conditionToCheck != NULL) {
mkarlsso	2:298679fff37c	1575	conditionToCheck->release();
mkarlsso	2:298679fff37c	1576	}
mkarlsso	2:298679fff37c	1577	conditionToCheck = conditionInput;
mkarlsso	2:298679fff37c	1578
mkarlsso	2:298679fff37c	1579	//conditionArray.push_back(conditionInput);
mkarlsso	2:298679fff37c	1580	}
mkarlsso	2:298679fff37c	1581
mkarlsso	2:298679fff37c	1582	void event::addAction(action* actionInput) {
mkarlsso	2:298679fff37c	1583	actionArray[numActions] = actionInput;
mkarlsso	2:298679fff37c	1584	numActions++;
mkarlsso	2:298679fff37c	1585	//actionArray.push_back(actionInput);
mkarlsso	2:298679fff37c	1586	}
mkarlsso	2:298679fff37c	1587
mkarlsso	2:298679fff37c	1588	bool event::isConditionTrue(void) {
mkarlsso	2:298679fff37c	1589	//if statement (can be left empty, which is interpreted as 'true')
mkarlsso	2:298679fff37c	1590	//queuePtr->pcPtr->printf("Checking condition...\r\n");
mkarlsso	2:298679fff37c	1591	bool result = true;
mkarlsso	2:298679fff37c	1592	/*
mkarlsso	2:298679fff37c	1593	std::vector<condition*>::size_type sz = conditionArray.size();
mkarlsso	2:298679fff37c	1594	for (unsigned i = 0; i < sz; i++) {
mkarlsso	2:298679fff37c	1595	if (!conditionArray[i]->isTrue()) {
mkarlsso	2:298679fff37c	1596	result = false;
mkarlsso	2:298679fff37c	1597	//queuePtr->pcPtr->printf("Consition false\r\n");
mkarlsso	2:298679fff37c	1598	} //else {queuePtr->pcPtr->printf("Consition true\r\n");}
mkarlsso	2:298679fff37c	1599	}
mkarlsso	2:298679fff37c	1600	*/
mkarlsso	2:298679fff37c	1601
mkarlsso	2:298679fff37c	1602	if ((conditionToCheck!=NULL)&&(!conditionToCheck->isTrue())) {
mkarlsso	2:298679fff37c	1603	result = false;
mkarlsso	2:298679fff37c	1604	}
mkarlsso	2:298679fff37c	1605
mkarlsso	2:298679fff37c	1606	return result;
mkarlsso	2:298679fff37c	1607	}
mkarlsso	2:298679fff37c	1608
mkarlsso	2:298679fff37c	1609	void event::execute(void) {
mkarlsso	2:298679fff37c	1610	//called from the event queue. The condition is bypassed because it was already checked
mkarlsso	2:298679fff37c	1611
mkarlsso	2:298679fff37c	1612
mkarlsso	2:298679fff37c	1613	uint32_t timeAtStartExec = *globalTimeKeeperPtr;
mkarlsso	2:298679fff37c	1614	//std::vector<action*>::size_type sz = actionArray.size();
mkarlsso	2:298679fff37c	1615
mkarlsso	2:298679fff37c	1616	/*
mkarlsso	2:298679fff37c	1617	std::deque<action*>::size_type sz = actionArray.size();
mkarlsso	2:298679fff37c	1618
mkarlsso	2:298679fff37c	1619	for (unsigned i = 0; i < sz; i++) {
mkarlsso	2:298679fff37c	1620	actionArray[i]->execute(timeAtStartExec);
mkarlsso	2:298679fff37c	1621
mkarlsso	2:298679fff37c	1622	}
mkarlsso	2:298679fff37c	1623	*/
mkarlsso	2:298679fff37c	1624	for (unsigned i = 0; i < numActions; i++) {
mkarlsso	2:298679fff37c	1625	actionArray[i]->execute(timeAtStartExec);
mkarlsso	2:298679fff37c	1626
mkarlsso	2:298679fff37c	1627	}
mkarlsso	2:298679fff37c	1628
mkarlsso	2:298679fff37c	1629	}
mkarlsso	2:298679fff37c	1630
mkarlsso	2:298679fff37c	1631	//Attach an 'else' statement to the event
mkarlsso	2:298679fff37c	1632	void event::setNextElseEvent(event* eventInput) {
mkarlsso	2:298679fff37c	1633	nextElseEventPtr = eventInput;
mkarlsso	2:298679fff37c	1634	}
mkarlsso	2:298679fff37c	1635
mkarlsso	2:298679fff37c	1636
mkarlsso	2:298679fff37c	1637	//When we we call addToQueue() the condition is checked. If true, the event is added
mkarlsso	2:298679fff37c	1638	//to the queue, otherwise we check if there was an 'else' statement attached to the event.
mkarlsso	2:298679fff37c	1639	void event::addToQueue(void) {
mkarlsso	2:298679fff37c	1640	if (isConditionTrue()) {
mkarlsso	2:298679fff37c	1641	if ((timeLagIsConstant)&&(timeLag == 0)) {
mkarlsso	2:298679fff37c	1642	execute();
mkarlsso	2:298679fff37c	1643
mkarlsso	2:298679fff37c	1644	} else if (timeLagIsConstant) {
mkarlsso	2:298679fff37c	1645	queuePtr->addEventToQueue(this, this->timeLag);
mkarlsso	2:298679fff37c	1646	} else if ((!timeLagIsConstant)&&(*timeLagVar <= 0)) {
mkarlsso	2:298679fff37c	1647	execute();
mkarlsso	2:298679fff37c	1648	} else {
mkarlsso	2:298679fff37c	1649	queuePtr->addEventToQueue(this, *timeLagVar);
mkarlsso	2:298679fff37c	1650	}
mkarlsso	2:298679fff37c	1651	} else if ((this->nextElseEventPtr != NULL)&&(whileLoopPeriod == 0)) {
mkarlsso	2:298679fff37c	1652	this->nextElseEventPtr->addToQueue();
mkarlsso	2:298679fff37c	1653	}
mkarlsso	2:298679fff37c	1654	}
mkarlsso	2:298679fff37c	1655
mkarlsso	2:298679fff37c	1656	//We can override the timeLag field and use another delay
mkarlsso	2:298679fff37c	1657	void event::addToQueue(uint32_t delay) {
mkarlsso	2:298679fff37c	1658	if (this->isConditionTrue()) {
mkarlsso	2:298679fff37c	1659	//if ((delay == 0) && (whileLoopPeriod == 0)) {
mkarlsso	2:298679fff37c	1660	if ((delay == 0)) {
mkarlsso	2:298679fff37c	1661	this->execute();
mkarlsso	2:298679fff37c	1662	} else {
mkarlsso	2:298679fff37c	1663	queuePtr->addEventToQueue(this, delay);
mkarlsso	2:298679fff37c	1664	}
mkarlsso	2:298679fff37c	1665	} else if ((this->nextElseEventPtr != NULL)) { //&&(!hasWhileLoop)) {
mkarlsso	2:298679fff37c	1666	this->nextElseEventPtr->addToQueue();
mkarlsso	2:298679fff37c	1667	}
mkarlsso	2:298679fff37c	1668	}
mkarlsso	2:298679fff37c	1669
mkarlsso	2:298679fff37c	1670
mkarlsso	2:298679fff37c	1671
mkarlsso	2:298679fff37c	1672	functionItem::functionItem(action* actionInput, string tagInput):
mkarlsso	2:298679fff37c	1673	tag(tagInput),
mkarlsso	2:298679fff37c	1674	actionPtr(actionInput) {
mkarlsso	2:298679fff37c	1675	}
mkarlsso	2:298679fff37c	1676
mkarlsso	2:298679fff37c	1677	functionItem::~functionItem() {
mkarlsso	2:298679fff37c	1678	delete actionPtr;
mkarlsso	2:298679fff37c	1679	}
mkarlsso	2:298679fff37c	1680
mkarlsso	2:298679fff37c	1681	scriptStream::scriptStream(Serial* serialInput, digitalPort** portVectorInput, int numPortsInput, eventQueue* queueInput):
mkarlsso	2:298679fff37c	1682	portVector(portVectorInput),
mkarlsso	2:298679fff37c	1683	numPorts(numPortsInput),
mkarlsso	2:298679fff37c	1684	pcPtr(serialInput),
mkarlsso	2:298679fff37c	1685	queuePtr(queueInput) {
mkarlsso	2:298679fff37c	1686
mkarlsso	2:298679fff37c	1687	currentPort = -1;
mkarlsso	2:298679fff37c	1688	currentTriggerPort = -1;
mkarlsso	2:298679fff37c	1689	currentTriggerDir = 1;
mkarlsso	2:298679fff37c	1690	currentFunction = -1;
mkarlsso	2:298679fff37c	1691
mkarlsso	2:298679fff37c	1692	lineError = false;
mkarlsso	2:298679fff37c	1693	blockDepth = 0;
mkarlsso	2:298679fff37c	1694	ifBlockInit = false;
mkarlsso	2:298679fff37c	1695	whileBlockInit = false;
mkarlsso	2:298679fff37c	1696	elseFlag = false;
mkarlsso	2:298679fff37c	1697	currentDelay = 0;
mkarlsso	2:298679fff37c	1698
mkarlsso	2:298679fff37c	1699	}
mkarlsso	2:298679fff37c	1700
mkarlsso	2:298679fff37c	1701	void scriptStream::addLineToCurrentBlock(char* lineInput) {
mkarlsso	2:298679fff37c	1702
mkarlsso	2:298679fff37c	1703	bool compile = false;
mkarlsso	2:298679fff37c	1704	bool keep = false;
mkarlsso	2:298679fff37c	1705	for (int i = 0; i < 128; i++) {
mkarlsso	2:298679fff37c	1706	if (lineInput[i] == ';') {
mkarlsso	2:298679fff37c	1707	compile = true;
mkarlsso	2:298679fff37c	1708	} else if (lineInput[i] == ' ') {
mkarlsso	2:298679fff37c	1709	continue;
mkarlsso	2:298679fff37c	1710	} else if (lineInput[i] == '\0') {
mkarlsso	2:298679fff37c	1711	break;
mkarlsso	2:298679fff37c	1712	} else {
mkarlsso	2:298679fff37c	1713	keep = true;
mkarlsso	2:298679fff37c	1714	compile = false;
mkarlsso	2:298679fff37c	1715	}
mkarlsso	2:298679fff37c	1716	}
mkarlsso	2:298679fff37c	1717	if (keep) currentBlock.insert(currentBlock.begin(),string(lineInput));
mkarlsso	2:298679fff37c	1718	if (compile) parseBlock();
mkarlsso	2:298679fff37c	1719
mkarlsso	2:298679fff37c	1720	}
mkarlsso	2:298679fff37c	1721
mkarlsso	2:298679fff37c	1722
mkarlsso	2:298679fff37c	1723	//SCRIPT PARSING - all script commands are defined here.
mkarlsso	2:298679fff37c	1724	//-------------------------------------------------------
mkarlsso	2:298679fff37c	1725	void scriptStream::parseBlock() {
mkarlsso	2:298679fff37c	1726
mkarlsso	2:298679fff37c	1727	lineError = false;
mkarlsso	2:298679fff37c	1728	blockDepth = 0;
mkarlsso	2:298679fff37c	1729	ifBlockInit = false;
mkarlsso	2:298679fff37c	1730	whileBlockInit = false;
mkarlsso	2:298679fff37c	1731	elseFlag = false;
mkarlsso	2:298679fff37c	1732	thenFlag = false;
mkarlsso	2:298679fff37c	1733	currentDelay = 0;
mkarlsso	2:298679fff37c	1734
mkarlsso	2:298679fff37c	1735	std::size_t stringInd = 0;
mkarlsso	2:298679fff37c	1736
mkarlsso	2:298679fff37c	1737	bool wholeLineEvaluated = false;
mkarlsso	2:298679fff37c	1738
mkarlsso	2:298679fff37c	1739	//pcPtr->printf("\r\n");
mkarlsso	2:298679fff37c	1740	while (!currentBlock.empty()) {
mkarlsso	2:298679fff37c	1741	wholeLineEvaluated = false;
mkarlsso	2:298679fff37c	1742	tmpLine = currentBlock.back();
mkarlsso	2:298679fff37c	1743	lineError = false;
mkarlsso	2:298679fff37c	1744	//remove tabs
mkarlsso	2:298679fff37c	1745	std::size_t found = tmpLine.find_first_of(9); //tab
mkarlsso	2:298679fff37c	1746	while (found!=std::string::npos) {
mkarlsso	2:298679fff37c	1747	tmpLine[found]= ' ';
mkarlsso	2:298679fff37c	1748	found=tmpLine.find_first_of(9,found+1);
mkarlsso	2:298679fff37c	1749	}
mkarlsso	2:298679fff37c	1750
mkarlsso	2:298679fff37c	1751	found = tmpLine.find_first_of(37); //% for commenting
mkarlsso	2:298679fff37c	1752	if (found!=std::string::npos) {
mkarlsso	2:298679fff37c	1753	for (int p=found; p<tmpLine.size() ;p++) {
mkarlsso	2:298679fff37c	1754	tmpLine[p]= ' ';
mkarlsso	2:298679fff37c	1755	}
mkarlsso	2:298679fff37c	1756	}
mkarlsso	2:298679fff37c	1757
mkarlsso	2:298679fff37c	1758	//break up the line into tokens separated by spaces
mkarlsso	2:298679fff37c	1759	tokenize(tmpLine,tokens," ;");
mkarlsso	2:298679fff37c	1760
mkarlsso	2:298679fff37c	1761	std::vector<string>::size_type sz = tokens.size();
mkarlsso	2:298679fff37c	1762
mkarlsso	2:298679fff37c	1763	for (unsigned i = 0; i < sz; i++) {
mkarlsso	2:298679fff37c	1764	//pcPtr->printf("%s", tokens[i].c_str());
mkarlsso	2:298679fff37c	1765
mkarlsso	2:298679fff37c	1766
mkarlsso	2:298679fff37c	1767	//end statement signals the end of a block-----------------------------------------
mkarlsso	2:298679fff37c	1768	if (tokens[i].compare("end") == 0) { //ends the current block
mkarlsso	2:298679fff37c	1769
mkarlsso	2:298679fff37c	1770	if (ifBlockInit \|\| whileBlockInit) {
mkarlsso	2:298679fff37c	1771	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	1772	lineError = true;
mkarlsso	2:298679fff37c	1773	}
mkarlsso	2:298679fff37c	1774
mkarlsso	2:298679fff37c	1775	ifBlockInit = false;
mkarlsso	2:298679fff37c	1776	whileBlockInit = false;
mkarlsso	2:298679fff37c	1777	elseFlag = false;
mkarlsso	2:298679fff37c	1778
mkarlsso	2:298679fff37c	1779	if (blockDepth > 0) {
mkarlsso	2:298679fff37c	1780	if (blockDepth == 1) {
mkarlsso	2:298679fff37c	1781
mkarlsso	2:298679fff37c	1782
mkarlsso	2:298679fff37c	1783	//pcPtr->printf("Close trigger block for port %d\r\n",currentTriggerPort);
mkarlsso	2:298679fff37c	1784	currentTriggerPort = -1;
mkarlsso	2:298679fff37c	1785
mkarlsso	2:298679fff37c	1786
mkarlsso	2:298679fff37c	1787
mkarlsso	2:298679fff37c	1788	blockDepth = 0;
mkarlsso	2:298679fff37c	1789	} else if (blockDepth > 1) {
mkarlsso	2:298679fff37c	1790	//pcPtr->printf("Close block\r\n");
mkarlsso	2:298679fff37c	1791	blockDepth = blockDepth - 1;
mkarlsso	2:298679fff37c	1792	}
mkarlsso	2:298679fff37c	1793
mkarlsso	2:298679fff37c	1794	while ((tmpEventPtrArray.back()->blockType == 3) \|\| (tmpEventPtrArray.back()->blockType == 4)){
mkarlsso	2:298679fff37c	1795	tmpEventPtrArray.pop_back(); //recursively remove the pointers to all else blocks
mkarlsso	2:298679fff37c	1796	}
mkarlsso	2:298679fff37c	1797	tmpEventPtrArray.pop_back(); //remove the pointer to the finished block
mkarlsso	2:298679fff37c	1798	} else {
mkarlsso	2:298679fff37c	1799	pcPtr->printf("Error: End statement without block\r\n");
mkarlsso	2:298679fff37c	1800	lineError = true;
mkarlsso	2:298679fff37c	1801	}
mkarlsso	2:298679fff37c	1802
mkarlsso	2:298679fff37c	1803
mkarlsso	2:298679fff37c	1804
mkarlsso	2:298679fff37c	1805	//sound statement used to play wave files------------------------------------------------
mkarlsso	2:298679fff37c	1806	//example: sound('soundfile')
mkarlsso	2:298679fff37c	1807	// sound(stop)
mkarlsso	2:298679fff37c	1808	} else if (tokens[i].find("sound(") != std::string::npos) {
mkarlsso	2:298679fff37c	1809	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	1810	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	1811	lineError = true;
mkarlsso	2:298679fff37c	1812	}
mkarlsso	2:298679fff37c	1813	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	1814	int pos1 = tmpLine.find("sound(")+6;
mkarlsso	2:298679fff37c	1815	int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso	2:298679fff37c	1816	string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso	2:298679fff37c	1817
mkarlsso	2:298679fff37c	1818	int* tmpVar = findIntVariable(dispVar);
mkarlsso	2:298679fff37c	1819	bool isText = false;
mkarlsso	2:298679fff37c	1820	bool stopSignal = false;
mkarlsso	2:298679fff37c	1821	bool resetSignal = false;
mkarlsso	2:298679fff37c	1822	if (tmpVar == NULL) {
mkarlsso	2:298679fff37c	1823	if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso	2:298679fff37c	1824	isText = true;
mkarlsso	2:298679fff37c	1825	} else if (dispVar.compare("stop") == 0) {
mkarlsso	2:298679fff37c	1826	stopSignal = true;
mkarlsso	2:298679fff37c	1827	} else if (dispVar.compare("reset") == 0) {
mkarlsso	2:298679fff37c	1828	resetSignal = true;
mkarlsso	2:298679fff37c	1829	} else {
mkarlsso	2:298679fff37c	1830	pcPtr->printf("Error: variable input to sound() does not exist\r\n");
mkarlsso	2:298679fff37c	1831	lineError = true;
mkarlsso	2:298679fff37c	1832	}
mkarlsso	2:298679fff37c	1833	}
mkarlsso	2:298679fff37c	1834	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	1835	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	1836	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	1837	lineError = true;
mkarlsso	2:298679fff37c	1838	}
mkarlsso	2:298679fff37c	1839	if (!lineError && (blockDepth == 0)) {
mkarlsso	2:298679fff37c	1840	//we are not inside a block structure, so play sound now
mkarlsso	2:298679fff37c	1841	if (stopSignal) {
mkarlsso	2:298679fff37c	1842	soundControl S;
mkarlsso	2:298679fff37c	1843	S.setPlayback(false);
mkarlsso	2:298679fff37c	1844	S.execute();
mkarlsso	2:298679fff37c	1845	} else if (resetSignal) {
mkarlsso	2:298679fff37c	1846	soundControl S;
mkarlsso	2:298679fff37c	1847	S.setReset();
mkarlsso	2:298679fff37c	1848	S.execute();
mkarlsso	2:298679fff37c	1849	} else if (isText) {
mkarlsso	2:298679fff37c	1850
mkarlsso	2:298679fff37c	1851	if (pos2-pos1-2 <= 20) {
mkarlsso	2:298679fff37c	1852
mkarlsso	2:298679fff37c	1853	soundControl S;
mkarlsso	2:298679fff37c	1854	S.setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso	2:298679fff37c	1855	S.execute();
mkarlsso	2:298679fff37c	1856	} else {
mkarlsso	2:298679fff37c	1857	pcPtr->printf("Error: sound file names must be 20 characters or less.\r\n");
mkarlsso	2:298679fff37c	1858	lineError = true;
mkarlsso	2:298679fff37c	1859	}
mkarlsso	2:298679fff37c	1860	} else {
mkarlsso	2:298679fff37c	1861	pcPtr->printf("Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n");
mkarlsso	2:298679fff37c	1862	lineError = true;
mkarlsso	2:298679fff37c	1863	}
mkarlsso	2:298679fff37c	1864
mkarlsso	2:298679fff37c	1865	} else if (!lineError && (blockDepth > 0) ){
mkarlsso	2:298679fff37c	1866	//the disp function was put inside a block
mkarlsso	2:298679fff37c	1867	if (stopSignal) {
mkarlsso	2:298679fff37c	1868	soundControl* sPtr = new soundControl();
mkarlsso	2:298679fff37c	1869	sPtr->setPlayback(false);
mkarlsso	2:298679fff37c	1870	//action* tmpAction = new action(sPtr);
mkarlsso	2:298679fff37c	1871	tmpAction->set(sPtr);
mkarlsso	2:298679fff37c	1872	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	1873	} else if (resetSignal) {
mkarlsso	2:298679fff37c	1874	soundControl* sPtr = new soundControl();
mkarlsso	2:298679fff37c	1875	sPtr->setReset();
mkarlsso	2:298679fff37c	1876	//action* tmpAction = new action(sPtr);
mkarlsso	2:298679fff37c	1877	tmpAction->set(sPtr);
mkarlsso	2:298679fff37c	1878	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	1879	} else if (isText) {
mkarlsso	2:298679fff37c	1880
mkarlsso	2:298679fff37c	1881	if (pos2-pos1-2 <= 20) {
mkarlsso	2:298679fff37c	1882	soundControl* sPtr = new soundControl();
mkarlsso	2:298679fff37c	1883	sPtr->setFile(tmpLine.substr(pos1+1,pos2-pos1-2));
mkarlsso	2:298679fff37c	1884	//action* tmpAction = new action(sPtr);
mkarlsso	2:298679fff37c	1885	tmpAction->set(sPtr);
mkarlsso	2:298679fff37c	1886	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	1887	} else {
mkarlsso	2:298679fff37c	1888	pcPtr->printf("Error: sound file names must be 20 characters or less.\r\n");
mkarlsso	2:298679fff37c	1889	lineError = true;
mkarlsso	2:298679fff37c	1890	}
mkarlsso	2:298679fff37c	1891	} else {
mkarlsso	2:298679fff37c	1892	pcPtr->printf("Error: variable input to sound() not yet supported. Enter a string in single quotes.\r\n");
mkarlsso	2:298679fff37c	1893	lineError = true;
mkarlsso	2:298679fff37c	1894	}
mkarlsso	2:298679fff37c	1895
mkarlsso	2:298679fff37c	1896	//pcPtr->printf("Sound action\r\n");
mkarlsso	2:298679fff37c	1897	}
mkarlsso	2:298679fff37c	1898
mkarlsso	2:298679fff37c	1899	} else if (tokens[i].find("volume(") != std::string::npos) {
mkarlsso	2:298679fff37c	1900	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	1901	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	1902	lineError = true;
mkarlsso	2:298679fff37c	1903	}
mkarlsso	2:298679fff37c	1904	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	1905	int pos1 = tmpLine.find("volume(")+7;
mkarlsso	2:298679fff37c	1906	int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso	2:298679fff37c	1907	string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso	2:298679fff37c	1908
mkarlsso	2:298679fff37c	1909	int* tmpVar = findIntVariable(dispVar);
mkarlsso	2:298679fff37c	1910	bool isText = false;
mkarlsso	2:298679fff37c	1911	if (tmpVar == NULL) {
mkarlsso	2:298679fff37c	1912	if (isNumber(dispVar)) {
mkarlsso	2:298679fff37c	1913	isText = true;
mkarlsso	2:298679fff37c	1914	} else {
mkarlsso	2:298679fff37c	1915	pcPtr->printf("Error: variable input to volume() does not exist\r\n");
mkarlsso	2:298679fff37c	1916	lineError = true;
mkarlsso	2:298679fff37c	1917	}
mkarlsso	2:298679fff37c	1918	}
mkarlsso	2:298679fff37c	1919	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	1920	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	1921	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	1922	lineError = true;
mkarlsso	2:298679fff37c	1923	}
mkarlsso	2:298679fff37c	1924	if (!lineError && (blockDepth == 0)) {
mkarlsso	2:298679fff37c	1925	//we are not inside a block structure, so play sound now
mkarlsso	2:298679fff37c	1926	if (isText) {
mkarlsso	2:298679fff37c	1927	int newVolume = atoi(dispVar.data());
mkarlsso	2:298679fff37c	1928	if ((newVolume >=0)&&(newVolume <= 255)) {
mkarlsso	2:298679fff37c	1929	soundControl S;
mkarlsso	2:298679fff37c	1930	S.setVolume(newVolume);
mkarlsso	2:298679fff37c	1931	S.execute();
mkarlsso	2:298679fff37c	1932	} else {
mkarlsso	2:298679fff37c	1933	pcPtr->printf("Error: sound volume must be between 0 and 255 .\r\n");
mkarlsso	2:298679fff37c	1934	lineError = true;
mkarlsso	2:298679fff37c	1935	}
mkarlsso	2:298679fff37c	1936	} else {
mkarlsso	2:298679fff37c	1937	soundControl S;
mkarlsso	2:298679fff37c	1938	S.setVolume(tmpVar);
mkarlsso	2:298679fff37c	1939	S.execute();
mkarlsso	2:298679fff37c	1940	}
mkarlsso	2:298679fff37c	1941
mkarlsso	2:298679fff37c	1942	} else if (!lineError && (blockDepth > 0) ){
mkarlsso	2:298679fff37c	1943	//the disp function was put inside a block
mkarlsso	2:298679fff37c	1944	if (isText) {
mkarlsso	2:298679fff37c	1945	int newVolume = atoi(dispVar.data());
mkarlsso	2:298679fff37c	1946
mkarlsso	2:298679fff37c	1947	soundControl* sPtr = new soundControl();
mkarlsso	2:298679fff37c	1948	sPtr->setVolume(newVolume);
mkarlsso	2:298679fff37c	1949
mkarlsso	2:298679fff37c	1950	//action* tmpAction = new action(sPtr);
mkarlsso	2:298679fff37c	1951	tmpAction->set(sPtr);
mkarlsso	2:298679fff37c	1952	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	1953
mkarlsso	2:298679fff37c	1954	} else {
mkarlsso	2:298679fff37c	1955	soundControl* sPtr = new soundControl();
mkarlsso	2:298679fff37c	1956	sPtr->setVolume(tmpVar);
mkarlsso	2:298679fff37c	1957	//action* tmpAction = new action(sPtr);
mkarlsso	2:298679fff37c	1958	tmpAction->set(sPtr);
mkarlsso	2:298679fff37c	1959	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	1960	}
mkarlsso	2:298679fff37c	1961
mkarlsso	2:298679fff37c	1962	//pcPtr->printf("Volume action\r\n");
mkarlsso	2:298679fff37c	1963	}
mkarlsso	2:298679fff37c	1964	//clock statement used to is used to control the clock-------------------------
mkarlsso	2:298679fff37c	1965	//example: clock(reset); clock(slave); clock(standalone)
mkarlsso	2:298679fff37c	1966	} else if (tokens[i].find("clock(") != std::string::npos) { //clock commands
mkarlsso	2:298679fff37c	1967	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	1968	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	1969	lineError = true;
mkarlsso	2:298679fff37c	1970	}
mkarlsso	2:298679fff37c	1971	if (blockDepth > 0) {
mkarlsso	2:298679fff37c	1972	pcPtr->printf("Error: clock commands only allowed outside of block structure\r\n");
mkarlsso	2:298679fff37c	1973	lineError = true;
mkarlsso	2:298679fff37c	1974	}
mkarlsso	2:298679fff37c	1975
mkarlsso	2:298679fff37c	1976	if (!lineError) {
mkarlsso	2:298679fff37c	1977	int pos1 = tmpLine.find("clock(")+6;
mkarlsso	2:298679fff37c	1978	int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso	2:298679fff37c	1979	string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso	2:298679fff37c	1980
mkarlsso	2:298679fff37c	1981
mkarlsso	2:298679fff37c	1982	if (blockDepth == 0) {
mkarlsso	2:298679fff37c	1983	if (dispVar.compare("reset") == 0) {
mkarlsso	2:298679fff37c	1984	resetTimer = true;
mkarlsso	2:298679fff37c	1985	queuePtr->eraseQueue();
mkarlsso	2:298679fff37c	1986	textDisplay.send(string("Clock reset to 0\r\n"));
mkarlsso	2:298679fff37c	1987	//pcPtr->printf("Clock reset to 0\r\n");
mkarlsso	2:298679fff37c	1988	} else if (dispVar.compare("slave") == 0) {
mkarlsso	2:298679fff37c	1989	if (!clockSlave) {
mkarlsso	2:298679fff37c	1990	changeToSlave = true;
mkarlsso	2:298679fff37c	1991	textDisplay.send(string("Slave mode\r\n"));
mkarlsso	2:298679fff37c	1992	//pcPtr->printf("Slave mode\r\n");
mkarlsso	2:298679fff37c	1993	}
mkarlsso	2:298679fff37c	1994	} else if (dispVar.compare("standalone") == 0) {
mkarlsso	2:298679fff37c	1995	if (clockSlave) {
mkarlsso	2:298679fff37c	1996	changeToStandAlone = true;
mkarlsso	2:298679fff37c	1997	textDisplay.send(string("Standalone mode\r\n"));
mkarlsso	2:298679fff37c	1998	//pcPtr->printf("Standalone mode\r\n");
mkarlsso	2:298679fff37c	1999	}
mkarlsso	2:298679fff37c	2000	} else {
mkarlsso	2:298679fff37c	2001	pcPtr->printf("Clock control statement not understood\r\n");
mkarlsso	2:298679fff37c	2002	lineError = true;
mkarlsso	2:298679fff37c	2003	}
mkarlsso	2:298679fff37c	2004	}
mkarlsso	2:298679fff37c	2005	}
mkarlsso	2:298679fff37c	2006
mkarlsso	2:298679fff37c	2007	//disp command used to display text via serial---------------------------------------
mkarlsso	2:298679fff37c	2008	//example: disp('hello'); disp(myVar)
mkarlsso	2:298679fff37c	2009	} else if (tokens[i].find("disp(") != std::string::npos) { //display value of variable
mkarlsso	2:298679fff37c	2010
mkarlsso	2:298679fff37c	2011	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2012	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2013	lineError = true;
mkarlsso	2:298679fff37c	2014	}
mkarlsso	2:298679fff37c	2015
mkarlsso	2:298679fff37c	2016	//int pos1 = tokens[i].find("disp(")+5;
mkarlsso	2:298679fff37c	2017	//int pos2 = tokens[i].find_first_of(")",pos1);
mkarlsso	2:298679fff37c	2018	//string dispVar = tokens[i].substr(pos1,pos2-pos1);
mkarlsso	2:298679fff37c	2019
mkarlsso	2:298679fff37c	2020	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2021	int pos1 = tmpLine.find("disp(")+5;
mkarlsso	2:298679fff37c	2022	int pos2 = tmpLine.find_first_of(")",pos1);
mkarlsso	2:298679fff37c	2023	string dispVar = tmpLine.substr(pos1,pos2-pos1);
mkarlsso	2:298679fff37c	2024
mkarlsso	2:298679fff37c	2025	int* tmpVar = findIntVariable(dispVar);
mkarlsso	2:298679fff37c	2026	bool isText = false;
mkarlsso	2:298679fff37c	2027	if (tmpVar == NULL) {
mkarlsso	2:298679fff37c	2028	if ((tmpLine.compare(pos1,1,"'")==0) && (tmpLine.compare(pos2-1,1,"'")==0)) {
mkarlsso	2:298679fff37c	2029	isText = true;
mkarlsso	2:298679fff37c	2030	} else {
mkarlsso	2:298679fff37c	2031	pcPtr->printf("Error: variable to display does not exist\r\n");
mkarlsso	2:298679fff37c	2032	lineError = true;
mkarlsso	2:298679fff37c	2033	}
mkarlsso	2:298679fff37c	2034	}
mkarlsso	2:298679fff37c	2035	displayAction* dPtr = findFirstUnUsed(displayActionBlock, NUMDISPLAYACTIONS);
mkarlsso	2:298679fff37c	2036	if (dPtr == NULL) {
mkarlsso	2:298679fff37c	2037	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2038	lineError = true;
mkarlsso	2:298679fff37c	2039	}
mkarlsso	2:298679fff37c	2040	if (!lineError && (blockDepth == 0)) {
mkarlsso	2:298679fff37c	2041	//we are not inside a block structure, so display now
mkarlsso	2:298679fff37c	2042
mkarlsso	2:298679fff37c	2043	if (isText) {
mkarlsso	2:298679fff37c	2044	//displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso	2:298679fff37c	2045	dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso	2:298679fff37c	2046	dPtr->execute();
mkarlsso	2:298679fff37c	2047	//delete dPtr;
mkarlsso	2:298679fff37c	2048	dPtr->release();
mkarlsso	2:298679fff37c	2049	} else {
mkarlsso	2:298679fff37c	2050	//displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso	2:298679fff37c	2051	dPtr->set(tmpVar, dispVar, pcPtr);
mkarlsso	2:298679fff37c	2052	dPtr->execute();
mkarlsso	2:298679fff37c	2053	//delete dPtr;
mkarlsso	2:298679fff37c	2054	dPtr->release();
mkarlsso	2:298679fff37c	2055	}
mkarlsso	2:298679fff37c	2056
mkarlsso	2:298679fff37c	2057	} else if (!lineError && (blockDepth > 0) ){
mkarlsso	2:298679fff37c	2058	//the disp function was put inside a block
mkarlsso	2:298679fff37c	2059	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2060	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2061	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2062	lineError = true;
mkarlsso	2:298679fff37c	2063	}
mkarlsso	2:298679fff37c	2064	if (!lineError && isText) {
mkarlsso	2:298679fff37c	2065	//displayAction* dPtr = new displayAction(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso	2:298679fff37c	2066	dPtr->set(tmpLine.substr(pos1+1,pos2-pos1-2), pcPtr);
mkarlsso	2:298679fff37c	2067	tmpAction->set(dPtr);
mkarlsso	2:298679fff37c	2068	//action* tmpAction = new action(dPtr);
mkarlsso	2:298679fff37c	2069	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2070	} else if (!lineError) {
mkarlsso	2:298679fff37c	2071	//displayAction* dPtr = new displayAction(tmpVar, dispVar, pcPtr);
mkarlsso	2:298679fff37c	2072	dPtr->set(tmpVar, dispVar, pcPtr);
mkarlsso	2:298679fff37c	2073	tmpAction->set(dPtr);
mkarlsso	2:298679fff37c	2074	//action* tmpAction = new action(dPtr);
mkarlsso	2:298679fff37c	2075	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2076	}
mkarlsso	2:298679fff37c	2077
mkarlsso	2:298679fff37c	2078	//pcPtr->printf("Display action\r\n");
mkarlsso	2:298679fff37c	2079	}
mkarlsso	2:298679fff37c	2080
mkarlsso	2:298679fff37c	2081
mkarlsso	2:298679fff37c	2082	//int is used to decalar new variables. Only allowed outside of callbacks-------------------
mkarlsso	2:298679fff37c	2083	//example: int a; int b = 9
mkarlsso	2:298679fff37c	2084	} else if (tokens[i].compare("int") == 0) { //define a new integer variable
mkarlsso	2:298679fff37c	2085
mkarlsso	2:298679fff37c	2086	if (ifBlockInit \|\| whileBlockInit) {
mkarlsso	2:298679fff37c	2087	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2088	lineError = true;
mkarlsso	2:298679fff37c	2089	}
mkarlsso	2:298679fff37c	2090	tmpString = "";
mkarlsso	2:298679fff37c	2091	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2092	int spacesBeforeEqualSign = 0;
mkarlsso	2:298679fff37c	2093	bool countSpaces = true;
mkarlsso	2:298679fff37c	2094	//combine the tokens without whitespaces
mkarlsso	2:298679fff37c	2095	for (unsigned j = i+1; j < sz; j++) {
mkarlsso	2:298679fff37c	2096	tmpString.append(tokens[j]);
mkarlsso	2:298679fff37c	2097	if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso	2:298679fff37c	2098	if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso	2:298679fff37c	2099	countSpaces = false;
mkarlsso	2:298679fff37c	2100	} else if (countSpaces) {
mkarlsso	2:298679fff37c	2101	spacesBeforeEqualSign++;
mkarlsso	2:298679fff37c	2102	}
mkarlsso	2:298679fff37c	2103	}
mkarlsso	2:298679fff37c	2104
mkarlsso	2:298679fff37c	2105	if (blockDepth > 0) {
mkarlsso	2:298679fff37c	2106	pcPtr->printf("Error: Variables can only be first declared outside of callbacks.\r\n");
mkarlsso	2:298679fff37c	2107	lineError = true;
mkarlsso	2:298679fff37c	2108	}
mkarlsso	2:298679fff37c	2109
mkarlsso	2:298679fff37c	2110	if ((!lineError) && (spacesBeforeEqualSign > 1)) {
mkarlsso	2:298679fff37c	2111	pcPtr->printf("Error: Variable can't have a space in it.\r\n");
mkarlsso	2:298679fff37c	2112	lineError = true;
mkarlsso	2:298679fff37c	2113	}
mkarlsso	2:298679fff37c	2114	stringInd = tmpString.find_first_of("=");
mkarlsso	2:298679fff37c	2115
mkarlsso	2:298679fff37c	2116	bool variableCreated = false;
mkarlsso	2:298679fff37c	2117	if (!lineError) {
mkarlsso	2:298679fff37c	2118	if (((stringInd == std::string::npos) && (sz == 2)) \|\| (stringInd != std::string::npos)) {
mkarlsso	2:298679fff37c	2119	if (createIntVariable(tmpString.substr(0,stringInd))) {
mkarlsso	2:298679fff37c	2120	//pcPtr->printf("Created variable: %s\r\n", tmpString.substr(0,stringInd).data());
mkarlsso	2:298679fff37c	2121	variableCreated = true;
mkarlsso	2:298679fff37c	2122	} else {
mkarlsso	2:298679fff37c	2123	int* tmpVar = findIntVariable(tmpString.substr(0,stringInd));
mkarlsso	2:298679fff37c	2124	*tmpVar = 0;
mkarlsso	2:298679fff37c	2125	//pcPtr->printf("Reset variable %s to 0\r\n", tmpString.substr(0,stringInd).data());
mkarlsso	2:298679fff37c	2126	//lineError = true;
mkarlsso	2:298679fff37c	2127	}
mkarlsso	2:298679fff37c	2128	} else {
mkarlsso	2:298679fff37c	2129	pcPtr->printf("Error: variable declaration not understood.\r\n", tmpString.substr(0,stringInd).data());
mkarlsso	2:298679fff37c	2130	lineError = true;
mkarlsso	2:298679fff37c	2131	}
mkarlsso	2:298679fff37c	2132	}
mkarlsso	2:298679fff37c	2133
mkarlsso	2:298679fff37c	2134	if ((!lineError) && (stringInd != std::string::npos)) { //evaluate the expression
mkarlsso	2:298679fff37c	2135	action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso	2:298679fff37c	2136	if (tmpAction != NULL) {
mkarlsso	2:298679fff37c	2137	tmpAction->execute();
mkarlsso	2:298679fff37c	2138	//delete tmpAction;
mkarlsso	2:298679fff37c	2139	tmpAction->release();
mkarlsso	2:298679fff37c	2140	} else {
mkarlsso	2:298679fff37c	2141	lineError = true;
mkarlsso	2:298679fff37c	2142	if (variableCreated) {
mkarlsso	2:298679fff37c	2143	delete globalVariables.back();
mkarlsso	2:298679fff37c	2144	globalVariables.pop_back();
mkarlsso	2:298679fff37c	2145	}
mkarlsso	2:298679fff37c	2146	}
mkarlsso	2:298679fff37c	2147	}
mkarlsso	2:298679fff37c	2148
mkarlsso	2:298679fff37c	2149	//serial command is used to toggle whether or not to buffer up output text----------------
mkarlsso	2:298679fff37c	2150	//examples: serial buffer; serial send
mkarlsso	2:298679fff37c	2151	} else if (tokens[i].compare("serial") == 0) {
mkarlsso	2:298679fff37c	2152	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2153	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2154	lineError = true;
mkarlsso	2:298679fff37c	2155	}
mkarlsso	2:298679fff37c	2156	bool stream = true;
mkarlsso	2:298679fff37c	2157	if ((!lineError)&&(i+1 < sz)){
mkarlsso	2:298679fff37c	2158	if (tokens[i+1].compare("buffer") == 0) {
mkarlsso	2:298679fff37c	2159	stream = false;
mkarlsso	2:298679fff37c	2160	} else if (tokens[i+1].compare("send") == 0) {
mkarlsso	2:298679fff37c	2161	stream = true;
mkarlsso	2:298679fff37c	2162	} else {
mkarlsso	2:298679fff37c	2163	pcPtr->printf("Error: 'serial' useage: 'serial buffer' or 'serial send'\r\n");
mkarlsso	2:298679fff37c	2164	lineError = true;
mkarlsso	2:298679fff37c	2165	}
mkarlsso	2:298679fff37c	2166	}
mkarlsso	2:298679fff37c	2167	i++;
mkarlsso	2:298679fff37c	2168	if ((!lineError) && (blockDepth == 0)) {
mkarlsso	2:298679fff37c	2169	if (stream) {
mkarlsso	2:298679fff37c	2170	textStreaming = true;
mkarlsso	2:298679fff37c	2171	} else {
mkarlsso	2:298679fff37c	2172	textStreaming = false;
mkarlsso	2:298679fff37c	2173	}
mkarlsso	2:298679fff37c	2174	} else if ((!lineError) && (blockDepth > 0)) {
mkarlsso	2:298679fff37c	2175	if (stream) {
mkarlsso	2:298679fff37c	2176	//action* tmpAction = new action(1); //code 1 = turn on text streaming
mkarlsso	2:298679fff37c	2177	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2178	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2179	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2180	lineError = true;
mkarlsso	2:298679fff37c	2181	} else {
mkarlsso	2:298679fff37c	2182	tmpAction->set(1);
mkarlsso	2:298679fff37c	2183	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2184	}
mkarlsso	2:298679fff37c	2185
mkarlsso	2:298679fff37c	2186	} else {
mkarlsso	2:298679fff37c	2187	//action* tmpAction = new action(2); //code 2 = turn on text buffering
mkarlsso	2:298679fff37c	2188	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2189	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2190	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2191	lineError = true;
mkarlsso	2:298679fff37c	2192	} else {
mkarlsso	2:298679fff37c	2193	tmpAction->set(2);
mkarlsso	2:298679fff37c	2194	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2195	}
mkarlsso	2:298679fff37c	2196	}
mkarlsso	2:298679fff37c	2197	}
mkarlsso	2:298679fff37c	2198
mkarlsso	2:298679fff37c	2199	//updates command toggles the DIO update messages upon a change------------------
mkarlsso	2:298679fff37c	2200	//examples: updates on; updates off
mkarlsso	2:298679fff37c	2201	} else if (tokens[i].compare("updates") == 0) {
mkarlsso	2:298679fff37c	2202	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2203	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2204	lineError = true;
mkarlsso	2:298679fff37c	2205	}
mkarlsso	2:298679fff37c	2206	bool stream = true;
mkarlsso	2:298679fff37c	2207	if ((!lineError)&&(i+1 < sz)){
mkarlsso	2:298679fff37c	2208	if (tokens[i+1].compare("on") == 0) {
mkarlsso	2:298679fff37c	2209	stream = true;
mkarlsso	2:298679fff37c	2210	} else if (tokens[i+1].compare("off") == 0) {
mkarlsso	2:298679fff37c	2211	stream = false;
mkarlsso	2:298679fff37c	2212	} else {
mkarlsso	2:298679fff37c	2213	pcPtr->printf("Error: 'updates' useage: 'updates on' or 'updates off'\r\n");
mkarlsso	2:298679fff37c	2214	lineError = true;
mkarlsso	2:298679fff37c	2215	}
mkarlsso	2:298679fff37c	2216	}
mkarlsso	2:298679fff37c	2217	i++;
mkarlsso	2:298679fff37c	2218	if ((!lineError) && (blockDepth == 0)) {
mkarlsso	2:298679fff37c	2219	if (stream) {
mkarlsso	2:298679fff37c	2220	broadCastStateChanges = true;
mkarlsso	2:298679fff37c	2221	} else {
mkarlsso	2:298679fff37c	2222	broadCastStateChanges = false;
mkarlsso	2:298679fff37c	2223	}
mkarlsso	2:298679fff37c	2224	} else if ((!lineError) && (blockDepth > 0)) {
mkarlsso	2:298679fff37c	2225	if (stream) {
mkarlsso	2:298679fff37c	2226	//action* tmpAction = new action(3); //code 3 = turn on updates
mkarlsso	2:298679fff37c	2227	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2228	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2229	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2230	lineError = true;
mkarlsso	2:298679fff37c	2231	} else {
mkarlsso	2:298679fff37c	2232	tmpAction->set(3);
mkarlsso	2:298679fff37c	2233	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2234	}
mkarlsso	2:298679fff37c	2235	} else {
mkarlsso	2:298679fff37c	2236	//action* tmpAction = new action(4); //code 4 = turn off updates
mkarlsso	2:298679fff37c	2237	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2238	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2239	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2240	lineError = true;
mkarlsso	2:298679fff37c	2241	} else {
mkarlsso	2:298679fff37c	2242	tmpAction->set(4);
mkarlsso	2:298679fff37c	2243	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2244	}
mkarlsso	2:298679fff37c	2245
mkarlsso	2:298679fff37c	2246	}
mkarlsso	2:298679fff37c	2247	}
mkarlsso	2:298679fff37c	2248
mkarlsso	2:298679fff37c	2249	//clear is used to clear things from memory---------------------------------
mkarlsso	2:298679fff37c	2250	//examples: clear all; clear callbacks; clear queue
mkarlsso	2:298679fff37c	2251	} else if (tokens[i].compare("ram") == 0) {
mkarlsso	2:298679fff37c	2252	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2253	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2254	lineError = true;
mkarlsso	2:298679fff37c	2255	}
mkarlsso	2:298679fff37c	2256	if ((!lineError) && (blockDepth > 0)) {
mkarlsso	2:298679fff37c	2257	pcPtr->printf("Error: ram statement is not allowed inside a block.\r\n");
mkarlsso	2:298679fff37c	2258	lineError = true;
mkarlsso	2:298679fff37c	2259	}
mkarlsso	2:298679fff37c	2260	if (!lineError) {
mkarlsso	2:298679fff37c	2261	DisplayRAMBanks();
mkarlsso	2:298679fff37c	2262	}
mkarlsso	2:298679fff37c	2263	} else if (tokens[i].compare("memory") == 0) {
mkarlsso	2:298679fff37c	2264	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2265	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2266	lineError = true;
mkarlsso	2:298679fff37c	2267	}
mkarlsso	2:298679fff37c	2268	if ((!lineError) && (blockDepth > 0)) {
mkarlsso	2:298679fff37c	2269	pcPtr->printf("Error: memory statement is not allowed inside a block.\r\n");
mkarlsso	2:298679fff37c	2270	lineError = true;
mkarlsso	2:298679fff37c	2271	}
mkarlsso	2:298679fff37c	2272	if (!lineError) {
mkarlsso	2:298679fff37c	2273	displayMemoryLeft();
mkarlsso	2:298679fff37c	2274	}
mkarlsso	2:298679fff37c	2275
mkarlsso	2:298679fff37c	2276
mkarlsso	2:298679fff37c	2277	} else if (tokens[i].compare("clear") == 0) { //delete all created events and variables
mkarlsso	2:298679fff37c	2278	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2279	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2280	lineError = true;
mkarlsso	2:298679fff37c	2281	}
mkarlsso	2:298679fff37c	2282	int clearMode = 0;
mkarlsso	2:298679fff37c	2283	if ((!lineError)&&(i+1 < sz)){
mkarlsso	2:298679fff37c	2284	if (tokens[i+1].compare("all") == 0) {
mkarlsso	2:298679fff37c	2285	clearMode = 1;
mkarlsso	2:298679fff37c	2286	} else if (tokens[i+1].compare("blocks") == 0) {
mkarlsso	2:298679fff37c	2287	clearMode = 2;
mkarlsso	2:298679fff37c	2288	} else if (tokens[i+1].compare("queue") == 0) {
mkarlsso	2:298679fff37c	2289	clearMode = 3;
mkarlsso	2:298679fff37c	2290	} else {
mkarlsso	2:298679fff37c	2291	pcPtr->printf("Error: clear what: all, blocks, or queue? \r\n");
mkarlsso	2:298679fff37c	2292	lineError = true;
mkarlsso	2:298679fff37c	2293	}
mkarlsso	2:298679fff37c	2294	} else {
mkarlsso	2:298679fff37c	2295	pcPtr->printf("Error: clear what: all, blocks, or queue? \r\n");
mkarlsso	2:298679fff37c	2296	lineError = true;
mkarlsso	2:298679fff37c	2297	}
mkarlsso	2:298679fff37c	2298
mkarlsso	2:298679fff37c	2299
mkarlsso	2:298679fff37c	2300	if ((!lineError) && (clearMode < 3) && (blockDepth > 0)) {
mkarlsso	2:298679fff37c	2301	pcPtr->printf("Error: 'clear all' and 'clear blocks' only allowed outside of block structures\r\n");
mkarlsso	2:298679fff37c	2302	lineError = true;
mkarlsso	2:298679fff37c	2303	}
mkarlsso	2:298679fff37c	2304	if (!lineError) {
mkarlsso	2:298679fff37c	2305	i++;
mkarlsso	2:298679fff37c	2306	//clear variables
mkarlsso	2:298679fff37c	2307	if (clearMode == 1) {
mkarlsso	2:298679fff37c	2308	while (!globalVariables.empty()) {
mkarlsso	2:298679fff37c	2309	globalVariables.pop_back();
mkarlsso	2:298679fff37c	2310	}
mkarlsso	2:298679fff37c	2311	}
mkarlsso	2:298679fff37c	2312
mkarlsso	2:298679fff37c	2313	//clear callbacks, functions, and queue
mkarlsso	2:298679fff37c	2314	if (clearMode < 3) {
mkarlsso	2:298679fff37c	2315	for (int pNum = 1; pNum <= numPorts; pNum++) {
mkarlsso	2:298679fff37c	2316	//delete portVector[pNum]->triggerUpEventPtr;
mkarlsso	2:298679fff37c	2317	if (portVector[pNum]->triggerUpEventPtr != NULL) {
mkarlsso	2:298679fff37c	2318	portVector[pNum]->triggerUpEventPtr->release();
mkarlsso	2:298679fff37c	2319	}
mkarlsso	2:298679fff37c	2320	portVector[pNum]->triggerUpEventPtr = NULL;
mkarlsso	2:298679fff37c	2321
mkarlsso	2:298679fff37c	2322	//delete portVector[pNum]->triggerDownEventPtr;
mkarlsso	2:298679fff37c	2323	if (portVector[pNum]->triggerDownEventPtr != NULL) {
mkarlsso	2:298679fff37c	2324	portVector[pNum]->triggerDownEventPtr->release();
mkarlsso	2:298679fff37c	2325	}
mkarlsso	2:298679fff37c	2326	portVector[pNum]->triggerDownEventPtr = NULL;
mkarlsso	2:298679fff37c	2327	while (!functionArray.empty()) {
mkarlsso	2:298679fff37c	2328	delete functionArray.back();
mkarlsso	2:298679fff37c	2329	functionArray.pop_back();
mkarlsso	2:298679fff37c	2330	}
mkarlsso	2:298679fff37c	2331	}
mkarlsso	2:298679fff37c	2332
mkarlsso	2:298679fff37c	2333	queuePtr->eraseQueue();
mkarlsso	2:298679fff37c	2334	}
mkarlsso	2:298679fff37c	2335
mkarlsso	2:298679fff37c	2336	if (clearMode == 4) {
mkarlsso	2:298679fff37c	2337	if (blockDepth > 0) { //we are inside a block
mkarlsso	2:298679fff37c	2338	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2339	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2340	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2341	lineError = true;
mkarlsso	2:298679fff37c	2342	} else {
mkarlsso	2:298679fff37c	2343
mkarlsso	2:298679fff37c	2344	int8_t code = 0;
mkarlsso	2:298679fff37c	2345	tmpAction->set(code);
mkarlsso	2:298679fff37c	2346	//action* tmpAction = new action(code); //code 0 = clear queue
mkarlsso	2:298679fff37c	2347	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2348	}
mkarlsso	2:298679fff37c	2349	} else {
mkarlsso	2:298679fff37c	2350	//clear queue now
mkarlsso	2:298679fff37c	2351	queuePtr->eraseQueue();
mkarlsso	2:298679fff37c	2352	}
mkarlsso	2:298679fff37c	2353	}
mkarlsso	2:298679fff37c	2354
mkarlsso	2:298679fff37c	2355
mkarlsso	2:298679fff37c	2356	}
mkarlsso	2:298679fff37c	2357
mkarlsso	2:298679fff37c	2358	//do starts a block---------------------------------------------------------
mkarlsso	2:298679fff37c	2359	//example: do in 500
mkarlsso	2:298679fff37c	2360	// ...
mkarlsso	2:298679fff37c	2361	// end
mkarlsso	2:298679fff37c	2362
mkarlsso	2:298679fff37c	2363	} else if (tokens[i].compare("do") == 0) { //the start of a block
mkarlsso	2:298679fff37c	2364
mkarlsso	2:298679fff37c	2365	if (!ifBlockInit && !whileBlockInit) {
mkarlsso	2:298679fff37c	2366
mkarlsso	2:298679fff37c	2367	if ((currentTriggerPort > 0) \|\| (currentFunction > 0)) { //check to make sure we are inside a trigger block
mkarlsso	2:298679fff37c	2368	//pcPtr->printf("Start new block\r\n");
mkarlsso	2:298679fff37c	2369
mkarlsso	2:298679fff37c	2370	} else {
mkarlsso	2:298679fff37c	2371	pcPtr->printf("Error: a statement block must be placed inside a callback or function.\r\n");
mkarlsso	2:298679fff37c	2372	lineError = true;
mkarlsso	2:298679fff37c	2373	}
mkarlsso	2:298679fff37c	2374
mkarlsso	2:298679fff37c	2375	}
mkarlsso	2:298679fff37c	2376	tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso	2:298679fff37c	2377	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2378	bool eventReserved = false;
mkarlsso	2:298679fff37c	2379	if ((tmpEvent == NULL)\|\|(tmpAction == NULL)) {
mkarlsso	2:298679fff37c	2380	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2381	lineError = true;
mkarlsso	2:298679fff37c	2382
mkarlsso	2:298679fff37c	2383	} else {
mkarlsso	2:298679fff37c	2384
mkarlsso	2:298679fff37c	2385
mkarlsso	2:298679fff37c	2386	}
mkarlsso	2:298679fff37c	2387
mkarlsso	2:298679fff37c	2388	if (i+2 < sz) { //a time delay in the block
mkarlsso	2:298679fff37c	2389
mkarlsso	2:298679fff37c	2390	if ((!lineError) && (tokens[i+1].compare("in") == 0) && (isNumber(tokens[i+2]))) {
mkarlsso	2:298679fff37c	2391
mkarlsso	2:298679fff37c	2392	currentDelay = atoi(tokens[i+2].data());
mkarlsso	2:298679fff37c	2393	if (currentDelay < 0) {
mkarlsso	2:298679fff37c	2394	pcPtr->printf("Error: block delay time must be a positive integer\r\n");
mkarlsso	2:298679fff37c	2395	lineError = true;
mkarlsso	2:298679fff37c	2396	} else if (!ifBlockInit) { //a standalone do block
mkarlsso	2:298679fff37c	2397	//tmpEvent = new event(queuePtr);
mkarlsso	2:298679fff37c	2398	tmpEvent->isUsed = true;
mkarlsso	2:298679fff37c	2399	eventReserved = true;
mkarlsso	2:298679fff37c	2400	tmpEvent->setTimeLag(currentDelay);
mkarlsso	2:298679fff37c	2401
mkarlsso	2:298679fff37c	2402	if ((!elseFlag) && ((!thenFlag))) {
mkarlsso	2:298679fff37c	2403	//tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso	2:298679fff37c	2404	tmpAction->set(tmpEvent);
mkarlsso	2:298679fff37c	2405	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2406	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2407	tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso	2:298679fff37c	2408	blockDepth = blockDepth+1;
mkarlsso	2:298679fff37c	2409	} else if (elseFlag) {
mkarlsso	2:298679fff37c	2410	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2411	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2412	tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso	2:298679fff37c	2413	} else if (thenFlag) {
mkarlsso	2:298679fff37c	2414
mkarlsso	2:298679fff37c	2415	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2416	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2417	tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso	2:298679fff37c	2418	}
mkarlsso	2:298679fff37c	2419	//pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2420	} else { //an if block
mkarlsso	2:298679fff37c	2421	tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso	2:298679fff37c	2422
mkarlsso	2:298679fff37c	2423	if (!elseFlag && !thenFlag) {
mkarlsso	2:298679fff37c	2424	if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso	2:298679fff37c	2425	tmpAction->set(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2426	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso	2:298679fff37c	2427	//tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso	2:298679fff37c	2428	}
mkarlsso	2:298679fff37c	2429	} else if (elseFlag){
mkarlsso	2:298679fff37c	2430	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2431	} else if (thenFlag){
mkarlsso	2:298679fff37c	2432	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2433
mkarlsso	2:298679fff37c	2434	}
mkarlsso	2:298679fff37c	2435	//pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2436
mkarlsso	2:298679fff37c	2437	}
mkarlsso	2:298679fff37c	2438
mkarlsso	2:298679fff37c	2439	} else if ((!lineError) && (tokens[i+1].compare("in") == 0) && (findIntVariable(tokens[i+2])!=NULL)) {
mkarlsso	2:298679fff37c	2440
mkarlsso	2:298679fff37c	2441	int* delayVar = findIntVariable(tokens[i+2]);
mkarlsso	2:298679fff37c	2442	//currentDelay = atoi(tokens[i+2].data());
mkarlsso	2:298679fff37c	2443	if (!ifBlockInit) { //a standalone do block
mkarlsso	2:298679fff37c	2444	//tmpEvent = new event(queuePtr);
mkarlsso	2:298679fff37c	2445	tmpEvent->isUsed = true;
mkarlsso	2:298679fff37c	2446	eventReserved = true;
mkarlsso	2:298679fff37c	2447	tmpEvent->setTimeLag(delayVar);
mkarlsso	2:298679fff37c	2448
mkarlsso	2:298679fff37c	2449	if ((!elseFlag) && ((!thenFlag))) {
mkarlsso	2:298679fff37c	2450	//tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso	2:298679fff37c	2451	tmpAction->set(tmpEvent);
mkarlsso	2:298679fff37c	2452	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2453	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2454	tmpEventPtrArray.back()->blockType = 2; //this is a do block
mkarlsso	2:298679fff37c	2455	blockDepth = blockDepth+1;
mkarlsso	2:298679fff37c	2456	} else if (elseFlag) {
mkarlsso	2:298679fff37c	2457	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2458	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2459	tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso	2:298679fff37c	2460	} else if (thenFlag) {
mkarlsso	2:298679fff37c	2461
mkarlsso	2:298679fff37c	2462	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2463	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2464	tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso	2:298679fff37c	2465	}
mkarlsso	2:298679fff37c	2466	//pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2467	} else { //an if block
mkarlsso	2:298679fff37c	2468	tmpEventPtrArray.back()->setTimeLag(delayVar);
mkarlsso	2:298679fff37c	2469
mkarlsso	2:298679fff37c	2470	if (!elseFlag && !thenFlag) {
mkarlsso	2:298679fff37c	2471	if (blockDepth > 1) { //this is a nested block, so add it as an action to the parent block
mkarlsso	2:298679fff37c	2472	tmpAction->set(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2473	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso	2:298679fff37c	2474	//tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso	2:298679fff37c	2475	}
mkarlsso	2:298679fff37c	2476	} else if (elseFlag){
mkarlsso	2:298679fff37c	2477	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2478	} else if (thenFlag){
mkarlsso	2:298679fff37c	2479	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2480
mkarlsso	2:298679fff37c	2481	}
mkarlsso	2:298679fff37c	2482	//pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2483
mkarlsso	2:298679fff37c	2484	}
mkarlsso	2:298679fff37c	2485
mkarlsso	2:298679fff37c	2486	} else {
mkarlsso	2:298679fff37c	2487	pcPtr->printf("Error: block delay time must be a positive integer or a variable\r\n");
mkarlsso	2:298679fff37c	2488	lineError = true;
mkarlsso	2:298679fff37c	2489	}
mkarlsso	2:298679fff37c	2490	} else if (!lineError && !ifBlockInit) { //no time delay given, standalone do
mkarlsso	2:298679fff37c	2491	currentDelay = 0;
mkarlsso	2:298679fff37c	2492	//tmpEvent = new event(queuePtr);
mkarlsso	2:298679fff37c	2493	tmpEvent->isUsed = true;
mkarlsso	2:298679fff37c	2494	eventReserved = true;
mkarlsso	2:298679fff37c	2495	tmpEvent->setTimeLag(currentDelay);
mkarlsso	2:298679fff37c	2496	if (!elseFlag && !thenFlag) {
mkarlsso	2:298679fff37c	2497	tmpAction->set(tmpEvent);
mkarlsso	2:298679fff37c	2498	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2499	//tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso	2:298679fff37c	2500	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2501	blockDepth = blockDepth+1;
mkarlsso	2:298679fff37c	2502	} else if (elseFlag) {
mkarlsso	2:298679fff37c	2503	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2504	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2505	tmpEventPtrArray.back()->blockType = 4; //an else block
mkarlsso	2:298679fff37c	2506	} else if (thenFlag) {
mkarlsso	2:298679fff37c	2507	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2508	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2509	tmpEventPtrArray.back()->blockType = 8; //a then block
mkarlsso	2:298679fff37c	2510	}
mkarlsso	2:298679fff37c	2511	//pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2512	} else if (!lineError) { //no time delay, if block
mkarlsso	2:298679fff37c	2513
mkarlsso	2:298679fff37c	2514	currentDelay = 0;
mkarlsso	2:298679fff37c	2515	tmpEventPtrArray.back()->setTimeLag(currentDelay);
mkarlsso	2:298679fff37c	2516
mkarlsso	2:298679fff37c	2517
mkarlsso	2:298679fff37c	2518	if (!elseFlag && !thenFlag) {
mkarlsso	2:298679fff37c	2519	if (blockDepth > 1) {
mkarlsso	2:298679fff37c	2520	tmpAction->set(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2521	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(tmpAction);
mkarlsso	2:298679fff37c	2522	//tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->addAction(new action(tmpEventPtrArray.back()));
mkarlsso	2:298679fff37c	2523	}
mkarlsso	2:298679fff37c	2524	} else {
mkarlsso	2:298679fff37c	2525	tmpEventPtrArray.at(tmpEventPtrArray.size()-2)->setNextElseEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2526	}
mkarlsso	2:298679fff37c	2527
mkarlsso	2:298679fff37c	2528
mkarlsso	2:298679fff37c	2529	//pcPtr->printf("Block delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2530	}
mkarlsso	2:298679fff37c	2531	if (lineError && eventReserved) {
mkarlsso	2:298679fff37c	2532	tmpEvent->release();
mkarlsso	2:298679fff37c	2533	}
mkarlsso	2:298679fff37c	2534	//close block initiation
mkarlsso	2:298679fff37c	2535	ifBlockInit = false;
mkarlsso	2:298679fff37c	2536	whileBlockInit = false;
mkarlsso	2:298679fff37c	2537	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2538	elseFlag = false;
mkarlsso	2:298679fff37c	2539	thenFlag = false;
mkarlsso	2:298679fff37c	2540
mkarlsso	2:298679fff37c	2541	//callback starts a callback block------------------------------------------
mkarlsso	2:298679fff37c	2542	//exmaple: callback portin(1) down
mkarlsso	2:298679fff37c	2543	// ...
mkarlsso	2:298679fff37c	2544	// end
mkarlsso	2:298679fff37c	2545	} else if (tokens[i].compare("callback") == 0) { //a new callback block
mkarlsso	2:298679fff37c	2546	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2547	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2548	lineError = true;
mkarlsso	2:298679fff37c	2549	}
mkarlsso	2:298679fff37c	2550	if (blockDepth != 0) {
mkarlsso	2:298679fff37c	2551	pcPtr->printf("Error: Can't declare a callback block within another block\r\n");
mkarlsso	2:298679fff37c	2552	lineError = true;
mkarlsso	2:298679fff37c	2553	}
mkarlsso	2:298679fff37c	2554	if (!lineError) {
mkarlsso	2:298679fff37c	2555	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2556	if (i+2 < sz) {
mkarlsso	2:298679fff37c	2557	if ((tokens[i+1].find("portin[") != std::string::npos) && (tokens[i+1].size() > 8) ) { //callback for a digital port
mkarlsso	2:298679fff37c	2558	int pos1 = tokens[i+1].find("portin[")+7;
mkarlsso	2:298679fff37c	2559	int pos2 = tokens[i+1].find_first_of("]",pos1);
mkarlsso	2:298679fff37c	2560	currentTriggerPort = atoi(tokens[i+1].substr(pos1,pos2-pos1).data());
mkarlsso	2:298679fff37c	2561
mkarlsso	2:298679fff37c	2562	if (currentTriggerPort <= 0) {
mkarlsso	2:298679fff37c	2563	currentTriggerPort = -1;
mkarlsso	2:298679fff37c	2564	pcPtr->printf("Error: Not a valid port number\r\n");
mkarlsso	2:298679fff37c	2565	lineError = true;
mkarlsso	2:298679fff37c	2566	}
mkarlsso	2:298679fff37c	2567	} else {
mkarlsso	2:298679fff37c	2568	pcPtr->printf("Error: Not a valid callback input\r\n");
mkarlsso	2:298679fff37c	2569	lineError = true;
mkarlsso	2:298679fff37c	2570	}
mkarlsso	2:298679fff37c	2571	if (tokens[i+2].compare("up") == 0) {
mkarlsso	2:298679fff37c	2572	currentTriggerDir = 1;
mkarlsso	2:298679fff37c	2573	} else if (tokens[i+2].compare("down") == 0) {
mkarlsso	2:298679fff37c	2574	currentTriggerDir = -1;
mkarlsso	2:298679fff37c	2575	} else {
mkarlsso	2:298679fff37c	2576	pcPtr->printf("Error: No trigger direction given\r\n");
mkarlsso	2:298679fff37c	2577	lineError = true;
mkarlsso	2:298679fff37c	2578	}
mkarlsso	2:298679fff37c	2579
mkarlsso	2:298679fff37c	2580	} else {
mkarlsso	2:298679fff37c	2581	if (!lineError) pcPtr->printf("Error: Not enough arguments for callback statement\r\n");
mkarlsso	2:298679fff37c	2582	lineError = true;
mkarlsso	2:298679fff37c	2583	}
mkarlsso	2:298679fff37c	2584	if (sz > 3) {
mkarlsso	2:298679fff37c	2585	if (!((sz == 4) && (tokens[i+3].compare("do") == 0))) {
mkarlsso	2:298679fff37c	2586	pcPtr->printf("Error: Too many arguments in callback statement\r\n");
mkarlsso	2:298679fff37c	2587	lineError = true;
mkarlsso	2:298679fff37c	2588	}
mkarlsso	2:298679fff37c	2589	}
mkarlsso	2:298679fff37c	2590
mkarlsso	2:298679fff37c	2591	tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso	2:298679fff37c	2592	if (tmpEvent != NULL) {
mkarlsso	2:298679fff37c	2593	tmpEvent->isUsed = true;
mkarlsso	2:298679fff37c	2594
mkarlsso	2:298679fff37c	2595	} else {
mkarlsso	2:298679fff37c	2596	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2597	lineError = true;
mkarlsso	2:298679fff37c	2598	}
mkarlsso	2:298679fff37c	2599	if (!lineError) {
mkarlsso	2:298679fff37c	2600	//pcPtr->printf("Current port: %d\r\n", currentTriggerPort);
mkarlsso	2:298679fff37c	2601	blockDepth = 1;
mkarlsso	2:298679fff37c	2602	i = i+2;
mkarlsso	2:298679fff37c	2603	//create new event and attach it to the port
mkarlsso	2:298679fff37c	2604	//tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso	2:298679fff37c	2605	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2606	if (currentTriggerDir == 1) {
mkarlsso	2:298679fff37c	2607
mkarlsso	2:298679fff37c	2608	portVector[currentTriggerPort]->setTriggerUpEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2609	} else {
mkarlsso	2:298679fff37c	2610
mkarlsso	2:298679fff37c	2611	portVector[currentTriggerPort]->setTriggerDownEvent(tmpEventPtrArray.back());
mkarlsso	2:298679fff37c	2612	}
mkarlsso	2:298679fff37c	2613
mkarlsso	2:298679fff37c	2614	}
mkarlsso	2:298679fff37c	2615	}
mkarlsso	2:298679fff37c	2616
mkarlsso	2:298679fff37c	2617	//if starts an if block----------------------------------------------
mkarlsso	2:298679fff37c	2618	//examples: if x < 10 && y == 1 do; if a==1 do in 1000
mkarlsso	2:298679fff37c	2619	} else if (tokens[i].compare("if") == 0) { //a new if block
mkarlsso	2:298679fff37c	2620	if (ifBlockInit \|\| whileBlockInit) {
mkarlsso	2:298679fff37c	2621	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2622	lineError = true;
mkarlsso	2:298679fff37c	2623	}
mkarlsso	2:298679fff37c	2624
mkarlsso	2:298679fff37c	2625	ifBlockInit = true;
mkarlsso	2:298679fff37c	2626	currentDelay = 0;
mkarlsso	2:298679fff37c	2627	bool eventDefined = false;
mkarlsso	2:298679fff37c	2628	tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso	2:298679fff37c	2629	if (tmpEvent != NULL) {
mkarlsso	2:298679fff37c	2630	tmpEvent->isUsed = true;
mkarlsso	2:298679fff37c	2631	eventDefined = true;
mkarlsso	2:298679fff37c	2632	} else {
mkarlsso	2:298679fff37c	2633	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2634	lineError = true;
mkarlsso	2:298679fff37c	2635	}
mkarlsso	2:298679fff37c	2636	if (!lineError) {
mkarlsso	2:298679fff37c	2637	//this is a regular event
mkarlsso	2:298679fff37c	2638	//tmpEventPtrArray.push_back(new event(queuePtr));
mkarlsso	2:298679fff37c	2639	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2640
mkarlsso	2:298679fff37c	2641	if ((!elseFlag) && ((!thenFlag))) {
mkarlsso	2:298679fff37c	2642	tmpEventPtrArray.back()->blockType = 1; //this is an if block
mkarlsso	2:298679fff37c	2643	blockDepth = blockDepth + 1;
mkarlsso	2:298679fff37c	2644	} else if (elseFlag) {
mkarlsso	2:298679fff37c	2645	tmpEventPtrArray.back()->blockType = 3; //this is an else if block
mkarlsso	2:298679fff37c	2646	} else if (thenFlag) {
mkarlsso	2:298679fff37c	2647	tmpEventPtrArray.back()->blockType = 7; //this is a then if block
mkarlsso	2:298679fff37c	2648	}
mkarlsso	2:298679fff37c	2649	}
mkarlsso	2:298679fff37c	2650
mkarlsso	2:298679fff37c	2651	if (!lineError) {
mkarlsso	2:298679fff37c	2652	//combine the condition tokens without whitespaces
mkarlsso	2:298679fff37c	2653	tmpString = "";
mkarlsso	2:298679fff37c	2654	for (unsigned j = i+1; j < sz; j++) {
mkarlsso	2:298679fff37c	2655	if (tokens[j].compare("do") != 0) {
mkarlsso	2:298679fff37c	2656	i++;
mkarlsso	2:298679fff37c	2657	tmpString.append(tokens[j]);
mkarlsso	2:298679fff37c	2658	} else {
mkarlsso	2:298679fff37c	2659	break;
mkarlsso	2:298679fff37c	2660	}
mkarlsso	2:298679fff37c	2661	}
mkarlsso	2:298679fff37c	2662	//adds the conditions to the current event
mkarlsso	2:298679fff37c	2663
mkarlsso	2:298679fff37c	2664	if (!evaluateConditions(tmpString, tmpEventPtrArray.back())) lineError = true;
mkarlsso	2:298679fff37c	2665	}
mkarlsso	2:298679fff37c	2666
mkarlsso	2:298679fff37c	2667	if (lineError && eventDefined) {
mkarlsso	2:298679fff37c	2668	tmpEvent->release();
mkarlsso	2:298679fff37c	2669	}
mkarlsso	2:298679fff37c	2670
mkarlsso	2:298679fff37c	2671
mkarlsso	2:298679fff37c	2672	//else starts an else block-------------------------------------
mkarlsso	2:298679fff37c	2673	//examples: else do in 500; else if x==7 do
mkarlsso	2:298679fff37c	2674	} else if (tokens[i].compare("else") == 0) { //an else block
mkarlsso	2:298679fff37c	2675	if (ifBlockInit \|\| whileBlockInit) {
mkarlsso	2:298679fff37c	2676	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2677	lineError = true;
mkarlsso	2:298679fff37c	2678	}
mkarlsso	2:298679fff37c	2679
mkarlsso	2:298679fff37c	2680	//trigger blocks can't have else conditions
mkarlsso	2:298679fff37c	2681	if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso	2:298679fff37c	2682	pcPtr->printf("Error: else statement can not occur after a trigger block or outside a block\r\n");
mkarlsso	2:298679fff37c	2683	lineError = true;
mkarlsso	2:298679fff37c	2684	}
mkarlsso	2:298679fff37c	2685
mkarlsso	2:298679fff37c	2686	//check to make sure we are in an 'if' block
mkarlsso	2:298679fff37c	2687	if ((!lineError) && (tmpEventPtrArray.back()->blockType != 1) && (tmpEventPtrArray.back()->blockType != 3)) { //not currently in an 'if' or 'else if' block
mkarlsso	2:298679fff37c	2688	pcPtr->printf("Error: else statement can only occur in an 'if' block\r\n");
mkarlsso	2:298679fff37c	2689	lineError = true;
mkarlsso	2:298679fff37c	2690	}
mkarlsso	2:298679fff37c	2691	if (!lineError) {
mkarlsso	2:298679fff37c	2692	elseFlag = true;
mkarlsso	2:298679fff37c	2693
mkarlsso	2:298679fff37c	2694	}
mkarlsso	2:298679fff37c	2695	} else if (tokens[i].compare("then") == 0) { //a then block
mkarlsso	2:298679fff37c	2696	if (ifBlockInit \|\| whileBlockInit) {
mkarlsso	2:298679fff37c	2697	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2698	lineError = true;
mkarlsso	2:298679fff37c	2699	}
mkarlsso	2:298679fff37c	2700
mkarlsso	2:298679fff37c	2701	//trigger blocks can't have else conditions
mkarlsso	2:298679fff37c	2702	if ((!lineError) && (blockDepth < 2) && (currentTriggerPort > -1)) {
mkarlsso	2:298679fff37c	2703	pcPtr->printf("Error: 'then' statement can only occur after a 'while' block\r\n");
mkarlsso	2:298679fff37c	2704	lineError = true;
mkarlsso	2:298679fff37c	2705	}
mkarlsso	2:298679fff37c	2706
mkarlsso	2:298679fff37c	2707	//check to make sure we are in a 'while' block
mkarlsso	2:298679fff37c	2708	if ((!lineError) && (tmpEventPtrArray.back()->blockType != 5)) { //not currently in a while block
mkarlsso	2:298679fff37c	2709	pcPtr->printf("Error: 'then' statement can only occur in a 'while' block\r\n");
mkarlsso	2:298679fff37c	2710	lineError = true;
mkarlsso	2:298679fff37c	2711	}
mkarlsso	2:298679fff37c	2712	if (!lineError) {
mkarlsso	2:298679fff37c	2713	thenFlag = true;
mkarlsso	2:298679fff37c	2714
mkarlsso	2:298679fff37c	2715	}
mkarlsso	2:298679fff37c	2716	//while starts a while block----------------------------------------
mkarlsso	2:298679fff37c	2717	//example: while x<10 do every 100
mkarlsso	2:298679fff37c	2718	// ...
mkarlsso	2:298679fff37c	2719	// end
mkarlsso	2:298679fff37c	2720	} else if (tokens[i].compare("while") == 0) { //a new while block
mkarlsso	2:298679fff37c	2721	if (ifBlockInit \|\| whileBlockInit) {
mkarlsso	2:298679fff37c	2722	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2723	lineError = true;
mkarlsso	2:298679fff37c	2724	}
mkarlsso	2:298679fff37c	2725
mkarlsso	2:298679fff37c	2726	if ((currentTriggerPort > 0) \|\| (currentFunction > 0)) { //check to make sure we are inside a trigger block
mkarlsso	2:298679fff37c	2727	//pcPtr->printf("Start new block\r\n");
mkarlsso	2:298679fff37c	2728
mkarlsso	2:298679fff37c	2729	} else {
mkarlsso	2:298679fff37c	2730	pcPtr->printf("Error: a statement block must be placed inside a callback or function.\r\n");
mkarlsso	2:298679fff37c	2731	lineError = true;
mkarlsso	2:298679fff37c	2732	}
mkarlsso	2:298679fff37c	2733	//whileBlockInit = true;
mkarlsso	2:298679fff37c	2734	currentDelay = 0;
mkarlsso	2:298679fff37c	2735
mkarlsso	2:298679fff37c	2736	tmpEvent = findFirstUnUsed(eventBlock, NUMEVENTS);
mkarlsso	2:298679fff37c	2737	if (tmpEvent != NULL) {
mkarlsso	2:298679fff37c	2738	tmpEvent->isUsed = true;
mkarlsso	2:298679fff37c	2739	tmpEvent->setTimeLag(currentDelay);
mkarlsso	2:298679fff37c	2740	} else {
mkarlsso	2:298679fff37c	2741	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2742	lineError = true;
mkarlsso	2:298679fff37c	2743	}
mkarlsso	2:298679fff37c	2744
mkarlsso	2:298679fff37c	2745	//tmpEvent = new event(queuePtr);
mkarlsso	2:298679fff37c	2746
mkarlsso	2:298679fff37c	2747
mkarlsso	2:298679fff37c	2748	if (!lineError) {
mkarlsso	2:298679fff37c	2749	//combine the condition tokens without whitespaces
mkarlsso	2:298679fff37c	2750	tmpString = "";
mkarlsso	2:298679fff37c	2751	for (unsigned j = i+1; j < sz; j++) {
mkarlsso	2:298679fff37c	2752	if (tokens[j].compare("do") != 0) {
mkarlsso	2:298679fff37c	2753	i++;
mkarlsso	2:298679fff37c	2754	tmpString.append(tokens[j]);
mkarlsso	2:298679fff37c	2755	} else {
mkarlsso	2:298679fff37c	2756	break;
mkarlsso	2:298679fff37c	2757	}
mkarlsso	2:298679fff37c	2758	}
mkarlsso	2:298679fff37c	2759	//adds the conditions to the current event
mkarlsso	2:298679fff37c	2760	if (!evaluateConditions(tmpString, tmpEvent)) lineError = true;
mkarlsso	2:298679fff37c	2761	}
mkarlsso	2:298679fff37c	2762
mkarlsso	2:298679fff37c	2763	if (!lineError) {
mkarlsso	2:298679fff37c	2764	if ((i+3) < sz) {
mkarlsso	2:298679fff37c	2765	if ((tokens[i+1].compare("do") == 0) && (tokens[i+2].compare("every") == 0)) {
mkarlsso	2:298679fff37c	2766
mkarlsso	2:298679fff37c	2767	if (isNumber(tokens[i+3])) {
mkarlsso	2:298679fff37c	2768	uint32_t period = atoi(tokens[i+3].data());
mkarlsso	2:298679fff37c	2769	if (period > 0) {
mkarlsso	2:298679fff37c	2770	//pcPtr->printf("While block\r\n");
mkarlsso	2:298679fff37c	2771
mkarlsso	2:298679fff37c	2772	//tmpEvent->whileLoopPeriod = period;
mkarlsso	2:298679fff37c	2773	tmpEvent->setWhileLoopPeriod(period);
mkarlsso	2:298679fff37c	2774	if (!elseFlag) {
mkarlsso	2:298679fff37c	2775	tmpEvent->blockType = 5; //this is a while block
mkarlsso	2:298679fff37c	2776
mkarlsso	2:298679fff37c	2777	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2778	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2779	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2780	lineError = true;
mkarlsso	2:298679fff37c	2781	} else {
mkarlsso	2:298679fff37c	2782	tmpAction->set(tmpEvent);
mkarlsso	2:298679fff37c	2783	}
mkarlsso	2:298679fff37c	2784	//tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso	2:298679fff37c	2785	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2786
mkarlsso	2:298679fff37c	2787	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2788	blockDepth = blockDepth+1;
mkarlsso	2:298679fff37c	2789	} else {
mkarlsso	2:298679fff37c	2790	tmpEvent->blockType = 6; //this is an else while block
mkarlsso	2:298679fff37c	2791	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2792	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2793	}
mkarlsso	2:298679fff37c	2794	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2795	} else {
mkarlsso	2:298679fff37c	2796	pcPtr->printf("Error: loop period must be a positive integer.\r\n");
mkarlsso	2:298679fff37c	2797	lineError = true;
mkarlsso	2:298679fff37c	2798	}
mkarlsso	2:298679fff37c	2799	} else if (findIntVariable(tokens[i+3])!=NULL) {
mkarlsso	2:298679fff37c	2800
mkarlsso	2:298679fff37c	2801	int* period = findIntVariable(tokens[i+3]);
mkarlsso	2:298679fff37c	2802	//tmpEvent->whileLoopPeriodVar = period;
mkarlsso	2:298679fff37c	2803	tmpEvent->setWhileLoopPeriod(period);
mkarlsso	2:298679fff37c	2804	if (!elseFlag) {
mkarlsso	2:298679fff37c	2805	tmpEvent->blockType = 5; //this is a while block
mkarlsso	2:298679fff37c	2806
mkarlsso	2:298679fff37c	2807	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2808	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2809	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	2810	lineError = true;
mkarlsso	2:298679fff37c	2811	} else {
mkarlsso	2:298679fff37c	2812	tmpAction->set(tmpEvent);
mkarlsso	2:298679fff37c	2813	}
mkarlsso	2:298679fff37c	2814	//tmpEventPtrArray.back()->addAction(new action(tmpEvent));
mkarlsso	2:298679fff37c	2815	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2816
mkarlsso	2:298679fff37c	2817	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2818	blockDepth = blockDepth+1;
mkarlsso	2:298679fff37c	2819	} else {
mkarlsso	2:298679fff37c	2820	tmpEvent->blockType = 6; //this is an else while block
mkarlsso	2:298679fff37c	2821	tmpEventPtrArray.back()->setNextElseEvent(tmpEvent);
mkarlsso	2:298679fff37c	2822	tmpEventPtrArray.push_back(tmpEvent);
mkarlsso	2:298679fff37c	2823	}
mkarlsso	2:298679fff37c	2824	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2825	}
mkarlsso	2:298679fff37c	2826	} else {
mkarlsso	2:298679fff37c	2827	pcPtr->printf("Error: expected a 'do every' statement\r\n");
mkarlsso	2:298679fff37c	2828	lineError = true;
mkarlsso	2:298679fff37c	2829	}
mkarlsso	2:298679fff37c	2830	} else {
mkarlsso	2:298679fff37c	2831	pcPtr->printf("Error: expected a 'do every' statement\r\n");
mkarlsso	2:298679fff37c	2832	lineError = true;
mkarlsso	2:298679fff37c	2833	}
mkarlsso	2:298679fff37c	2834	}
mkarlsso	2:298679fff37c	2835
mkarlsso	2:298679fff37c	2836	//if the line contains an '=' sign,the equality is evaulated-------------------------
mkarlsso	2:298679fff37c	2837	//examples: a = 1; a = b + 5; a = random(100); portout[2] = 1; portout[2] = flip
mkarlsso	2:298679fff37c	2838	} else if ((tmpLine.find_first_of("=") != std::string::npos) ) { //an expression
mkarlsso	2:298679fff37c	2839	if (ifBlockInit \|\| whileBlockInit \|\| elseFlag) {
mkarlsso	2:298679fff37c	2840	pcPtr->printf("Error: expected a 'do' statement\r\n");
mkarlsso	2:298679fff37c	2841	lineError = true;
mkarlsso	2:298679fff37c	2842	}
mkarlsso	2:298679fff37c	2843
mkarlsso	2:298679fff37c	2844	wholeLineEvaluated = true;
mkarlsso	2:298679fff37c	2845	tmpString = "";
mkarlsso	2:298679fff37c	2846	int spacesBeforeEqualSign = 0;
mkarlsso	2:298679fff37c	2847	bool countSpaces = true;
mkarlsso	2:298679fff37c	2848	//combine the tokens without whitespaces
mkarlsso	2:298679fff37c	2849	for (unsigned j = i; j < sz; j++) {
mkarlsso	2:298679fff37c	2850	tmpString.append(tokens[j]);
mkarlsso	2:298679fff37c	2851	if (tokens[j].find_first_of("=") != std::string::npos) {
mkarlsso	2:298679fff37c	2852	if (tokens[j].find_first_of("=") > 0) spacesBeforeEqualSign++;
mkarlsso	2:298679fff37c	2853	countSpaces = false;
mkarlsso	2:298679fff37c	2854	} else if (countSpaces) {
mkarlsso	2:298679fff37c	2855	spacesBeforeEqualSign++;
mkarlsso	2:298679fff37c	2856	}
mkarlsso	2:298679fff37c	2857	}
mkarlsso	2:298679fff37c	2858	if (!lineError && spacesBeforeEqualSign > 1) {
mkarlsso	2:298679fff37c	2859	pcPtr->printf("Error: Variable can't have a space in it.\r\n");
mkarlsso	2:298679fff37c	2860	lineError = true;
mkarlsso	2:298679fff37c	2861	}
mkarlsso	2:298679fff37c	2862
mkarlsso	2:298679fff37c	2863	if (!lineError) {
mkarlsso	2:298679fff37c	2864	if (blockDepth > 0) {
mkarlsso	2:298679fff37c	2865	action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso	2:298679fff37c	2866	if (tmpAction != NULL) {
mkarlsso	2:298679fff37c	2867	tmpEventPtrArray.back()->addAction(tmpAction);
mkarlsso	2:298679fff37c	2868	//pcPtr->printf("Added action with delay: %d\r\n", tmpEventPtrArray.back()->timeLag);
mkarlsso	2:298679fff37c	2869
mkarlsso	2:298679fff37c	2870	} else {
mkarlsso	2:298679fff37c	2871	lineError = true;
mkarlsso	2:298679fff37c	2872	}
mkarlsso	2:298679fff37c	2873
mkarlsso	2:298679fff37c	2874	} else { //assignment was written outside of any block structure, so execute now
mkarlsso	2:298679fff37c	2875
mkarlsso	2:298679fff37c	2876
mkarlsso	2:298679fff37c	2877	action* tmpAction = evaluateAssignmentForAction(tmpString);
mkarlsso	2:298679fff37c	2878
mkarlsso	3:ae33b7f5a7c1	2879	if (tmpAction != NULL) {
mkarlsso	2:298679fff37c	2880	tmpAction->execute();
mkarlsso	3:ae33b7f5a7c1	2881
mkarlsso	2:298679fff37c	2882	//delete tmpAction;
mkarlsso	2:298679fff37c	2883	tmpAction->release();
mkarlsso	2:298679fff37c	2884	} else {
mkarlsso	2:298679fff37c	2885	lineError = true;
mkarlsso	2:298679fff37c	2886	}
mkarlsso	2:298679fff37c	2887	}
mkarlsso	2:298679fff37c	2888	}
mkarlsso	2:298679fff37c	2889	} else {
mkarlsso	2:298679fff37c	2890	//if there was no match to any of the above, an error is given
mkarlsso	2:298679fff37c	2891	pcPtr->printf("Error: statement not understood.\r\n");
mkarlsso	2:298679fff37c	2892	lineError = true;
mkarlsso	2:298679fff37c	2893	}
mkarlsso	2:298679fff37c	2894
mkarlsso	2:298679fff37c	2895	if (lineError) break; //stop parsing the rest of the line if an error was detected
mkarlsso	2:298679fff37c	2896
mkarlsso	2:298679fff37c	2897	if (wholeLineEvaluated) { //some of the tokens forces the whole line to be avaluated at once
mkarlsso	2:298679fff37c	2898	i = sz; //skip ahead to end of the line
mkarlsso	2:298679fff37c	2899	}
mkarlsso	2:298679fff37c	2900
mkarlsso	2:298679fff37c	2901	}
mkarlsso	2:298679fff37c	2902
mkarlsso	2:298679fff37c	2903	//if there was an error, we quit compiling the code
mkarlsso	2:298679fff37c	2904	if (lineError) {
mkarlsso	2:298679fff37c	2905	pcPtr->printf("Line text: ");
mkarlsso	2:298679fff37c	2906	while (!tokens.empty()) {
mkarlsso	2:298679fff37c	2907	pcPtr->printf("%s ",tokens.front().data());
mkarlsso	2:298679fff37c	2908	tokens.erase(tokens.begin());
mkarlsso	2:298679fff37c	2909	}
mkarlsso	2:298679fff37c	2910	pcPtr->printf("\r\n");
mkarlsso	2:298679fff37c	2911	while (!currentBlock.empty()) {
mkarlsso	2:298679fff37c	2912	currentBlock.pop_back();
mkarlsso	2:298679fff37c	2913	}
mkarlsso	2:298679fff37c	2914	delete tmpEvent;
mkarlsso	2:298679fff37c	2915	} else {
mkarlsso	2:298679fff37c	2916
mkarlsso	2:298679fff37c	2917	while (!tokens.empty()) {
mkarlsso	2:298679fff37c	2918	tokens.pop_back();
mkarlsso	2:298679fff37c	2919	}
mkarlsso	2:298679fff37c	2920	currentBlock.pop_back();
mkarlsso	2:298679fff37c	2921	}
mkarlsso	2:298679fff37c	2922
mkarlsso	2:298679fff37c	2923	}
mkarlsso	2:298679fff37c	2924
mkarlsso	2:298679fff37c	2925	//make sure that all blocks have a matching end statement
mkarlsso	2:298679fff37c	2926	if ((!lineError)&&(blockDepth > 0)) {
mkarlsso	2:298679fff37c	2927	pcPtr->printf("Error: Missing 1 or more end statements\r\n");
mkarlsso	2:298679fff37c	2928	lineError = true;
mkarlsso	2:298679fff37c	2929	}
mkarlsso	2:298679fff37c	2930	//pcPtr->printf("~~~\r\n"); //signals that the code was compiled
mkarlsso	2:298679fff37c	2931	textDisplay.send("~~~\r\n");
mkarlsso	2:298679fff37c	2932	//displayMemoryLeft();
mkarlsso	2:298679fff37c	2933	//DisplayRAMBanks();
mkarlsso	2:298679fff37c	2934
mkarlsso	2:298679fff37c	2935	}
mkarlsso	2:298679fff37c	2936
mkarlsso	2:298679fff37c	2937
mkarlsso	2:298679fff37c	2938	//used to return a pointer to a variable, if it exists
mkarlsso	2:298679fff37c	2939	int* scriptStream::findIntVariable(string nameInput) {
mkarlsso	2:298679fff37c	2940
mkarlsso	2:298679fff37c	2941	int* outPtr = NULL;
mkarlsso	2:298679fff37c	2942	bool foundIt = false;
mkarlsso	2:298679fff37c	2943
mkarlsso	2:298679fff37c	2944	if (nameInput.find("portout") != std::string::npos) {
mkarlsso	2:298679fff37c	2945	int pos1 = nameInput.find("portout[")+8;
mkarlsso	2:298679fff37c	2946	int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso	2:298679fff37c	2947	int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso	2:298679fff37c	2948	int portVal = 0;
mkarlsso	2:298679fff37c	2949	if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso	2:298679fff37c	2950	outPtr = &portVector[portnum]->outState;
mkarlsso	2:298679fff37c	2951	foundIt = true;
mkarlsso	2:298679fff37c	2952	}
mkarlsso	2:298679fff37c	2953	} else if (nameInput.find("portin") != std::string::npos) {
mkarlsso	2:298679fff37c	2954	int pos1 = nameInput.find("portin[")+7;
mkarlsso	2:298679fff37c	2955	int pos2 = nameInput.find_first_of("]",pos1);
mkarlsso	2:298679fff37c	2956	int portnum = atoi(nameInput.substr(pos1,pos2-pos1).data());
mkarlsso	2:298679fff37c	2957	int portVal = 0;
mkarlsso	2:298679fff37c	2958	if ((portnum > 0) && (portnum <= numPorts)) {
mkarlsso	2:298679fff37c	2959	outPtr = &portVector[portnum]->inState;
mkarlsso	2:298679fff37c	2960	foundIt = true;
mkarlsso	2:298679fff37c	2961	}
mkarlsso	2:298679fff37c	2962	}
mkarlsso	2:298679fff37c	2963
mkarlsso	2:298679fff37c	2964	if (!foundIt) {
mkarlsso	2:298679fff37c	2965	std::vector<intVariable*>::size_type sz = globalVariables.size();
mkarlsso	2:298679fff37c	2966	for (unsigned i = 0; i < sz; i++) {
mkarlsso	2:298679fff37c	2967	if (nameInput.compare(globalVariables[i]->tag) == 0) {
mkarlsso	2:298679fff37c	2968	outPtr = &globalVariables[i]->value;
mkarlsso	2:298679fff37c	2969	break;
mkarlsso	2:298679fff37c	2970	}
mkarlsso	2:298679fff37c	2971	}
mkarlsso	2:298679fff37c	2972	}
mkarlsso	2:298679fff37c	2973
mkarlsso	2:298679fff37c	2974	return outPtr;
mkarlsso	2:298679fff37c	2975	}
mkarlsso	2:298679fff37c	2976
mkarlsso	2:298679fff37c	2977	bool scriptStream::createIntVariable(string nameInput) {
mkarlsso	2:298679fff37c	2978	if (findIntVariable(nameInput) == NULL) {
mkarlsso	2:298679fff37c	2979	globalVariables.push_back(new intVariable(nameInput, 0));
mkarlsso	2:298679fff37c	2980	return true;
mkarlsso	2:298679fff37c	2981	} else {
mkarlsso	2:298679fff37c	2982	return false;
mkarlsso	2:298679fff37c	2983	}
mkarlsso	2:298679fff37c	2984	}
mkarlsso	2:298679fff37c	2985
mkarlsso	2:298679fff37c	2986
mkarlsso	2:298679fff37c	2987	action* scriptStream::evaluateAssignmentForAction(string expression) {
mkarlsso	2:298679fff37c	2988
mkarlsso	2:298679fff37c	2989	//action* tmpAction = new action(); //create a new action
mkarlsso	2:298679fff37c	2990	action* tmpAction = findFirstUnUsed(actionBlock, NUMACTIONS);
mkarlsso	2:298679fff37c	2991	if (tmpAction == NULL) {
mkarlsso	2:298679fff37c	2992	pcPtr->printf("Error: no action memory slots available.\r\n");
mkarlsso	2:298679fff37c	2993	return NULL;
mkarlsso	2:298679fff37c	2994	}
mkarlsso	2:298679fff37c	2995	std::size_t stringInd;
mkarlsso	2:298679fff37c	2996	std::size_t stringInd2;
mkarlsso	2:298679fff37c	2997	string afterEqual;
mkarlsso	2:298679fff37c	2998	string beforeEqual;
mkarlsso	2:298679fff37c	2999	//The expression might have up to three variables
mkarlsso	2:298679fff37c	3000	int* tmpVar;
mkarlsso	2:298679fff37c	3001	int* tmpVar2;
mkarlsso	2:298679fff37c	3002	int* tmpVar3;
mkarlsso	2:298679fff37c	3003	stringInd = expression.find_first_of("="); //location of = sign, if it exists
mkarlsso	2:298679fff37c	3004	beforeEqual = expression.substr(0,stringInd); // the string after the = sign
mkarlsso	2:298679fff37c	3005	afterEqual = expression.substr(stringInd+1,std::string::npos); // the string after the = sign
mkarlsso	2:298679fff37c	3006	stringInd2 = afterEqual.find_first_of("+-"); //location of +/- sign (only one allowed)
mkarlsso	2:298679fff37c	3007	tmpVar = findIntVariable(expression.substr(0,stringInd)); //returns pointer to the variable
mkarlsso	2:298679fff37c	3008
mkarlsso	2:298679fff37c	3009	if (beforeEqual.find("portout[") != std::string::npos) { //set the output of a digital port
mkarlsso	2:298679fff37c	3010	int pos1 = beforeEqual.find("portout[")+8;
mkarlsso	2:298679fff37c	3011	int pos2 = beforeEqual.find_first_of("]",pos1);
mkarlsso	2:298679fff37c	3012	int portnum = atoi(beforeEqual.substr(pos1,pos2-pos1).data());
mkarlsso	2:298679fff37c	3013	int* tmpVar = findIntVariable(beforeEqual.substr(pos1,pos2-pos1)); //returns pointer to the variable, if given
mkarlsso	2:298679fff37c	3014	int portVal = 0;
mkarlsso	2:298679fff37c	3015	if ((tmpVar != NULL)\|\|((portnum > 0) && (portnum <= numPorts))) {
mkarlsso	2:298679fff37c	3016	if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso	2:298679fff37c	3017	portVal = atoi(afterEqual.data());
mkarlsso	2:298679fff37c	3018	if ((portVal == 0) \|\| (portVal == 1)) {
mkarlsso	2:298679fff37c	3019	//portMessage* tmpMessage = new portMessage(portVector[portnum],1,portVal);
mkarlsso	2:298679fff37c	3020	portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso	2:298679fff37c	3021	if (tmpMessage == NULL) {
mkarlsso	2:298679fff37c	3022	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3023	tmpAction->release();
mkarlsso	2:298679fff37c	3024	return NULL;
mkarlsso	2:298679fff37c	3025	} else {
mkarlsso	2:298679fff37c	3026	//tmpMessage->setMessage(portVector[portnum],1,portVal);
mkarlsso	2:298679fff37c	3027	if (tmpVar == NULL) { //a constant port number was given
mkarlsso	2:298679fff37c	3028	tmpMessage->setMessage(NULL,portnum,portVal);
mkarlsso	2:298679fff37c	3029	} else {
mkarlsso	2:298679fff37c	3030	tmpMessage->setMessage(tmpVar,0,portVal);
mkarlsso	2:298679fff37c	3031	}
mkarlsso	2:298679fff37c	3032	}
mkarlsso	2:298679fff37c	3033
mkarlsso	2:298679fff37c	3034
mkarlsso	2:298679fff37c	3035	tmpAction->set(tmpMessage);
mkarlsso	2:298679fff37c	3036	//pcPtr->printf("Action: digital port %d set to %d\r\n",portnum,portVal);
mkarlsso	2:298679fff37c	3037	} else {
mkarlsso	2:298679fff37c	3038	pcPtr->printf("Error: portouts can only be directly assigned a 1, 0 or 'flip'\r\n");
mkarlsso	2:298679fff37c	3039	//delete tmpAction;
mkarlsso	2:298679fff37c	3040	tmpAction->release();
mkarlsso	2:298679fff37c	3041	return NULL;
mkarlsso	2:298679fff37c	3042	}
mkarlsso	2:298679fff37c	3043	} else if (afterEqual.compare("flip") == 0) {
mkarlsso	2:298679fff37c	3044	//portMessage* tmpMessage = new portMessage(portVector[portnum],1,-1);
mkarlsso	2:298679fff37c	3045	portMessage* tmpMessage = findFirstUnUsed(portMessageBlock, NUMPORTMESSAGES);
mkarlsso	2:298679fff37c	3046	if (tmpMessage == NULL) {
mkarlsso	2:298679fff37c	3047	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3048	tmpAction->release();
mkarlsso	2:298679fff37c	3049	return NULL;
mkarlsso	2:298679fff37c	3050	} else {
mkarlsso	2:298679fff37c	3051	//tmpMessage->setMessage(portVector[portnum],1,-1);
mkarlsso	2:298679fff37c	3052	if (tmpVar == NULL) { //a constant port number was given
mkarlsso	3:ae33b7f5a7c1	3053	tmpMessage->setMessage(NULL,portnum,-1);
mkarlsso	2:298679fff37c	3054	} else {
mkarlsso	3:ae33b7f5a7c1	3055	tmpMessage->setMessage(tmpVar,0,-1);
mkarlsso	2:298679fff37c	3056	}
mkarlsso	2:298679fff37c	3057	}
mkarlsso	2:298679fff37c	3058	tmpAction->set(tmpMessage);
mkarlsso	2:298679fff37c	3059	} else {
mkarlsso	2:298679fff37c	3060	pcPtr->printf("Error: portouts can only be directly assigned a 1, 0, or 'flip'\r\n");
mkarlsso	2:298679fff37c	3061	//delete tmpAction;
mkarlsso	2:298679fff37c	3062	tmpAction->release();
mkarlsso	2:298679fff37c	3063	return NULL;
mkarlsso	2:298679fff37c	3064	}
mkarlsso	2:298679fff37c	3065	} else {
mkarlsso	2:298679fff37c	3066	pcPtr->printf("Port number not found (must be between 1 and %d, or an existing variable)\r\n", numPorts);
mkarlsso	2:298679fff37c	3067	//delete tmpAction;
mkarlsso	2:298679fff37c	3068	tmpAction->release();
mkarlsso	2:298679fff37c	3069	return NULL;
mkarlsso	2:298679fff37c	3070	}
mkarlsso	2:298679fff37c	3071	} else if (beforeEqual.find("portin") != std::string::npos) {
mkarlsso	2:298679fff37c	3072	pcPtr->printf("Error: portins can not be set\r\n");
mkarlsso	2:298679fff37c	3073	//delete tmpAction;
mkarlsso	2:298679fff37c	3074	tmpAction->release();
mkarlsso	2:298679fff37c	3075	return NULL;
mkarlsso	2:298679fff37c	3076	} else if (tmpVar != NULL) {
mkarlsso	2:298679fff37c	3077	intOperation* tmpOp;
mkarlsso	2:298679fff37c	3078	intOperation* tmpOp2;
mkarlsso	2:298679fff37c	3079	if (isNumber(afterEqual)) { //a simple numeric assign
mkarlsso	2:298679fff37c	3080	//tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso	2:298679fff37c	3081	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	2:298679fff37c	3082	if (tmpOp == NULL) {
mkarlsso	2:298679fff37c	3083	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3084	tmpAction->release();
mkarlsso	2:298679fff37c	3085	return NULL;
mkarlsso	2:298679fff37c	3086	} else {
mkarlsso	2:298679fff37c	3087	tmpOp->set(tmpVar, "=", atoi(afterEqual.data()));
mkarlsso	2:298679fff37c	3088	}
mkarlsso	2:298679fff37c	3089	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3090	//pcPtr->printf("Action: set variable to constant numeric value\r\n");
mkarlsso	2:298679fff37c	3091	} else if ((stringInd2 == std::string::npos)&&(afterEqual.find("random") != std::string::npos)) {
mkarlsso	2:298679fff37c	3092
mkarlsso	2:298679fff37c	3093	int highVal = getRandomParam(afterEqual);
mkarlsso	2:298679fff37c	3094
mkarlsso	2:298679fff37c	3095	if (highVal > 0) {
mkarlsso	2:298679fff37c	3096	//tmpOp = new intOperation(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso	2:298679fff37c	3097	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	2:298679fff37c	3098	if (tmpOp == NULL) {
mkarlsso	2:298679fff37c	3099	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3100	tmpAction->release();
mkarlsso	2:298679fff37c	3101	return NULL;
mkarlsso	2:298679fff37c	3102	} else {
mkarlsso	2:298679fff37c	3103	tmpOp->set(highVal, "=", tmpVar); //for random assignment, we reverse the input order (because of overloading uniqueness)
mkarlsso	2:298679fff37c	3104	}
mkarlsso	2:298679fff37c	3105	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3106	//pcPtr->printf("Action: set variable to random value up to %d\r\n", highVal);
mkarlsso	2:298679fff37c	3107	} else {
mkarlsso	2:298679fff37c	3108	//delete tmpAction;
mkarlsso	2:298679fff37c	3109	tmpAction->release();
mkarlsso	2:298679fff37c	3110	return NULL;
mkarlsso	2:298679fff37c	3111	}
mkarlsso	2:298679fff37c	3112
mkarlsso	2:298679fff37c	3113	} else if (stringInd2 != std::string::npos) { //a +/- operation is there
mkarlsso	2:298679fff37c	3114	string multiplier("+");
mkarlsso	2:298679fff37c	3115	int multiplierInt = 1;
mkarlsso	2:298679fff37c	3116	if (afterEqual[stringInd2] == '-') {
mkarlsso	2:298679fff37c	3117	multiplier = "-";
mkarlsso	2:298679fff37c	3118	multiplierInt = -1;
mkarlsso	2:298679fff37c	3119	}
mkarlsso	2:298679fff37c	3120	tmpVar2 = findIntVariable(afterEqual.substr(0,stringInd2)); //before the +/- sign
mkarlsso	2:298679fff37c	3121	tmpVar3 = findIntVariable(afterEqual.substr(stringInd2+1,std::string::npos)); //after the +/- sign
mkarlsso	2:298679fff37c	3122
mkarlsso	2:298679fff37c	3123	if ((tmpVar2 != NULL) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //variable +/- number
mkarlsso	2:298679fff37c	3124	if (tmpVar2 == tmpVar) {
mkarlsso	2:298679fff37c	3125	multiplier.append("="); //final sign is += or -=
mkarlsso	2:298679fff37c	3126	//tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso	2:298679fff37c	3127	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	2:298679fff37c	3128	if (tmpOp == NULL) {
mkarlsso	2:298679fff37c	3129	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3130	tmpAction->release();
mkarlsso	2:298679fff37c	3131	return NULL;
mkarlsso	2:298679fff37c	3132	} else {
mkarlsso	2:298679fff37c	3133	tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso	2:298679fff37c	3134	}
mkarlsso	2:298679fff37c	3135	tmpAction->set(tmpOp);
mkarlsso	3:ae33b7f5a7c1	3136	pcPtr->printf("Action: change variable by constant amount\r\n");
mkarlsso	2:298679fff37c	3137	} else {
mkarlsso	3:ae33b7f5a7c1	3138
mkarlsso	2:298679fff37c	3139	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3140	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3141	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3142	tmpAction->release();
mkarlsso	2:298679fff37c	3143	return NULL;
mkarlsso	2:298679fff37c	3144	} else {
mkarlsso	3:ae33b7f5a7c1	3145
mkarlsso	2:298679fff37c	3146	tmpOp2->set(tmpVar2,multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso	3:ae33b7f5a7c1	3147	//tmpOp->set(tmpVar, tmpOp2);
mkarlsso	3:ae33b7f5a7c1	3148	}
mkarlsso	3:ae33b7f5a7c1	3149
mkarlsso	3:ae33b7f5a7c1	3150	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3151	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3152	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3153	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3154	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3155	return NULL;
mkarlsso	3:ae33b7f5a7c1	3156	} else {
mkarlsso	2:298679fff37c	3157	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	3:ae33b7f5a7c1	3158	}
mkarlsso	3:ae33b7f5a7c1	3159
mkarlsso	2:298679fff37c	3160	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3161	//pcPtr->printf("Action: variable equals expression\r\n");
mkarlsso	2:298679fff37c	3162	}
mkarlsso	2:298679fff37c	3163
mkarlsso	2:298679fff37c	3164	} else if ((tmpVar3 != NULL) && isNumber(afterEqual.substr(0,stringInd2))) { //number +/- variable
mkarlsso	2:298679fff37c	3165	if (tmpVar3 == tmpVar) {
mkarlsso	3:ae33b7f5a7c1	3166	multiplier.append("="); //makes "+=" or "-="
mkarlsso	2:298679fff37c	3167	//tmpOp = new intOperation(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso	2:298679fff37c	3168	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	2:298679fff37c	3169	if (tmpOp == NULL) {
mkarlsso	2:298679fff37c	3170	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3171	tmpAction->release();
mkarlsso	2:298679fff37c	3172	return NULL;
mkarlsso	2:298679fff37c	3173	} else {
mkarlsso	2:298679fff37c	3174	tmpOp->set(tmpVar, multiplier.data(), atoi(afterEqual.substr(0,stringInd2).data()));
mkarlsso	2:298679fff37c	3175	}
mkarlsso	2:298679fff37c	3176	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3177	//pcPtr->printf("Action: change variable by constant amount\r\n");
mkarlsso	2:298679fff37c	3178	} else {
mkarlsso	3:ae33b7f5a7c1	3179
mkarlsso	2:298679fff37c	3180	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3181	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3182	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3183	tmpAction->release();
mkarlsso	2:298679fff37c	3184	return NULL;
mkarlsso	2:298679fff37c	3185	} else {
mkarlsso	3:ae33b7f5a7c1	3186	tmpOp2->set(tmpVar3, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso	3:ae33b7f5a7c1	3187	}
mkarlsso	3:ae33b7f5a7c1	3188	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3189
mkarlsso	3:ae33b7f5a7c1	3190	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3191	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3192	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3193	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3194	return NULL;
mkarlsso	3:ae33b7f5a7c1	3195	} else {
mkarlsso	2:298679fff37c	3196	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	2:298679fff37c	3197	}
mkarlsso	2:298679fff37c	3198	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3199	//pcPtr->printf("Action: variable equals expression\r\n");
mkarlsso	2:298679fff37c	3200	}
mkarlsso	2:298679fff37c	3201
mkarlsso	2:298679fff37c	3202	} else if ((tmpVar2 != NULL) && (tmpVar3 != NULL)) { //variable +/- variable
mkarlsso	3:ae33b7f5a7c1	3203
mkarlsso	2:298679fff37c	3204	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3205	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3206	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3207	tmpAction->release();
mkarlsso	2:298679fff37c	3208	return NULL;
mkarlsso	2:298679fff37c	3209	} else {
mkarlsso	3:ae33b7f5a7c1	3210	tmpOp2->set(tmpVar2, multiplier.data(), tmpVar3);
mkarlsso	3:ae33b7f5a7c1	3211	}
mkarlsso	3:ae33b7f5a7c1	3212	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3213
mkarlsso	3:ae33b7f5a7c1	3214	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3215	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3216	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3217	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3218	return NULL;
mkarlsso	3:ae33b7f5a7c1	3219	} else {
mkarlsso	3:ae33b7f5a7c1	3220
mkarlsso	2:298679fff37c	3221	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	2:298679fff37c	3222	}
mkarlsso	2:298679fff37c	3223	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3224	//pcPtr->printf("Action: set variable to operation involving two variables\r\n");
mkarlsso	2:298679fff37c	3225	//tmpVar->value = tmpVar2->value + (multiplier * tmpVar3->value);
mkarlsso	2:298679fff37c	3226	} else if ( isNumber(afterEqual.substr(stringInd2+1,std::string::npos)) && isNumber(afterEqual.substr(0,stringInd2)) ) { //number +/- number
mkarlsso	2:298679fff37c	3227	//tmpOp = new intOperation(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso	2:298679fff37c	3228	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	2:298679fff37c	3229	if (tmpOp == NULL) {
mkarlsso	2:298679fff37c	3230	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3231	tmpAction->release();
mkarlsso	2:298679fff37c	3232	return NULL;
mkarlsso	2:298679fff37c	3233	} else {
mkarlsso	2:298679fff37c	3234	tmpOp->set(tmpVar, "=", atoi(afterEqual.substr(0,stringInd2).data()) + (multiplierInt * atoi(afterEqual.substr(stringInd2+1,std::string::npos).data())));
mkarlsso	2:298679fff37c	3235	}
mkarlsso	2:298679fff37c	3236	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3237	//pcPtr->printf("Action: set variable to constant numeric value\r\n");
mkarlsso	2:298679fff37c	3238
mkarlsso	2:298679fff37c	3239	} else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && isNumber(afterEqual.substr(stringInd2+1,std::string::npos))) { //random +/- number
mkarlsso	2:298679fff37c	3240	int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso	2:298679fff37c	3241
mkarlsso	2:298679fff37c	3242	if (highVal > 0) {
mkarlsso	3:ae33b7f5a7c1	3243
mkarlsso	3:ae33b7f5a7c1	3244
mkarlsso	2:298679fff37c	3245	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3246	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3247	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3248	tmpAction->release();
mkarlsso	2:298679fff37c	3249	return NULL;
mkarlsso	2:298679fff37c	3250	} else {
mkarlsso	3:ae33b7f5a7c1	3251	tmpOp2->set(highVal, multiplier.data(), atoi(afterEqual.substr(stringInd2+1,std::string::npos).data()));
mkarlsso	3:ae33b7f5a7c1	3252	}
mkarlsso	3:ae33b7f5a7c1	3253	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3254
mkarlsso	3:ae33b7f5a7c1	3255	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3256	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3257	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3258	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3259	return NULL;
mkarlsso	3:ae33b7f5a7c1	3260	} else {
mkarlsso	2:298679fff37c	3261	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	2:298679fff37c	3262	}
mkarlsso	2:298679fff37c	3263	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3264	//pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso	2:298679fff37c	3265	} else {
mkarlsso	2:298679fff37c	3266	//delete tmpAction;
mkarlsso	2:298679fff37c	3267	tmpAction->release();
mkarlsso	2:298679fff37c	3268	return NULL;
mkarlsso	2:298679fff37c	3269	}
mkarlsso	2:298679fff37c	3270	} else if ((afterEqual.substr(0,stringInd2).find("random") != std::string::npos) && (tmpVar3 != NULL)) { //random +/- variable
mkarlsso	2:298679fff37c	3271	int highVal = getRandomParam(afterEqual.substr(0,stringInd2));
mkarlsso	2:298679fff37c	3272
mkarlsso	2:298679fff37c	3273	if (highVal > 0) {
mkarlsso	3:ae33b7f5a7c1	3274
mkarlsso	3:ae33b7f5a7c1	3275
mkarlsso	2:298679fff37c	3276	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3277	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3278	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3279	tmpAction->release();
mkarlsso	2:298679fff37c	3280	return NULL;
mkarlsso	2:298679fff37c	3281	} else {
mkarlsso	3:ae33b7f5a7c1	3282	tmpOp2->set(highVal, multiplier.data(), tmpVar3);
mkarlsso	3:ae33b7f5a7c1	3283	}
mkarlsso	3:ae33b7f5a7c1	3284	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3285	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3286	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3287	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3288	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3289	return NULL;
mkarlsso	3:ae33b7f5a7c1	3290	} else {
mkarlsso	2:298679fff37c	3291	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	2:298679fff37c	3292	}
mkarlsso	2:298679fff37c	3293	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3294	//pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso	2:298679fff37c	3295	} else {
mkarlsso	2:298679fff37c	3296	//delete tmpAction;
mkarlsso	2:298679fff37c	3297	tmpAction->release();
mkarlsso	2:298679fff37c	3298	return NULL;
mkarlsso	2:298679fff37c	3299	}
mkarlsso	2:298679fff37c	3300
mkarlsso	2:298679fff37c	3301
mkarlsso	2:298679fff37c	3302	} else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && isNumber(afterEqual.substr(0,stringInd2))) { //random +/- number
mkarlsso	2:298679fff37c	3303	int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso	2:298679fff37c	3304
mkarlsso	2:298679fff37c	3305	if (highVal > 0) {
mkarlsso	3:ae33b7f5a7c1	3306
mkarlsso	3:ae33b7f5a7c1	3307
mkarlsso	2:298679fff37c	3308	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3309	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3310	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3311	tmpAction->release();
mkarlsso	2:298679fff37c	3312	return NULL;
mkarlsso	2:298679fff37c	3313	} else {
mkarlsso	3:ae33b7f5a7c1	3314	tmpOp2->set(highVal, multiplier.data(), atoi(afterEqual.substr(0, stringInd2).data()));
mkarlsso	3:ae33b7f5a7c1	3315	}
mkarlsso	3:ae33b7f5a7c1	3316	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3317	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3318	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3319	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3320	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3321	return NULL;
mkarlsso	3:ae33b7f5a7c1	3322	} else {
mkarlsso	2:298679fff37c	3323	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	2:298679fff37c	3324	}
mkarlsso	2:298679fff37c	3325	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3326	//pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso	2:298679fff37c	3327	} else {
mkarlsso	2:298679fff37c	3328	//delete tmpAction;
mkarlsso	2:298679fff37c	3329	tmpAction->release();
mkarlsso	2:298679fff37c	3330	return NULL;
mkarlsso	2:298679fff37c	3331	}
mkarlsso	2:298679fff37c	3332	} else if ((afterEqual.substr(stringInd2+1,std::string::npos).find("random") != std::string::npos) && (tmpVar2 != NULL)) { //random +/- number
mkarlsso	2:298679fff37c	3333	int highVal = getRandomParam(afterEqual.substr(stringInd2+1,std::string::npos));
mkarlsso	2:298679fff37c	3334
mkarlsso	2:298679fff37c	3335	if (highVal > 0) {
mkarlsso	3:ae33b7f5a7c1	3336
mkarlsso	3:ae33b7f5a7c1	3337
mkarlsso	2:298679fff37c	3338	tmpOp2 = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3339	if (tmpOp2 == NULL) {
mkarlsso	2:298679fff37c	3340	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3341	tmpAction->release();
mkarlsso	2:298679fff37c	3342	return NULL;
mkarlsso	2:298679fff37c	3343	} else {
mkarlsso	3:ae33b7f5a7c1	3344	tmpOp2->set(highVal, multiplier.data(), tmpVar2);
mkarlsso	3:ae33b7f5a7c1	3345	}
mkarlsso	3:ae33b7f5a7c1	3346	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	3:ae33b7f5a7c1	3347	if (tmpOp == NULL) {
mkarlsso	3:ae33b7f5a7c1	3348	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	3:ae33b7f5a7c1	3349	tmpOp2->release();
mkarlsso	3:ae33b7f5a7c1	3350	tmpAction->release();
mkarlsso	3:ae33b7f5a7c1	3351	return NULL;
mkarlsso	3:ae33b7f5a7c1	3352	} else {
mkarlsso	2:298679fff37c	3353	tmpOp->set(tmpVar, tmpOp2);
mkarlsso	2:298679fff37c	3354	}
mkarlsso	2:298679fff37c	3355	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3356	//pcPtr->printf("Action: set variable to random value plus number %d\r\n", highVal);
mkarlsso	2:298679fff37c	3357	} else {
mkarlsso	2:298679fff37c	3358	//delete tmpAction;
mkarlsso	2:298679fff37c	3359	tmpAction->release();
mkarlsso	2:298679fff37c	3360	return NULL;
mkarlsso	2:298679fff37c	3361	}
mkarlsso	2:298679fff37c	3362	} else {
mkarlsso	2:298679fff37c	3363	pcPtr->printf("Expression not understood: %s\r\n",afterEqual.data());
mkarlsso	2:298679fff37c	3364	//delete tmpAction;
mkarlsso	2:298679fff37c	3365	tmpAction->release();
mkarlsso	2:298679fff37c	3366	return NULL;
mkarlsso	2:298679fff37c	3367	}
mkarlsso	2:298679fff37c	3368
mkarlsso	2:298679fff37c	3369	} else if (findIntVariable(afterEqual) != NULL) { //assign value of another variable
mkarlsso	2:298679fff37c	3370	//tmpOp = new intOperation(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso	2:298679fff37c	3371	tmpOp = findFirstUnUsed(intOperationBlock, NUMINTOPERATIONS);
mkarlsso	2:298679fff37c	3372	if (tmpOp == NULL) {
mkarlsso	2:298679fff37c	3373	pcPtr->printf("Error: no memory slots available.\r\n");
mkarlsso	2:298679fff37c	3374	tmpAction->release();
mkarlsso	2:298679fff37c	3375	return NULL;
mkarlsso	2:298679fff37c	3376	} else {
mkarlsso	2:298679fff37c	3377	tmpOp->set(tmpVar, "=", findIntVariable(afterEqual));
mkarlsso	2:298679fff37c	3378	}
mkarlsso	2:298679fff37c	3379	tmpAction->set(tmpOp);
mkarlsso	2:298679fff37c	3380	//pcPtr->printf("Action: set variable to value of another\r\n");
mkarlsso	2:298679fff37c	3381	} else {
mkarlsso	2:298679fff37c	3382	pcPtr->printf("Variable not found: %s\r\n",afterEqual.data());
mkarlsso	2:298679fff37c	3383	//delete tmpAction;
mkarlsso	2:298679fff37c	3384	tmpAction->release();
mkarlsso	2:298679fff37c	3385	return NULL;
mkarlsso	2:298679fff37c	3386	}
mkarlsso	2:298679fff37c	3387
mkarlsso	2:298679fff37c	3388	} else {
mkarlsso	2:298679fff37c	3389	pcPtr->printf("Variable not found\r\n");
mkarlsso	2:298679fff37c	3390	//delete tmpAction;
mkarlsso	2:298679fff37c	3391	tmpAction->release();
mkarlsso	2:298679fff37c	3392	return NULL;
mkarlsso	2:298679fff37c	3393	}
mkarlsso	2:298679fff37c	3394	return tmpAction;
mkarlsso	2:298679fff37c	3395	}
mkarlsso	2:298679fff37c	3396
mkarlsso	2:298679fff37c	3397	bool scriptStream::isOutsideParenth(string expression,std::size_t foundItem) {
mkarlsso	2:298679fff37c	3398
mkarlsso	2:298679fff37c	3399	int pDepth = 0; // How many nested parentheses
mkarlsso	2:298679fff37c	3400	//pcPtr->printf("Check outside parentheses...");
mkarlsso	2:298679fff37c	3401	if (foundItem < expression.length()) {
mkarlsso	2:298679fff37c	3402	for (int i = 0; i <= foundItem; i++) {
mkarlsso	2:298679fff37c	3403	if (expression[i] == '(') {
mkarlsso	2:298679fff37c	3404	pDepth++;
mkarlsso	2:298679fff37c	3405	} else if (expression[i] == ')') {
mkarlsso	2:298679fff37c	3406	pDepth--;
mkarlsso	2:298679fff37c	3407	}
mkarlsso	2:298679fff37c	3408	}
mkarlsso	2:298679fff37c	3409	if (pDepth<=0) {
mkarlsso	2:298679fff37c	3410	//pcPtr->printf("yes.");
mkarlsso	2:298679fff37c	3411	return true;
mkarlsso	2:298679fff37c	3412	} else {
mkarlsso	2:298679fff37c	3413	//pcPtr->printf("no.");
mkarlsso	2:298679fff37c	3414	return false;
mkarlsso	2:298679fff37c	3415	}
mkarlsso	2:298679fff37c	3416	} else {
mkarlsso	2:298679fff37c	3417	return true;
mkarlsso	2:298679fff37c	3418	}
mkarlsso	2:298679fff37c	3419
mkarlsso	2:298679fff37c	3420	}
mkarlsso	2:298679fff37c	3421
mkarlsso	2:298679fff37c	3422	std::size_t scriptStream::findFirstOrOutsideParenth(string expression) {
mkarlsso	2:298679fff37c	3423
mkarlsso	2:298679fff37c	3424	std::size_t foundItem = expression.find("\|\|");
mkarlsso	2:298679fff37c	3425	while (foundItem != std::string::npos) {
mkarlsso	2:298679fff37c	3426	if (isOutsideParenth(expression,foundItem)) {
mkarlsso	2:298679fff37c	3427	break;
mkarlsso	2:298679fff37c	3428	}
mkarlsso	2:298679fff37c	3429	foundItem = expression.find("\|\|",foundItem+1);
mkarlsso	2:298679fff37c	3430	}
mkarlsso	2:298679fff37c	3431	return foundItem;
mkarlsso	2:298679fff37c	3432	}
mkarlsso	2:298679fff37c	3433
mkarlsso	2:298679fff37c	3434	std::size_t scriptStream::findFirstAndOutsideParenth(string expression) {
mkarlsso	2:298679fff37c	3435
mkarlsso	2:298679fff37c	3436	std::size_t foundItem = expression.find("&&");
mkarlsso	2:298679fff37c	3437	while (foundItem != std::string::npos) {
mkarlsso	2:298679fff37c	3438	if (isOutsideParenth(expression,foundItem)){
mkarlsso	2:298679fff37c	3439	break;
mkarlsso	2:298679fff37c	3440	}
mkarlsso	2:298679fff37c	3441	foundItem = expression.find("&&",foundItem+1);
mkarlsso	2:298679fff37c	3442	}
mkarlsso	2:298679fff37c	3443	return foundItem;
mkarlsso	2:298679fff37c	3444	}
mkarlsso	2:298679fff37c	3445
mkarlsso	2:298679fff37c	3446	condition* scriptStream::parseConditions(string expression) {
mkarlsso	2:298679fff37c	3447	//This function is used to parse a condition string
mkarlsso	2:298679fff37c	3448	//such as (x < y && x != z) \|\| (y == 2)
mkarlsso	2:298679fff37c	3449	//This function first identifies the root node of the logic tree
mkarlsso	2:298679fff37c	3450	//based on operator precedence ( () > && > \|\| ), and then recursively calls itself
mkarlsso	2:298679fff37c	3451	//to find the nodes of the branches. The basic building blocks of
mkarlsso	2:298679fff37c	3452	//the final condition object are arithmatic comparitors (a > b) and
mkarlsso	2:298679fff37c	3453	//other condition objects.
mkarlsso	2:298679fff37c	3454
mkarlsso	2:298679fff37c	3455
mkarlsso	2:298679fff37c	3456	//pcPtr->printf("Parsing condition: %s\r\n", expression.data());
mkarlsso	2:298679fff37c	3457	condition* newCondition = NULL;
mkarlsso	2:298679fff37c	3458	bool singleCondition = false; //no compound conditions
mkarlsso	2:298679fff37c	3459	string afterComparator;
mkarlsso	2:298679fff37c	3460	string beforeComparator;
mkarlsso	2:298679fff37c	3461
mkarlsso	2:298679fff37c	3462	std::size_t found;
mkarlsso	2:298679fff37c	3463
mkarlsso	2:298679fff37c	3464	//To make a parse tree, we start by looking for operators with the lowest precendence
mkarlsso	2:298679fff37c	3465	//so we look for OR conditions first
mkarlsso	2:298679fff37c	3466	char currentOperator = OR_CONDITION;
mkarlsso	2:298679fff37c	3467	//pcPtr->printf("Looking for OR condition...");
mkarlsso	2:298679fff37c	3468	found = findFirstOrOutsideParenth(expression);
mkarlsso	2:298679fff37c	3469	if (found==std::string::npos) { //no or conditions outside parentheses found, so we look for AND conditions
mkarlsso	2:298679fff37c	3470	currentOperator = AND_CONDITION;
mkarlsso	2:298679fff37c	3471	//pcPtr->printf("Looking for AND condition...");
mkarlsso	2:298679fff37c	3472	found = findFirstAndOutsideParenth(expression);
mkarlsso	2:298679fff37c	3473	}
mkarlsso	2:298679fff37c	3474	if (found==std::string::npos) { //no or/and conditions outside parentheses found
mkarlsso	2:298679fff37c	3475	//if the expression is encapsulated in parentheses, remove the parentheses
mkarlsso	2:298679fff37c	3476	bool removedParenth = false;
mkarlsso	2:298679fff37c	3477	if ((expression[0] == '(') && (expression[expression.length()-1] == ')')) {
mkarlsso	2:298679fff37c	3478	//pcPtr->printf("Remove parentheses");
mkarlsso	2:298679fff37c	3479	expression = expression.substr(1,expression.length()-2);
mkarlsso	2:298679fff37c	3480	removedParenth = true;
mkarlsso	2:298679fff37c	3481	}
mkarlsso	2:298679fff37c	3482	if (removedParenth) { //we removed parentheses, so try again
mkarlsso	2:298679fff37c	3483	return parseConditions(expression);
mkarlsso	2:298679fff37c	3484	} else {
mkarlsso	2:298679fff37c	3485	singleCondition = true; //we assume that the condition is non-compound, i.e., a>b
mkarlsso	2:298679fff37c	3486	}
mkarlsso	2:298679fff37c	3487	}
mkarlsso	2:298679fff37c	3488
mkarlsso	2:298679fff37c	3489	if (singleCondition) { //no compound conditions found
mkarlsso	2:298679fff37c	3490	//pcPtr->printf("Single condition");
mkarlsso	2:298679fff37c	3491	std::size_t equalStringInd;
mkarlsso	2:298679fff37c	3492	std::size_t greaterOrEqualStringInd;
mkarlsso	2:298679fff37c	3493	std::size_t lessThanOrEqualStringInd;
mkarlsso	2:298679fff37c	3494	std::size_t notEqualStringInd;
mkarlsso	2:298679fff37c	3495	std::size_t greaterThanStringInd;
mkarlsso	2:298679fff37c	3496	std::size_t lessThanStringInd;
mkarlsso	2:298679fff37c	3497	std::size_t generalCompareStringInd;
mkarlsso	2:298679fff37c	3498
mkarlsso	2:298679fff37c	3499
mkarlsso	2:298679fff37c	3500	string tmpCondition = expression;
mkarlsso	2:298679fff37c	3501	string compareString;
mkarlsso	2:298679fff37c	3502	//The expression might have up to three variables
mkarlsso	2:298679fff37c	3503	int* tmpVar;
mkarlsso	2:298679fff37c	3504	int* tmpVar2;
mkarlsso	2:298679fff37c	3505	int* tmpVar3;
mkarlsso	2:298679fff37c	3506
mkarlsso	2:298679fff37c	3507	int offset = 0;
mkarlsso	2:298679fff37c	3508	equalStringInd = tmpCondition.find("=="); //location of comparator
mkarlsso	2:298679fff37c	3509	greaterOrEqualStringInd = tmpCondition.find(">="); //location of comparator
mkarlsso	2:298679fff37c	3510	lessThanOrEqualStringInd = tmpCondition.find("<="); //location of comparator
mkarlsso	2:298679fff37c	3511	notEqualStringInd = tmpCondition.find("!="); //location of comparator
mkarlsso	2:298679fff37c	3512	greaterThanStringInd = tmpCondition.find_first_of(">"); //location of comparator
mkarlsso	2:298679fff37c	3513	lessThanStringInd = tmpCondition.find_first_of("<"); //location of comparator
mkarlsso	2:298679fff37c	3514
mkarlsso	2:298679fff37c	3515	if ((equalStringInd != std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3516	(lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso	2:298679fff37c	3517
mkarlsso	2:298679fff37c	3518	generalCompareStringInd = equalStringInd;
mkarlsso	2:298679fff37c	3519	compareString = "==";
mkarlsso	2:298679fff37c	3520	} else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd != std::string::npos) &&
mkarlsso	2:298679fff37c	3521	(lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso	2:298679fff37c	3522
mkarlsso	2:298679fff37c	3523	generalCompareStringInd = greaterOrEqualStringInd;
mkarlsso	2:298679fff37c	3524	compareString = ">=";
mkarlsso	2:298679fff37c	3525	} else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3526	(lessThanOrEqualStringInd != std::string::npos) && (notEqualStringInd == std::string::npos)){
mkarlsso	2:298679fff37c	3527
mkarlsso	2:298679fff37c	3528	generalCompareStringInd = lessThanOrEqualStringInd;
mkarlsso	2:298679fff37c	3529	compareString = "<=";
mkarlsso	2:298679fff37c	3530	} else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3531	(lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd != std::string::npos)){
mkarlsso	2:298679fff37c	3532
mkarlsso	2:298679fff37c	3533	generalCompareStringInd = notEqualStringInd;
mkarlsso	2:298679fff37c	3534	compareString = "!=";
mkarlsso	2:298679fff37c	3535	} else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3536	(lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3537	(greaterThanStringInd != std::string::npos) && (lessThanStringInd == std::string::npos)){
mkarlsso	2:298679fff37c	3538
mkarlsso	2:298679fff37c	3539	generalCompareStringInd = greaterThanStringInd;
mkarlsso	2:298679fff37c	3540	compareString = ">";
mkarlsso	2:298679fff37c	3541	offset = 1;
mkarlsso	2:298679fff37c	3542	} else if ((equalStringInd == std::string::npos) && (greaterOrEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3543	(lessThanOrEqualStringInd == std::string::npos) && (notEqualStringInd == std::string::npos) &&
mkarlsso	2:298679fff37c	3544	(greaterThanStringInd == std::string::npos) && (lessThanStringInd != std::string::npos)){
mkarlsso	2:298679fff37c	3545
mkarlsso	2:298679fff37c	3546	generalCompareStringInd = lessThanStringInd;
mkarlsso	2:298679fff37c	3547	compareString = "<";
mkarlsso	2:298679fff37c	3548	offset = 1;
mkarlsso	2:298679fff37c	3549
mkarlsso	2:298679fff37c	3550	}else {
mkarlsso	2:298679fff37c	3551	pcPtr->printf("Condition not understood: %s\r\n", expression.data());
mkarlsso	2:298679fff37c	3552	return 0;
mkarlsso	2:298679fff37c	3553	}
mkarlsso	2:298679fff37c	3554
mkarlsso	2:298679fff37c	3555	intCompare* newCompare = findFirstUnUsed(intCompareBlock, NUMINTCOMPARE);
mkarlsso	2:298679fff37c	3556	if (newCompare == NULL) {
mkarlsso	2:298679fff37c	3557	pcPtr->printf("Error: No memory slots available.");
mkarlsso	2:298679fff37c	3558	return NULL;
mkarlsso	2:298679fff37c	3559	}
mkarlsso	2:298679fff37c	3560	newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso	2:298679fff37c	3561	if (newCondition == NULL) {
mkarlsso	2:298679fff37c	3562	pcPtr->printf("Error: No memory slots available.");
mkarlsso	2:298679fff37c	3563	return NULL;
mkarlsso	2:298679fff37c	3564	}
mkarlsso	2:298679fff37c	3565	afterComparator = tmpCondition.substr(generalCompareStringInd+2-offset,std::string::npos);
mkarlsso	2:298679fff37c	3566
mkarlsso	2:298679fff37c	3567	beforeComparator = tmpCondition.substr(0,generalCompareStringInd);
mkarlsso	2:298679fff37c	3568	tmpVar = findIntVariable(beforeComparator); //returns pointer to the variable
mkarlsso	2:298679fff37c	3569	if (tmpVar != NULL) { //before the comparator is a single variable
mkarlsso	2:298679fff37c	3570	tmpVar2 = findIntVariable(afterComparator); //returns pointer to the variable
mkarlsso	2:298679fff37c	3571	if (tmpVar2 != NULL) { //we are comapring a single variable to another
mkarlsso	2:298679fff37c	3572	//intCompare* newCompare = new intCompare(tmpVar,compareString.data(),tmpVar2);
mkarlsso	2:298679fff37c	3573	//currentEvent->addCondition(new condition(newCompare));
mkarlsso	2:298679fff37c	3574	newCompare->set(tmpVar,compareString.data(),tmpVar2);
mkarlsso	2:298679fff37c	3575	newCondition->set(newCompare);
mkarlsso	2:298679fff37c	3576
mkarlsso	2:298679fff37c	3577	//pcPtr->printf("Var vs. Var condition added: %s\r\n", tmpCondition.data());
mkarlsso	2:298679fff37c	3578	} else if (isNumber(afterComparator)) {
mkarlsso	2:298679fff37c	3579	//intCompare* newCompare = new intCompare(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso	2:298679fff37c	3580	//currentEvent->addCondition(new condition(newCompare));
mkarlsso	2:298679fff37c	3581	newCompare->set(tmpVar,compareString.data(),atoi(afterComparator.data()));
mkarlsso	2:298679fff37c	3582	newCondition->set(newCompare);
mkarlsso	2:298679fff37c	3583
mkarlsso	2:298679fff37c	3584	//pcPtr->printf("Var vs. Int condition added: %s\r\n", tmpCondition.data());
mkarlsso	2:298679fff37c	3585	} //more here
mkarlsso	2:298679fff37c	3586
mkarlsso	2:298679fff37c	3587	} else {
mkarlsso	2:298679fff37c	3588	pcPtr->printf("Condition not understood: %s\r\n", expression.data());
mkarlsso	2:298679fff37c	3589
mkarlsso	2:298679fff37c	3590	return NULL;
mkarlsso	2:298679fff37c	3591	}
mkarlsso	2:298679fff37c	3592
mkarlsso	2:298679fff37c	3593	} else { //this is a compound condition (with either && or \|\|)
mkarlsso	2:298679fff37c	3594	//pcPtr->printf("Compound condition");
mkarlsso	2:298679fff37c	3595	afterComparator = expression.substr(found+2,std::string::npos);
mkarlsso	2:298679fff37c	3596	beforeComparator = expression.substr(0,found);
mkarlsso	2:298679fff37c	3597	newCondition = findFirstUnUsed(conditionBlock, NUMCONDITIONS);
mkarlsso	2:298679fff37c	3598	if (newCondition == NULL) {
mkarlsso	2:298679fff37c	3599	pcPtr->printf("Error: No memory slots available.");
mkarlsso	2:298679fff37c	3600	return NULL;
mkarlsso	2:298679fff37c	3601	} else {
mkarlsso	2:298679fff37c	3602	newCondition->isUsed = true; //reserve the condition slot;
mkarlsso	2:298679fff37c	3603	}
mkarlsso	2:298679fff37c	3604	//recursively call this function to parse the sub conditions
mkarlsso	2:298679fff37c	3605	condition* cond1 = parseConditions(beforeComparator);
mkarlsso	2:298679fff37c	3606	if (cond1 == NULL) {
mkarlsso	2:298679fff37c	3607	newCondition->release();
mkarlsso	2:298679fff37c	3608	return NULL;
mkarlsso	2:298679fff37c	3609	}
mkarlsso	2:298679fff37c	3610	condition* cond2 = parseConditions(afterComparator);
mkarlsso	2:298679fff37c	3611	if (cond2 == NULL) {
mkarlsso	2:298679fff37c	3612	newCondition->release();
mkarlsso	2:298679fff37c	3613	cond1->release();
mkarlsso	2:298679fff37c	3614	return NULL;
mkarlsso	2:298679fff37c	3615	}
mkarlsso	2:298679fff37c	3616	newCondition->set(cond1,currentOperator, cond2);
mkarlsso	2:298679fff37c	3617
mkarlsso	2:298679fff37c	3618	}
mkarlsso	2:298679fff37c	3619
mkarlsso	2:298679fff37c	3620	return newCondition; //all went well, so return the newly made condition
mkarlsso	2:298679fff37c	3621
mkarlsso	2:298679fff37c	3622	}
mkarlsso	2:298679fff37c	3623
mkarlsso	2:298679fff37c	3624	bool scriptStream::evaluateConditions(string expression, event* currentEvent) {
mkarlsso	2:298679fff37c	3625	//calls the function to parse the condition string. The condition pointer is then
mkarlsso	2:298679fff37c	3626	//attached to the event
mkarlsso	2:298679fff37c	3627
mkarlsso	2:298679fff37c	3628	condition* newCondition = NULL;
mkarlsso	2:298679fff37c	3629	newCondition = parseConditions(expression);
mkarlsso	2:298679fff37c	3630	if (newCondition == NULL) {
mkarlsso	2:298679fff37c	3631	return false;
mkarlsso	2:298679fff37c	3632	} else {
mkarlsso	2:298679fff37c	3633	currentEvent->addCondition(newCondition);
mkarlsso	2:298679fff37c	3634	return true;
mkarlsso	2:298679fff37c	3635	}
mkarlsso	2:298679fff37c	3636	}
mkarlsso	2:298679fff37c	3637
mkarlsso	2:298679fff37c	3638	int scriptStream::getRandomParam(string expression) {
mkarlsso	2:298679fff37c	3639
mkarlsso	2:298679fff37c	3640	int pos1 = expression.find("random(")+7;
mkarlsso	2:298679fff37c	3641	int pos2 = expression.find_first_of(")",pos1);
mkarlsso	2:298679fff37c	3642	int highVal = atoi(expression.substr(pos1,pos2-pos1).data());
mkarlsso	2:298679fff37c	3643
mkarlsso	2:298679fff37c	3644	if ((highVal > 0)) {
mkarlsso	2:298679fff37c	3645	return highVal;
mkarlsso	2:298679fff37c	3646	} else {
mkarlsso	2:298679fff37c	3647	pcPtr->printf("Error: random parameter must be 1 or more\r\n");
mkarlsso	2:298679fff37c	3648	return 0;
mkarlsso	2:298679fff37c	3649	}
mkarlsso	2:298679fff37c	3650	}
mkarlsso	2:298679fff37c	3651
mkarlsso	2:298679fff37c	3652
mkarlsso	2:298679fff37c	3653	outputStream::outputStream(int bufferSizeIn):
mkarlsso	2:298679fff37c	3654	readHead(0),
mkarlsso	2:298679fff37c	3655	writeHead(0),
mkarlsso	2:298679fff37c	3656	totalWriteHead(0),
mkarlsso	2:298679fff37c	3657	totalReadHead(0),
mkarlsso	2:298679fff37c	3658	bufferSize(bufferSizeIn),
mkarlsso	2:298679fff37c	3659	unsentData(false) {
mkarlsso	2:298679fff37c	3660
mkarlsso	2:298679fff37c	3661	outputBuffer = new char[bufferSize];
mkarlsso	2:298679fff37c	3662
mkarlsso	2:298679fff37c	3663	}
mkarlsso	2:298679fff37c	3664
mkarlsso	2:298679fff37c	3665	outputStream::~outputStream() {
mkarlsso	2:298679fff37c	3666	delete[] outputBuffer;
mkarlsso	2:298679fff37c	3667	}
mkarlsso	2:298679fff37c	3668
mkarlsso	2:298679fff37c	3669	//adds text to the buffer
mkarlsso	2:298679fff37c	3670	void outputStream::send(string outputString) {
mkarlsso	2:298679fff37c	3671	int strLen = outputString.size();
mkarlsso	2:298679fff37c	3672
mkarlsso	2:298679fff37c	3673	int total = 0;
mkarlsso	2:298679fff37c	3674	int chunk = 0;
mkarlsso	2:298679fff37c	3675	if (!(totalWriteHead+strLen > (totalReadHead + bufferSize))) {
mkarlsso	2:298679fff37c	3676	while (strLen - total > 0) {
mkarlsso	2:298679fff37c	3677	chunk = min((bufferSize - writeHead), strLen - total);
mkarlsso	2:298679fff37c	3678	outputString.copy(outputBuffer + writeHead, chunk, total);
mkarlsso	2:298679fff37c	3679	writeHead = (writeHead + chunk) % bufferSize;
mkarlsso	2:298679fff37c	3680	totalWriteHead += chunk;
mkarlsso	2:298679fff37c	3681	total += chunk;
mkarlsso	2:298679fff37c	3682	}
mkarlsso	2:298679fff37c	3683	if (total > 0) {
mkarlsso	2:298679fff37c	3684	unsentData = true;
mkarlsso	2:298679fff37c	3685	}
mkarlsso	2:298679fff37c	3686	}
mkarlsso	2:298679fff37c	3687	}
mkarlsso	2:298679fff37c	3688
mkarlsso	2:298679fff37c	3689	//the main loop gets one character per loop and write it to the serial port
mkarlsso	2:298679fff37c	3690	char outputStream::getNextChar() {
mkarlsso	2:298679fff37c	3691
mkarlsso	2:298679fff37c	3692
mkarlsso	2:298679fff37c	3693	if (totalReadHead < totalWriteHead) {
mkarlsso	2:298679fff37c	3694	tmpOut = *(outputBuffer+readHead);
mkarlsso	2:298679fff37c	3695	readHead = (readHead+1) % bufferSize;
mkarlsso	2:298679fff37c	3696	totalReadHead++;
mkarlsso	2:298679fff37c	3697	if (totalReadHead >= totalWriteHead) {
mkarlsso	2:298679fff37c	3698	unsentData = false;
mkarlsso	2:298679fff37c	3699	}
mkarlsso	2:298679fff37c	3700	}
mkarlsso	2:298679fff37c	3701	return tmpOut;
mkarlsso	2:298679fff37c	3702
mkarlsso	2:298679fff37c	3703	}
mkarlsso	2:298679fff37c	3704

Repository toolbox

Export to desktop IDE

Build repository

Repository details

Type:	Program
Mbed OS support:	Mbed 2 deprecated
Created:	08 Jul 2014
Imports:	25
Forks:	2
Commits:	5
Dependents:	1
Dependencies:	3
Followers:	2

behave.cpp@3:ae33b7f5a7c1, 2014-07-19 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning