Forum: Mitt scriptspråk Sigma

 
SAY ("Hello World!")
PAUSE
SAY ("Hello World!")
KEY_WAIT
CLEAR_SCREEN
 

[sum] [=] [5] [*] [(] [multiplier] [+] [1] [)] [;] 

        [=]
       /   \
   [sum]   [*]
          /   \
        [5]   [+]
             /   \
  [multiplier]   [1] 

 
#include <stdio.h>
#define SAY(x) puts(x "n");
#define PAUSE sleep(1);
#define KEY_WAIT getchar();
#define CLEAR_SCREEN 
#define START int main(void){
#define END return 0;}
 

 
START
SAY("sdfghjk")
PAUSE
SAY("kjhgfds")
KEY_WAIT
CLEAR_SCREEN
END
 

 
echo "#include <sigma.h>" > tmp.c;
cat $1 >> tmp.c;
gcc tmp.c -o $1.out
 

/*
 * Sigma Scripting Language Parser
 * Author: Karl Mikaelsson
 * Date: 070402
 */
 
#include <iostream>
#include <sstream>
#include <map>
#include <fstream>
#include <string>
#include <queue>
using namespace std;
 
/*
 * Data structures
 */
 
enum sigma_opcode
{
	SIGMA_ILLEGAL_INSTRUCTION,
	SIGMA_PRINT,
	SIGMA_LOAD,
	SIGMA_STORE,
	SIGMA_ADD,
	SIGMA_SUB,
	SIGMA_MUL,
	SIGMA_DIV,
	SIGMA_EXIT
};
 
map<const string, const sigma_opcode> SIGMA_TRANSLATION_TABLE;
 
struct sigma_instruction
{
	sigma_opcode type;
	queue<string> arguments;
};
 
template<typename T>
struct sigma_variable
{
	string name;
	T value;
};
 
 
/*
 * Function implementations
 */
 
void sigma_print(string out);
 
template<typename T>
int sigma_load(string name, T value);
 
template<typename T>
T sigma_store(string name, T value);
 
void sigma_exit(int status);
 
 
/*
 * Internal helper functions
 */
 
sigma_instruction* sigma_translate_instruction(string instruction);
void sigma_parse(istream& is);
string sigma_readline(istream& is);
int sigma_execute(sigma_instruction* i);
void sigma_error(sigma_instruction* i, int rval);
sigma_opcode sigma_string_to_opcode(string str);
 
/*
 * Main loop
 */
 
int main(int argc, char *argv)
{
	/*
	 * Populate translation map
	 */
	SIGMA_TRANSLATION_TABLE.insert(make_pair("PRINT",SIGMA_PRINT));
	//	SIGMA_TRANSLATION_TABLE.insert(make_pair("LOAD",SIGMA_LOAD));
	//	SIGMA_TRANSLATION_TABLE.insert(make_pair("STORE", SIGMA_STORE));
	SIGMA_TRANSLATION_TABLE.insert(make_pair("EXIT", SIGMA_EXIT));
 
	/*
	 * Read from file
	 */
	
	/*
	 * Read from stdin
	 */
	
	sigma_parse(cin);
	return 0;
}
 
/* 
 * Print contents of out to stdout.
 */
 
void sigma_print(string out)
{
	cout << out;
	return;
}
 
 
/*
 * Read and execute instructions from is
 */
 
void sigma_parse(istream& is)
{
	sigma_instruction* i;
	string read_instr;
	int rval;
	while (is)
		{
			read_instr = sigma_readline(is);
			i = sigma_translate_instruction(read_instr);
			rval = sigma_execute(i);
			if (rval != 0)
				{
					sigma_error(i,rval);
					break;
				}
		};
	return;
}
 
 
/*
 * Read and return one line
 */
 
string sigma_readline(istream& is)
{
	string tmp;
	getline(is, tmp);
	return tmp;
}
 
/*
 * Return a instruction string, stripped of comments.
 */
 
string sigma_strip_comments(string in)
{
	unsigned int cpos = in.find(";");
	if (cpos == string::npos)
		{
			return in;
		}
	else
		{
			return in.substr(0,cpos);
		}
	return 0;
}
 
 
/*
 * Execute an instruction. 
 */
 
int sigma_execute(sigma_instruction* instruction)
{
	/*
	 * Look at the instruction and call appropriate
	 * function
	 */
	if (instruction == 0)
		{
			return 0;
		}
	string arg;
	switch (instruction->type)
		{
		case SIGMA_PRINT:
			while (!instruction->arguments.empty())
				{
					arg = instruction->arguments.front();
					sigma_print(arg);
					instruction->arguments.pop();
				}
			sigma_print("n");
			break;
		case SIGMA_LOAD:
			cout << "load" << endl;
			break;
		case SIGMA_STORE:
			cout << "store" << endl;
			break;
		case SIGMA_EXIT:
			cout << "exit" << endl;
			delete instruction;
			return 1;
			break;
		case SIGMA_ILLEGAL_INSTRUCTION:
		default:
			cout << "Illegal instruction" << endl;
			delete instruction;
			return -1;
			break;
		}
	delete instruction;
	return 0;
}
 
/*
 * Print an error message, given a return code and instruction
 */
 
void sigma_error(sigma_instruction* i, int rval)
{
	//	cout << SIGMA_ERROR_MESSAGE[inst.instruction_type][];
};
 
 
/*
 * Translate string into sigma_instruction*
 */ 
 
sigma_instruction* sigma_translate_instruction(string instruction)
{
	/*
	 * Strip comments from the string.
	 * If the string is empty, return 0.
	 */
	string i;
	i = sigma_strip_comments(instruction);
 
	if (i.length() == 0)
		{
			return 0;
		}
 
	sigma_instruction* si = new sigma_instruction;
 
	/*
	 * Split into function and arguments
	 */
	istringstream inst_line(i);
	
	string inst;
	inst_line >> inst;
 
	while (inst_line)
		{
			string tmp;
			inst_line >> tmp;
			si->arguments.push(tmp);
		}
 
	si->type = sigma_string_to_opcode(inst);
	return si;
};
 
 
/*
 * Translate string instruction to opcode
 */
 
sigma_opcode sigma_string_to_opcode(string str)
{
	/*
	 * Look up opcode in string->opcode map
	 */
 
	map<const string,const sigma_opcode>::iterator i = SIGMA_TRANSLATION_TABLE.find(str);
	if (i != SIGMA_TRANSLATION_TABLE.end())
		{
			return i->second;
		}
	return SIGMA_ILLEGAL_INSTRUCTION;
}