==text being interpreted==

line @test(%int+4),2,80,80,2

==part of execute.c==

else if(strcmp(commandBuffer,"line")==0){
				GrayClearScreen();
			char buffer2[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			sprintf(buffer2,"line");	
  		GrayDrawStr2B(0,0,buffer2,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
				counter+=5;
				short x2,y2;
				
				short debug2=parseInteger(data+counter);
				counter+=debug2;
				x=valueBuffer;
				// ##DEBUG
	
			GrayClearScreen();
			sprintf(buffer2,"Debug:%d,%u,%c,%c",x,debug2,data[counter],data[counter+1]);	
  		GrayDrawStr2B(0,0,buffer2,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();

==parse.c==

#include "parse.h"

// Don't overwrite "temporary"

unsigned short parseInteger(unsigned char* place){
	double value = 0; // This is the value that is going to be returned
	char operatorStack[11] = {0,0,0,0,0,0,0,0,0};
	double valueStack[12] = {0,0,0,0,0,0,0,0,0,0};
	unsigned short valueCounter = 0;
	unsigned short operatorCounter = 0;
	unsigned short textCounter = 0; // Holds position in text that is being parsed - is reused
	unsigned short negativeNumber = 0;
	if(place[textCounter]=='-'){
		negativeNumber=1;
		textCounter++;
	}
	
	// ##DEBUG
	char buffer10[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			GrayClearScreen();
			sprintf(buffer10,"Current Character:%c",place[textCounter]);	
  		GrayDrawStr2B(0,0,buffer10,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
pause();
	
	while(*(place+textCounter)!=',' && *(place+textCounter)!=0x0D && *(place+textCounter)!=0x20){
		// First parse for numbers
		if(*(place+textCounter)>='0' && *(place+textCounter)<='9'){
			temporary2=textCounter;
			while(*(place+textCounter)>='0' && *(place+textCounter)<='9'){
				textCounter++;
				if(textCounter-temporary2>6)programError("Number too long");
			}
			restoreNameBuffer2();
			memcpy(nameBuffer2,place+temporary2,textCounter-temporary2);
			valueStack[valueCounter]=(double)atoi(nameBuffer2);
			valueCounter++;
			textCounter--; // It's going to be added back at the end of the loop
		}
		else if(*(place+textCounter)=='@'){
			//short* temporaryPointer=parseArrayIndex(place+textCounter);
			// ## DEBUG
			// change later
			short debug=parseArrayIndex(place+textCounter);
			textCounter+=debug;
			valueStack[valueCounter]=*elementBuffer;
			valueCounter++;
			// ##DEBUG
		
			char buffer7[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			GrayClearScreen();
			sprintf(buffer7,"TextCounter:%u,%f,%c,%c",debug,valueStack[valueCounter-1],place[textCounter],place[textCounter+1]);	
  		GrayDrawStr2B(0,0,buffer7,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
pause();
			// ##ENDDEBUG
		}
		else if(*(place+textCounter)=='%'){
			temporary2=textCounter;
			textCounter++;
			while(*(place+textCounter)>='A' && *(place+textCounter)<='z'){
				textCounter++;
				if(textCounter-temporary2>7)programError("Variable name too long");
			}
			restoreNameBuffer2();
			memcpy(nameBuffer2,place+temporary2+1,textCounter-temporary2-1);
			// ##DEBUG
		
			char buffer3[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			GrayClearScreen();
			sprintf(buffer3,"Var name: %s,%c,%c",nameBuffer2,place[textCounter],place[textCounter+1]);	
  		GrayDrawStr2B(0,0,buffer3,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
			
			// ##ENDDEBUG
			for(temporary2=0;temporary2<=integerAmount;temporary2++){
				if(strcmp(integerPointer[temporary2].name,nameBuffer2)==0){
					valueStack[valueCounter]=integerPointer[temporary2].value;
					valueCounter++;
					goto integerVariableExists2;
				}
			}
			// ##DEBUG
			
			char buffer[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			sprintf(buffer,"Number: %s,%d,%s",integerPointer[0].name,integerPointer[0].value,nameBuffer2);	
  		GrayDrawStr2B(0,0,buffer,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
	pause();
				
			// ##ENDDEBUG
			programError("Undefined variable");
			integerVariableExists2:;
			textCounter--;
		}
		// Then parse for operators
		if(*(place+textCounter)=='+'){
			operatorStack[operatorCounter]='+';
			operatorCounter++;
		}
		else if(*(place+textCounter)=='-'){
			operatorStack[operatorCounter]='-';
			operatorCounter++;
		}
		else if(*(place+textCounter)=='*'){
			operatorStack[operatorCounter]='*';
			operatorCounter++;
		}
		else if(*(place+textCounter)=='/'){
			operatorStack[operatorCounter]='/';
			operatorCounter++;
		}
		else if(*(place+textCounter)=='|'){ // Modulo
			operatorStack[operatorCounter]='|';
			operatorCounter++;
		}
		/*
		else{
			programError("Mathematical syntax error");
		}
		*/
		if(valueCounter>11)programError("Value stack overflow");
		if(operatorCounter>10)programError("Operator stack overflow");
		if(operatorCounter>valueCounter)programError("Operator/value quantity");
		
		textCounter++;
	}
	
	if(negativeNumber==1)valueStack[0]*=-1;
	value=valueStack[0];
	
	for(temporary2=1;temporary2<=valueCounter;temporary2++){
		if(operatorStack[temporary2-1]=='+'){
			value+=valueStack[temporary2];
		}
		else if(operatorStack[temporary2-1]=='-'){
			value-=valueStack[temporary2];
		}
		else if(operatorStack[temporary2-1]=='*'){
			value*=valueStack[temporary2];
			
		}
		else if(operatorStack[temporary2-1]=='/'){
			value/=valueStack[temporary2];
		}
		else if(operatorStack[temporary2-1]=='|'){
			(short)value%=(short)valueStack[temporary2];
		}
	}
	
	// ##DEBUG
	/*
			char buffer2[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			sprintf(buffer2,"Value: %f,%f,%f,%f,%c",value,valueStack[0],valueStack[1],valueStack[2],operatorStack[0]);	
  		GrayDrawStr2B(0,0,buffer2,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
				*/
			// ##ENDDEBUG
	
	// ##DEBUG
	
			GrayClearScreen();
			char buffer2[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
			sprintf(buffer2,"pInt Returned: %f,%c,%c",value,data[textCounter],data[textCounter+1]);	
  		GrayDrawStr2B(0,0,buffer2,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
			
			// ##ENDDEBUG
	valueBuffer=value;
	return textCounter+1;
}

unsigned short parseString(unsigned char* place){
	place++; // First byte should always be quotation marks. If it's not, whatever.
	unsigned short textCounter = 0;
	restoreStringBuffer2();
	while(place[textCounter]!='\"'){
		textCounter++;
		if(textCounter>19)programError("String too long");
	}
	memcpy(stringBuffer2,place,textCounter);
	counter+=textCounter+2;
	return textCounter+2; // "+2" because of two quotes
}

unsigned short parseName(unsigned char* place){
	unsigned short textCounter = 0;
	restoreNameBuffer2();
	while(place[textCounter]>='A' && place[textCounter]<='z'){
		textCounter++;
		if(textCounter>7)programError("Name too long");
	}
	memcpy(nameBuffer2,place,textCounter);
	counter+=textCounter;
	return textCounter;
}
unsigned short parseArrayIndex(unsigned char* tplace){
	tplace++; // Get past "@"
	short length = -1;
	char temporaryBuffer[8];
	unsigned short index;
	index=parseName(tplace); // temporary use of "index"
	memcpy(temporaryBuffer,nameBuffer2,8); // temporaryBuffer holds array name
	tplace+=index+1; // Get passed "("
	length+=index;
	// ##DEBUG
				char buffer5[20] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
				GrayClearScreen();
			sprintf(buffer5,"ary:%c,%s,%c",*tplace,temporaryBuffer,tplace[1]);	
  		GrayDrawStr2B(0,0,buffer5,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
	length+=parseInteger(tplace); // Get index
	index=valueBuffer;
	// ##DEBUG
				GrayClearScreen();
			sprintf(buffer5,"ary:   %d",index);	
  		GrayDrawStr2B(0,0,buffer5,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
	unsigned short vatCounter;
			for(vatCounter=0;vatCounter<arrayAmount;vatCounter++){
				if(strcmp((*(arrayPointer+vatCounter)).name,temporaryBuffer)==0){
					//counter+=2;
					GrayClearScreen();
			sprintf(buffer5,"ary:     %c,%u",*(tplace+length),length);	
  		GrayDrawStr2B(0,0,buffer5,A_REPLACE,GrayGetPlane(0),GrayGetPlane(1));
				pause();
					elementBuffer=arrayPointer[vatCounter].values+index;
					return length;
			}
	}
	programError("Nonexistent array");
}