//version that is robust to more than 3/4 parts in a line
//check incremental part by searching "***"

#include <iostream>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
using namespace std;

#define TRIPLE_STRBUF_SIZE 1000000

bool report_err_warn = false;//do not set true for distributed computing

//translated from com.hp.hpl.jena.rdf.model.impl.NTripleReader.java

char strbuf[TRIPLE_STRBUF_SIZE];//for low-level string: readLang, readURI, readName
char strbuf1[TRIPLE_STRBUF_SIZE];//for middle-level string: readLiteral, readResource
char strbuf2[TRIPLE_STRBUF_SIZE];//for high-level string: readLiteral, readResource
bool stmt_error;//++++ no exit version
bool literal_read;//XXXX detect what is just read

class statement
{
	public:
		string subject;
		string predicate;
		string object;
		string context;

		statement()
		{
			context = "";//empty context
		}

		//====== assisting functions (called internally) ======
		char readChar(const char* & head)
		{
			char cur = head[0];
			if(cur != '\0') head++;
			return cur;
		}

		inline char nextChar(const char* & head)
		{
			return head[0];
		}

		inline bool eol(const char* & head)//end of line
		{
			return head[0] == '\0';
		}

		int readNum(const char* & head)
		{
			char cur = readChar(head);
			int pos = 0;
			while(isdigit(cur))
			{
				strbuf[pos] = cur;
				pos++;
				cur = readChar(head);
			}
			strbuf[pos]='\0';
			return atoi(strbuf);
		}

		void skipWhiteSpace(const char* & head)
		{
			//input: head[] is a string that ends with '\0'
			//output: update value of the head pointer "head" to skip white spaces
			char cur = nextChar(head);
			const char* old = head;
			while(cur == ' ' || cur == '\t' || cur == '\r' || cur == '#')
			{//'\n' is impossible as head[] is part of a line
				cur = readChar(head);
				if(eol(head)){
					return;//line end is reached
				}
				if(cur == '#')//skip comments #... till line end
				{
					while(cur != '\0') cur = readChar(head);
				}
			}
			if(head > old) head--;
		}

		bool expect(string pattern, const char* & head)
		{
			const char* str = pattern.c_str();
			int len = pattern.length();
			for(int i=0; i<len; i++)
			{
				if(eol(head)) return false;//line end, nothing to match
				char cur = readChar(head);
				if(cur != str[i])
				{
					if(report_err_warn) cout<<"Error in expect(): \""<<str[i]<<"\" expected, but observing: "<<head<<endl;
					stmt_error = true;//++++ no exit version
					return false;//++++ no exit version
				}
			}
			return true;
		}

		char* readName(const char* & head)
		{
			char cur;
			int pos = 0;
			while(isalnum(cur = nextChar(head)) || '-' == cur)
			{
				strbuf[pos] = readChar(head);
				pos++;
				if(eol(head)) break;
			}
			if(pos > TRIPLE_STRBUF_SIZE -1)
			{
				if(report_err_warn) cout<<"Error in readName(): strbuf overflows ! Please enlarge TRIPLE_STRBUF_SIZE"<<endl;
				stmt_error = true;//++++ no exit version
				return NULL;//++++ no exit version
			}
			strbuf[pos] = '\0';
			return strbuf;
		}

		char* readURI(const char* & head)
		{
			char cur;
			int pos = 0;
			while(nextChar(head) != '>')
			{
				strbuf[pos] = readChar(head);
				pos++;
				if(eol(head)) break;
			}
			if(pos > TRIPLE_STRBUF_SIZE -1)
			{
				if(report_err_warn) cout<<"Error in readURI(): strbuf overflows ! Please enlarge TRIPLE_STRBUF_SIZE"<<endl;
				stmt_error = true;//++++ no exit version
				return NULL;//++++ no exit version
			}
			strbuf[pos] = '\0';
			return strbuf;
		}

		char* readLang(const char* & head)
		{
			int pos = 0;
			while(true)
			{
				char cur = nextChar(head);
				if(cur == ' ' || cur == '\t' || cur == '\r' || cur == '.' || cur == '^' || cur == '\0')
				{
					strbuf[pos] = '\0';
					return strbuf;
				}
				strbuf[pos] = readChar(head);
				pos++;
			}
		}

