path: root/parser.cpp

#include <stdexcept>
#include <stack>
#include <cstring>
#include <cctype>
#include <cassert>
#include "parser.h"

using namespace std;


ParseError::ParseError(const string &what_arg)
	:runtime_error(what_arg){}
ParseError::ParseError(const char *what_arg)
	:runtime_error(what_arg){}


static bool isinitwordchar(char c){
	return isalpha(c)||c=='_';
}

static bool iswordchar(char c){
	return isalpha(c)||isdigit(c)||c=='_';
}

static const vector<string> tok_symbols={
	"==", "!=", ">", "<", ">=", "<=",
	":=", "=",
	"+", "-", "*", "/", "%",
	"(", ")", ",",
	"{", "}", "?{", "??{", "}&",
};

static bool isSymbolPrefix(const string &s){
	for(const string &sym : tok_symbols){
		if(s.size()<=sym.size()&&sym.substr(0,s.size())==s)return true;
	}
	return false;
}

template <typename T>
static bool contains(const vector<T> &v,const T &target){
	for(const T &t : v){
		if(t==target)return true;
	}
	return false;
}


class Token{
public:
	enum class Type{
		word,
		number,
		string,
		symbol,
		terminator,
	};

	Type type;
	string str;
	Site site;

	Token(Type type,const string &str,const Site &site)
		:type(type),str(str),site(site){}
};


class Tokeniser{
	const string &source;
	const string &filename;
	i64 idx,nextidx;
	i64 lnum,linex;
	Token::Type ttype;

	/*struct State{
		i64 idx,nextidx;
		i64 lnum,lineidx;
		Token::Type ttype;
	};

	stack<State> statestack;*/

	bool eof(i64 at){
		return at>=(i64)source.size();
	}

	string get_() const {
		if(eof())throw runtime_error("Tokeniser::get() on eof");
		if(nextidx==-1)throw runtime_error("Tokeniser::get() before advance");
		if(nextidx==-2)throw runtime_error("Tokeniser::get() after eof");
		assert(nextidx>=0);
		return source.substr(idx,nextidx-idx);
	}

public:
	Tokeniser(const string &source,const string &filename)
		:source(source),filename(filename),
		 idx(0),nextidx(-1),
		 lnum(1),linex(1){}

	Tokeniser& operator=(const Tokeniser &other){
		if(&source!=&other.source||&filename!=&other.filename){
			throw runtime_error("Tokeniser::operator= on incompatible Tokeniser");
		}
		idx=other.idx; nextidx=other.nextidx;
		lnum=other.lnum; linex=other.linex;
		ttype=other.ttype;
		return *this;
	}

	/*void save(){
		statestack.push({idx,nextidx,lnum,lineidx,ttype});
	}

	void restore(){
		if(statestack.size()==0)throw runtime_error("Tokeniser::restore() on empty stack");
		const State &st=statestack.top();
		idx=st.idx; nextidx=st.nextidx;
		lnum=st.lnum; linex=st.linex;
		ttype=st.ttype;
		statestack.pop();
	}

	void discardstate(){
		if(statestack.size()==0)throw runtime_error("Tokeniser::discardstate() on empty stack");
		statestack.pop();
	}*/

	bool eof() const {
		return idx>=(i64)source.size();
	}

	Token get(){
		return Token(ttype,get_(),Site(filename,lnum,linex));
	}

	// Returns whether there are more tokens
	bool advance(){
		if(eof())return false;

		// Let nextidx catch up with idx
		while(idx<nextidx){
			if(source[idx]=='\n'){
				lnum++;
				linex=1;
			} else {
				linex++;
			}
			idx++;
		}

		// Skip any whitespace and/or comments, emitting a terminator on a newline
		while(true){
			i64 origidx=idx;
			while(!eof()&&isspace(source[idx])){
				if(source[idx]=='\n'){
					nextidx=idx+1;
					ttype=Token::Type::terminator;
					return true;
				}
				linex++;
				idx++;
			}
			if(eof())return false;

			if(source[idx]=='#'){
				while(!eof()&&source[idx]!='\n')idx++;
				if(eof())return false;
				nextidx=idx+1;
				ttype=Token::Type::terminator;
				return true;
			}

			if(idx==origidx)break;
		}

		nextidx=idx;

		// Terminator semicolon
		if(source[nextidx]==';'){
			ttype=Token::Type::terminator;
			nextidx++;
			return true;
		}

		// Word
		if(isinitwordchar(source[nextidx])){
			ttype=Token::Type::word;
			do nextidx++;
			while(!eof(nextidx)&&iswordchar(source[nextidx]));
			return true;
		}

		// Number literal
		if(isdigit(source[nextidx])||(!eof(nextidx+1)&&source[nextidx]=='-'&&isdigit(source[nextidx+1]))){
			ttype=Token::Type::number;
			if(source[nextidx]=='-')nextidx++;
			while(!eof(nextidx)&&isdigit(source[nextidx]))nextidx++;
			if(eof(nextidx))return true;
			if(source[nextidx]=='.'){
				nextidx++;
				if(eof(nextidx)||!isdigit(source[nextidx])){
					throw ParseError("Incomplete floating point literal at EOF");
				}
				while(!eof(nextidx)&&isdigit(source[nextidx]))nextidx++;
				if(eof(nextidx))return true;
			}
			if(strchr("eE",source[nextidx])!=NULL){
				nextidx++;
				if(eof(nextidx)||strchr("+-0123456789",source[nextidx])==NULL){
					throw ParseError("Incomplete floating point literal at EOF");
				}
				if(strchr("+-",source[nextidx])!=NULL){
					nextidx++;
					if(eof(nextidx))throw ParseError("Incomplete floating point literal at EOF");
				}
				while(!eof(nextidx)&&isdigit(source[nextidx]))nextidx++;
			}
			return true;
		}

		// String literal
		if(source[nextidx]=='"'){
			ttype=Token::Type::string;
			nextidx++;
			while(!eof(nextidx)&&source[nextidx]!='"'){
				if(source[nextidx]=='\\')nextidx++;
			}
			if(eof(nextidx))throw ParseError("Incomplete string literal at EOF");
			nextidx++;
			return true;
		}

		// Symbol
		if(isSymbolPrefix({source[idx]})){
			ttype=Token::Type::symbol;
			nextidx++;
			while(!eof(nextidx)){
				if(!isSymbolPrefix(get_()))return true;
				nextidx++;
			}
			if(contains(tok_symbols,get_()))return true;
			else throw ParseError("Unknown symbol at EOF");
		}

		throw ParseError("Unknown token starting at '"+source.substr(idx,5)+"'");
	}
};


static Expression parseExpression(Tokeniser &tokeniser){
	;
}

static Statement parseStatement(Tokeniser &tokeniser){
	Token tok=tokeniser.get();
	switch(tok.type){
		case Token::Type::word:{
			Tokeniser copyiser(tokeniser);
			copyiser.advance();
			Token tok2=copyiser.get();
			if(tok2.type==Token::Type::symbol&&tok2.str==":="){
				tokeniser=copyiser;
				tokeniser.advance();
				return Statement(Statement::Type::create,tok.str,parseExpression(tokeniser));
			} else if(tok2.type==Token::Type::symbol&&tok2.str=="="){
				tokeniser=copyiser;
				tokeniser.advance();
				return Statement(Statement::Type::assign,tok.str,parseExpression(tokeniser));
			} else {
				return Statement(Statement::Type::expression,parseExpression(tokeniser));
			}
		}

		case Token::Type::number:
		case Token::Type::string:
		case Token::Type::symbol:
			return Statement(Statement::Type::expression,parseExpression(tokeniser));

		case Token::Type::terminator:
			throw runtime_error("Unexpected terminator in parseStatement()");
	}
}

StatementList parse(const string &source,const string &filename){
	Tokeniser tokeniser(source,filename);
	if(!tokeniser.advance())return {};
	StatementList stl;
	while(!tokeniser.eof()){
		if(tokeniser.get().type==Token::Type::terminator)continue;
		stl.push_back(parseStatement(tokeniser));
	}
	return stl;
}