		char* readLiteral(const char* & head)
		{
			literal_read = true;//XXXX
			int pos = 0;
			if(!expect("\"", head))
			{
				if(report_err_warn) cout<<"Error in readLiteral(): not starting with \""<<endl;
				return NULL;//++++ no exit version
			}
			while(true)
			{
				char cur = readChar(head);
				if(cur == '\0')
				{
					if(report_err_warn) cout<<"Error in readLiteral(): literal content not finished !"<<endl;
					stmt_error = true;//++++ no exit version
					return NULL;//++++ no exit version
				}
				if(cur == '\\')
				{
					strbuf1[pos] = cur;//%%%%%%
					pos++;//%%%%%%
					char c = readChar(head);
					if(c == '\0')
					{
						if(report_err_warn) cout<<"Error in readLiteral(): literal content not finished, read till \\ !"<<endl;
						stmt_error = true;//++++ no exit version
						return NULL;//++++ no exit version
					}
					if(c == 'n' || c == 'r' || c == 't' || c == '\\' || c == '"' || c == 'u' || c =='U') cur = c;//%%%%%%
					else
					{
						if(report_err_warn) cout<<"Error in readLiteral(): \\ is not followed by the right character !"<<endl;
						stmt_error = true;//++++ no exit version
						return NULL;//++++ no exit version
					}
				}
				else if(cur == '"')
				{
					strbuf1[pos] = '"';
					pos++;
					char* lang;
					char empty[1] = {'\0'};
					if('@' == nextChar(head))
					{
						strbuf1[pos] = '@';
						pos++;
						expect("@", head);
						if(stmt_error)
						{
							return NULL;//++++ no exit version
						}
						lang = readLang(head);
						if(stmt_error) return NULL;//++++ no exit version
					}
					else if('-' == nextChar(head))
					{
						strbuf1[pos] = '-';
						pos++;
						expect("-", head);
						if(stmt_error)
						{
							return NULL;//++++ no exit version
						}
						if(report_err_warn) cout<<"Warning in readLiteral(): Language tags should be introduced with @, not -"<<endl;
						lang = readLang(head);
						if(stmt_error) return NULL;//++++ no exit version
					}
					else lang = empty;
					strbuf1[pos]='\0';
					strcat(strbuf1, lang);//pos cannot be used any more
					int len_lang = strlen(lang);
					//------
					if('^' == nextChar(head))
					{
						char* datatypeURI = NULL;
						if(!expect("^^<", head))
						{
							if(report_err_warn) cout<<"Error in readLiteral(): ill-formed datatype after ^^ !"<<endl;
							return NULL;//++++ no exit version
						}
						strcat(strbuf1, "^^<");
						datatypeURI = readURI(head);
						if(stmt_error) return NULL;//++++ no exit version
						if(!expect(">", head))
						{
							if(report_err_warn) cout<<"Error in readLiteral(): datatype uri after ^^ not ended by > !"<<endl;
							return NULL;//++++ no exit version
						}
						if(len_lang > 0) if(report_err_warn) cout<<"Warning in readLiteral(): Language tags are not permitted on typed literals"<<endl;
						strcat(strbuf1, datatypeURI);
						strcat(strbuf1, ">");
						return strbuf1;
					}
					else return strbuf1;
				}
				else if(cur == '\n' || cur == '\r')
				{
					if(report_err_warn) cout<<"Error in readLiteral(): Raw \\n and \\r not permitted in N-Triples data !"<<endl;
					stmt_error = true;//++++ no exit version
					return NULL;//++++ no exit version
				}
				strbuf1[pos] = cur;
				pos++;
			}
		}

		char* readResource(const char* & head)
		{
			literal_read = false;//XXXX
			char cur = readChar(head);
			if(cur == '_')//anon
			{
				if(!expect(":", head))
				{
					if(report_err_warn) cout<<"Error in readResource(): _ is not followed by : !"<<endl;
					return NULL;//++++ no exit version
				}
				char* name = readName(head);
				if(stmt_error) return NULL;//++++ no exit version
				strbuf1[0]='\0';
				strcat(strbuf1, "_:");//pos cannot be used any more
				strcat(strbuf1, name);
				return strbuf1;
			}
			else if(cur == '<')//uri
			{
				char* uri = readURI(head);
				if(stmt_error) return NULL;//++++ no exit version
				cur = readChar(head);
				if(cur != '>')
				{
					if(report_err_warn) cout<<"Error in readResource(): url not ended by > !"<<endl;
					stmt_error = true;//++++ no exit version
					return NULL;//++++ no exit version
				}
				strbuf1[0]='\0';
				strcat(strbuf1, "<");//pos cannot be used any more
				strcat(strbuf1, uri);
				strcat(strbuf1, ">");
				return strbuf1;
			}
			else
			{
				if(report_err_warn) cout<<"Error in readResource(): not starting with :_ or < !"<<endl;
				stmt_error = true;//++++ no exit version
				return NULL;//++++ no exit version
			}
		}

		char* readNode(const char* & head)
		{
			char cur = nextChar(head);
			strbuf2[0]='\0';
			char* a;
			switch(cur)
			{
				case '"':
					strcat(strbuf2, "\"");//pos cannot be used any more
					a=readLiteral(head);
					if(stmt_error) return NULL;//++++ no exit version
					strcat(strbuf2, a);
					return strbuf2;
				case '<':
					a=readResource(head);
					if(stmt_error) return NULL;//++++ no exit version
					strcat(strbuf2, a);
					return strbuf2;
				case '_':
					a=readResource(head);
					if(stmt_error) return NULL;//++++ no exit version
					strcat(strbuf2, a);
					return strbuf2;
				default:
					cout<<"Error in readNode(): Unexpected object input !"<<endl;
					stmt_error = true;//++++ no exit version
					return NULL;//++++ no exit version
			}
		}

		//====== external parser call ======
		void parseTriple(const char* line)
		{
			stmt_error = false;//++++ no exit version

			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseTriple(): empty line !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			char* a = readResource(line);
			if(stmt_error) return;//++++ no exit version
			subject = a;
			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseTriple(): only has subject !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			a = readResource(line);
			if(stmt_error) return;//++++ no exit version
			predicate = a;
			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseTriple(): only has subject + predicate !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			a = readNode(line);
			if(stmt_error) return;//++++ no exit version
			object = a;
			skipWhiteSpace(line);
			if(!expect(".", line))
			{
				if(report_err_warn) cout<<"Error in parseTriple(): line is not ending with '.' !"<<endl;
				stmt_error = false;//**************** For robustness, just take the first few parts and ignore that latter parts ****************
				return;//++++ no exit version
			}
			context = "";
		}

		void parseQuad(const char* line)
		{
			stmt_error = false;//++++ no exit version

			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseQuad(): empty line !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			char* a = readResource(line);
			if(stmt_error) return;//++++ no exit version
			subject = a;
			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseQuad(): only has subject !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			a = readResource(line);
			if(stmt_error) return;//++++ no exit version
			predicate = a;
			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseQuad(): only has subject + predicate !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			a = readNode(line);
			if(stmt_error) return;//++++ no exit version
			object = a;
			skipWhiteSpace(line);
			if(eol(line))
			{
				if(report_err_warn) cout<<"Error in parseQuad(): no context detected !"<<endl;
				stmt_error = true;//++++ no exit version
				return;//++++ no exit version
			}
			a = readResource(line);
			if(stmt_error) return;//++++ no exit version
			context = a;
			skipWhiteSpace(line);
			if(!expect(".", line))
			{
				if(report_err_warn) cout<<"Error in parseQuad(): line is not ending with '.' !"<<endl;
				stmt_error = false;//**************** For robustness, just take the first few parts and ignore that latter parts ****************
				return;//++++ no exit version
			}
		}

		void report()
		{
			if(stmt_error)//++++ no exit version
			{
				cout<<"Parse Error";
			}
			else
			{
				cout<<"subject: "<<subject<<endl;
				cout<<"predicate: "<<predicate<<endl;
				cout<<"object: "<<object<<endl;
				if(context != "") cout<<"context: "<<context<<endl;
			}
		}
};

/*
int main()
{
	string content="<http://reference.data.gov.uk/id/second/2010-05-10T07:14:36> 5678 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://reference.data.gov.uk/def/intervals/Second> ";
	const char * line = content.c_str();
	statement o;
	o.skipWhiteSpace(line);
	char* str = o.readResource(line);
	cout<<str<<endl;
	o.skipWhiteSpace(line);
	cout<<o.readNum(line)<<endl;
	o.skipWhiteSpace(line);
	str = o.readResource(line);
	cout<<str<<endl;
	o.skipWhiteSpace(line);
	str = o.readResource(line);
	cout<<str<<endl;
	o.skipWhiteSpace(line);
	cout<<"end-of-line(eol) is "<<o.eol(line)<<endl;
	return 0;
}
*/