qasm/asm.cpp

#define ADD_ERROR_STRINGS

#include "asm.h"
#include "eval.h"
#include "psuedo.h"
#include <sys/ioctl.h>
#include <unistd.h>
#include <string.h>


#define CLASS MerlinLine


CLASS::CLASS(ConfigOptions &opt) : options(&opt)
{
	clear();
}

CLASS::CLASS(std::string line, ConfigOptions &opt) : options(&opt)
{
	clear();
	set(line);
}


void CLASS::setError(uint32_t ecode)
{
	errorcode = ecode;
}


void CLASS::print(uint32_t lineno)
{
	uint32_t l, i, savpcol, pcol;
	bool commentprinted = false;
	uint8_t commentcol = tabs[2];
	bool force=false;

	uint32_t b = 4; // how many bytes show on the first line

	if (datafillct > 0)
	{
		l = datafillct;
	}
	else
	{
		l = outbytect;
	}
	if (l > b)
	{
		l = b;
	}
	if (errorcode > 0)
	{
		if (merlinerrors)
		{
			//printf("errorcode=%d\n",errorcode);
			printf("\n%s in line: %d", errStrings[errorcode].c_str(), lineno + 1);
			if (errorText != "")
			{
				printf(" (%s)", errorText.c_str());
			}
			printf("\n");
		}
		force=true;
		flags &= (~FLAG_NOLINEPRINT);
	}

	bool np=(flags & FLAG_NOLINEPRINT)?true:false;
	if (options->isQuiet())
	{
		np=true;
	}
	if (options->isList())
	{
		np=false;
	}
	if (force)
	{
		np=false;
	}
	if (np)
	{
		return;
	}
	if (options->useColor())
	{
		if (errorcode > 0)
		{
			if (errorcode >= errFatal)
			{
				SetColor(CL_WHITE | CL_BOLD | BG_RED);
			}
			else
			{
				SetColor(CL_YELLOW | CL_BOLD | BG_NORMAL);
			}
		}
		else
		{
			SetColor(CL_WHITE | CL_BOLD | BG_NORMAL);
		}
	}
	bool empty = false;
	if ((printlable == "") && (opcode == "") && (printoperand == ""))
	{
		empty = true;
	}

	pcol = 0;

	bool saddr = flags & FLAG_FORCEADDRPRINT;
	saddr = (outbytect > 0) ? true : saddr;
	saddr = (printlable != "") ? true : saddr;

	if (saddr)
	{
		pcol += printf("%02X/%04X:", (startpc >> 16), startpc & 0xFFFF);
	}
	else
	{
		pcol += printf("        ");
	}

	for (i = 0; i < l; i++)
	{
		uint8_t a = datafillbyte;
		if (datafillct == 0)
		{
			a = outbytes[i];
		}

		pcol += printf("%02X ", a);
	}
	for (i = l; i < b; i++)
	{
		pcol += printf("   ");
	}

	pcol += printf("%6d  ", lineno + 1);

	if (showmx)
	{
		if ((outbytect + datafillct) > 0)
		{
			pcol += printf("%%%c%c ", linemx & 02 ? '1' : '0', linemx & 01 ? '1' : '0');
		}
		else
		{
			pcol += printf("    ");
		}


		string addrmode=options->addrModeEnglish(addressmode).c_str();
		pcol+=printf("%s ",addrmode.c_str());
		pcol+=printf("/%04X ",flags);

		while(pcol<50)
		{
			pcol+=printf(" ");
		}
		char sc=shiftchar;
		if (sc==0)
		{
			sc=' ';
		}
		pcol+=printf("%c |",sc);

	}

	if (isDebug() > 1)
	{
		//pcol += printf("%02X ", addressmode & 0xFF);
		pcol += printf(" %s ", addrtext.c_str());

	}

	savpcol = pcol; // this is how many bytes are in the side margin
	pcol = 0; // reset pcol here because this is where source code starts

	if (empty)
	{
		if (comment.length() > 0)
		{
			if (comment[0] == ';')
			{
				while (pcol < commentcol)
				{
					pcol += printf(" ");
				}
			}
			//else
			{
				int comct = 0;
				for (uint32_t cc = 0; cc < comment.length(); cc++)
				{
					pcol += printf("%c", comment[cc]);
					comct++;
					if ((comment[cc] <= ' ') && (pcol >= (commentcol + savpcol + 20)))
					{
						printf("\n");
						pcol = 0;
						while (pcol < (commentcol + savpcol))
						{
							pcol += printf(" ");
						}
					}
				}
				//pcol += printf("%s", comment.c_str());

			}
			commentprinted = true;
		}
	}
	else
	{
		pcol += printf("%s ", printlable.c_str());
		while (pcol < tabs[0])
		{
			pcol += printf(" ");
		}
		pcol += printf("%s ", opcode.c_str());
		while (pcol < tabs[1])
		{
			pcol += printf(" ");
		}
		if (isDebug() > 1)
		{
			pcol += printf("%s ", operand.c_str());
		}
		else
		{
			if (printoperand.length() > 0)
			{
				pcol += printf("%s ", printoperand.c_str());
				//pcol += printf("%s ", orig_operand.c_str());

			}
			else
			{
				pcol += printf("%s ", printoperand.c_str());
				//pcol += printf("%s ", orig_operand.c_str());
			}
		}
		//pcol += printf("%-12s %-8s %-10s ", printlable.c_str(), opcode.c_str(), operand.c_str());
	}
	//printf("merlinerrors=%d\n",merlinerrors);
	//merlinerrors=false;
	if ((errorcode > 0) && (!merlinerrors))
	{
		while (pcol < commentcol)
		{
			pcol += printf(" ");
		}
		pcol += printf(":[Error] %s", errStrings[errorcode].c_str());
		if (errorText.length() > 0)
		{
			pcol += printf(" (%s)", errorText.c_str());
		}
	}
	else if (!commentprinted)
	{
		while (pcol < commentcol)
		{
			pcol += printf(" ");
		}
		pcol += printf("%s", comment.c_str());
	}
	//printf("\n");

	if ((options->useColor()) && (errorcode > 0))
	{
		SetColor(CL_NORMAL);
	}

	uint32_t obc = datafillct;
	if (obc == 0)
	{
		obc = outbytect;
	}

	uint32_t ct = 1;
	if ((obc > b) && ((truncdata & 0x01) == 0))
	{
		ct = 0;
		uint8_t db;
		uint32_t t = b;
		char *s = (char *)"        ";

		b = 8;

		//printf("t=%d ct=%d\n",t,outbytect);
		printf("\n");
		while (t < obc)
		{
			db = datafillbyte;
			if (datafillct == 0)
			{
				db = outbytes[t];
			}
			if (ct == 0)
			{
				printf("%s", s);
			}

			printf("%02X ", db);
			t++;
			ct++;
			if (ct >= b)
			{
				printf("\n");
				ct = 0;
			}
		}
	}
	if (ct > 0)
	{
		printf("\n");
	}

}

void CLASS::clear()
{
	shiftchar=0;
	wholetext = "";
	lable = "";
	printlable = "";
	opcode = "";
	opcodelower = "";
	operand = "";
	printoperand = "";
	orig_operand="";
	strippedoperand="";
	comment = "";
	operand_expr = "";
	operand_expr2 = "";
	addrtext = "";
	merlinerrors = false;
	linemx = 0;
	bytect = 0;
	opflags = 0;
	pass0bytect = 0;
	startpc = 0;
	errorcode = 0;
	errorText = "";
	datafillct = 0;
	datafillbyte = 0;
	lineno = 0;
	addressmode = 0;
	expr_value = 0;
	eval_result = 0;
	flags = 0;
	outbytes.clear();
	outbytect = 0;
}

std::string operEx[] =
{
	"^(\\S*)(#?)([<>\\^|]?)([\"\'])(.*)(\\4)([\\S]*)", // catches the normal delims
	"^(\\s*)([!-~])([!-~]*?)([^;]*)\\2(\\S*)", // catches the unusual delims
	"^(\\s*)(\\S+)",							// captures everything else
	""
};

std::string commentEx = "^(\\s*)((;|\\/{2}))+(.*)";

void CLASS::set(std::string line)
{
	int state = 0;
	int l = (int)line.length();
	int i = 0;
	int x;
	char c;
	//char delim;
	//bool isascii;
	std::string opupper, s;
	std::string restofline;
	std::string tline = line;
	clear();

	wholetext = line;
	// isascii = false;
	//delim = 0;
	while (i < l)
	{
		c = tline[i++];
		switch (state)
		{
		case 7:
			if (c >= ' ')
			{
				comment += c;
			}
			else
			{
				i = l;
			}
			break;
		case 0:  // start of line state
			if ((c == ';') || (c == '*') || (c == '/'))
			{
				comment += c;
				state = 7;
			}
			else if (c > ' ')
			{
				lable += c;
				state = 1;
			}
			else
			{
				state = 2;
			};
			break;
		case 1:   // read in entire lable until whitespace
			if (c > ' ')
			{
				lable += c;
			}
			else
			{
				state = 2;
			}
			break;
		case 2:  // read whitespace between label and opcode
			if (c == ';')
			{
				comment += c;
				state = 7;
			}
			else if (((c == '*') || (c == '/')) && (lable.length() == 0))
			{
				comment += c;
				state = 7;
			}
			else if (c > ' ')
			{
				opcode += c;
				state = 3;
			}
			break;
		case 3:
		{
			if (c > ' ')
			{
				opcode += c;
			}
			else
			{
				i--;
				state = 4;
			}
		}
		break;
		case 4:  // read whitespace between opcode and operand
		{
			std::vector<std::string> strs;
			std::string s;

			Poco::RegularExpression comEx(commentEx, 0, true);
			restofline = Poco::trim(tline.substr(i, tline.length())) + " ";
			//printf("ROL: |%s|\n",restofline.c_str());

			if (restofline == "")
			{
				i = l;
				break;
			}
			strs.clear();
			x = 0;
			try
			{
				x = comEx.split(restofline, strs, 0);
			}
			catch (Poco::Exception &e)
			{
				x = 0;
				if (isDebug() > 3)
				{
					cout << e.displayText() << endl;
				}
			}
			if (x > 0)
			{
				// if the comment detector above is true, then the rest of line is comment;
				operand = "";
				comment = strs[0];
				//printf("comment=%s\n", comment.c_str());
				i = l;
				break;
			}

			int ct = 0;
			int x = 0;
			bool match = false;
			s = operEx[ct];
			while (s != "")
			{
				RegularExpression regex(s, 0, true);
				strs.clear();
				x = 0;
				try
				{
					x = regex.split(restofline, strs, 0);
				}
				catch (Poco::Exception &e)
				{
					x = 0;
					if (isDebug() > 3)
					{
						cout << e.displayText() << endl;
					}
				}
				if (x > 0)
				{
					//printf("%d regex %d match |%s|\n", ct, x, restofline.c_str());
					operand = strs[0];
					orig_operand=operand;
					//printf("which=%d operand=|%s|\n",ct,operand.c_str());
					i = (int)operand.length();
					restofline = restofline.substr(i, restofline.length());
					comment = Poco::trim(restofline);
					match = true;
					break;
				}
				ct++;
				s = operEx[ct];
			}
			i = l;
			if (!match)
			{
				// if you are here, there probably isn't an operand and/or comment after opcode
			}
		}
		break;
		}
	}
	printlable = lable;
	x = (int)lable.length();
	if (x > 1)
	{
		// M32 syntax allows a colon after lable, and it is not part of the lable
		//if ((syntax & SYNTAX_MERLIN32) == SYNTAX_MERLIN32)
		if (options->isMerlin32())
		{
			while ((x > 1) && (lable[x - 1] == ':'))
			{
				lable = lable.substr(0, x - 1);
				x--;
			}
			//printf("linelable: |%s|\n", lable.c_str());
		}
	}

	opcodelower = Poco::toLower(opcode);
}

#undef CLASS
#define CLASS TFileProcessor

CLASS::CLASS(ConfigOptions &opt) : options(opt)
{
	int x;
	errorct = 0;
	//syntax=SYNTAX_QASM;

	win_columns = -1;
	win_rows = -1;
	struct winsize w;
	x = ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
	if (x == 0)
	{
		win_columns = w.ws_col;
		win_rows = w.ws_row;
	}
	//printf("cols=%d rows=%d\n",win_columns,win_rows);

}

CLASS::~CLASS()
{
}

void CLASS::setLanguage(string lang,bool force)
{
	options.setLanguage(lang,force);
}

void CLASS::errorOut(uint16_t code)
{
	printf("error: %d\n", code);
}

void CLASS::init(void)
{
	int ts, tabpos;
	std::string s;

	filenames.clear();
	starttime = GetTickCount();
	initialdir = Poco::Path::current();
	filecount = 0;
	//syntax = SYNTAX_QASM;

	//std::string tabstr = getConfig("reformat.tabs", "8,16,32");
	std::string tabstr = getConfig("reformat.tabs", "12,24,40,70");

	tabstr = Poco::trim(tabstr);

	memset(tabs, 0x00, sizeof(tabs));

	Poco::StringTokenizer t(tabstr, ",;", 0);
	tabpos = 0;
	for (auto itr = t.begin(); itr != t.end(); ++itr)
	{
		s = Poco::trim(*itr);
		try
		{
			ts = Poco::NumberParser::parse(s);
		}
		catch (...)
		{
			ts = 0;
		}
		if ((ts >= 0) && (ts < 240))
		{
			tabs[tabpos++] = ts;
		}
	}

}

void CLASS::complete(void)
{

	uint64_t n = GetTickCount();
	//if (isDebug())
	{
		//cout << "Processing Time: " << n - starttime << "ms" << endl;
		uint64_t x = n - starttime;
		uint32_t x1 = x & 0xFFFFFFFF;
		//if ((!getBool("option.quiet",false)) && (isDebug()>0))
		{
			printf("Elapsed time: %u ms\n", x1);
		}

	}
}

void CLASS::process(void)
{

}
int CLASS::doline(int lineno, std::string line)
{
	UNUSED(lineno);
	UNUSED(line);

	int res = -1;

	return (res);
}

std::string CLASS::processFilename(std::string fn, std::string curDir, int level)
{
	std::string res = fn;
	std::string s, s1;
	Path p = Poco::Path(fn);

	try
	{
		int n = p.depth();
		//LOG_DEBUG << "n=" << n << " " << fn << endl;
		if (n == 0)
		{
			res = curDir + fn;
		}
		if (n > 0)
		{
			std::string d1 = p[0];
			uint32_t v = 100;
			try
			{
				v = Poco::NumberParser::parseUnsigned(d1);
			}
			catch (...)
			{
				v = 99;
			}
			if (v < 10)
			{
				Poco::Path p1 = p.popFrontDirectory();
				s = p1.toString();
				s1 = "global.path" + Poco::NumberFormatter::format(v);
				switch (v)
				{
				case 0:
					s = initialdir + s;
					break;
				default:
					s = getConfig(s1, ".") + "/" + s;
					if (level < 5)
					{
						s = processFilename(s, curDir, level + 1);
					}
					break;
				}
				p = s;
				p.makeAbsolute();
			}
			res = p.toString();
		}
	}
	catch (Poco::Exception &e)
	{
		if (isDebug() > 2)
		{
			cout << "exception: " << e.displayText() << endl;
		}
	}
	catch (std::exception &e)
	{
		if (isDebug() > 2)
		{
			cout << e.what() << endl;
		}
	}

	p = res;
	p.makeAbsolute();
	res = p.toString();

	char buff[PATH_MAX + 1];
	memset(buff, 0x00, sizeof(buff));
	char *rp = realpath(res.c_str(), buff);
	if (rp != NULL)
	{
		//printf("realpath: %s\n", buff);
		res = rp;
	}
	p = res;
	p.makeAbsolute();
	res = p.toString();

	//LOG_DEBUG << "convert: |" << res << "|" << endl;

	return (res);
}

int CLASS::processfile(std::string p, std::string &newfilename)
{
	//Poco::File fn(p);
	int c,c1;
	int res = -1;
	uint32_t linect;
	bool done, valid;
	std::string currentdir;
	std::string p1;
	std::string line, op;

	linect = 0;
	done = false;

	p = Poco::trim(p);
	currentdir = Poco::Path::current();

	if (filecount == 0)
	{
		initialdir = currentdir;
		//printf("initialdir=%s\n",initialdir.c_str());
	}

	//printf("currentdir=%s initialdir=%s\n", currentdir.c_str(), initialdir.c_str());
	//LOG_DEBUG << "initial file name: " << p << endl;
	p = processFilename(p, (filecount == 0) ? currentdir : currentdir, 0);

	//LOG_DEBUG << "Converted filename: " << p << endl;

	Poco::Path tp(p);
	Poco::Path path = tp.makeAbsolute();
	Poco::Path parent = path.parent();
	std::string dir = parent.toString();

	try
	{

		if (filecount == 0)
		{
			// is this the first file in the compilation, or a PUT/USE?
			// if first, change CWD to location of file
			//LOG_DEBUG << "Changing directory to: " << dir << endl;
			if (chdir(dir.c_str())) {} // change directory to where the file is
		}

		p1 = path.toString();

		newfilename = p1;
		//LOG_DEBUG << "initial file name: " << p1 << endl;

		valid = true;
		Poco::File fn(p1);
		if (!fn.exists())
		{
			fn = Poco::File(p1 + ".s");
			if (!fn.exists())
			{
				fn = Poco::File(p1 + ".S");
				if (!fn.exists())
				{
					fn = Poco::File(p1 + ".mac");
					if (!fn.exists())
					{
						fn = Poco::File(p1);
						valid = false;
					}
				}
			}
		}
		p1 = fn.path();
		//LOG_DEBUG << "File name: " << p1 << endl;

		int ecode = -3;
		valid = false;
		if (fn.exists())
		{
			ecode = -2;
			valid = true;
			//LOG_DEBUG << "File exists: " << p1 << endl;
			if (fn.isLink())
			{
				//LOG_DEBUG << "File is a link: " << p1 << endl;
			}
			if ((fn.isDirectory()) || (!fn.canRead()))
			{
				LOG_DEBUG << "File is a directory or can not read: " << p1 << endl;
				valid = false;
			}
		}
		else
		{
			printf("file does not exist |%s|\n", p1.c_str());
		}

		newfilename = p1;
		if (!valid)
		{
			//fprintf(stderr, "Unable to access file: %s\n", p1.c_str());

			errorct = 1;
			return (ecode);
		}

		if (valid)
		{

			if (filecount == 0)
			{
			}
			else
			{
				for (auto itr = filenames.begin(); itr != filenames.end(); ++itr)
				{
					if (*itr == p1)
					{
						return (-9);
					}
				}
			}

			filecount++;
			filenames.push_back(p1);

			std::ifstream f(p1);
			if (f.is_open())
			{
				//printf("file is open\n");
				line = "";
				while ((!done) && (f.good()) && (!f.eof()))
				{
					c = f.get();
					c1 = c & 0x7F;
					if (c == 0x8D) // merlin line ending
					{
						c = 0x0A;  // convert to linux
					}
					else if (c == 0x8A) // possible merlin line ending
					{
						c = 0x0D; // ignore
					}
					else if ((c1<0x20) || (c1==127)) // see if it might be a control character
					{
						if ((c1==0x0D) || (c1==0x0A) || (c1==0x09))
						{

						}
						else
						{
							c=0x00;
						}
					}
					c &= 0x7F;
					int x;
					switch (c)
					{
					case 0x00:
					case 0x0D:
						break;
					case 0x09:
						line += " ";
						break;
					case 0x0A:
						linect++;
						line=Poco::trimRight(line); //get rid of any space at end of line
						x = doline(linect, line);
						if (x < 0)
						{
							done = true;
						}
						line = "";
						break;
					default:
						if ((c >= ' ') && (c < 0x7F))
						{
							line += c;
						}
						else
						{
							//printf("garbage %08X\n",c);
						}
						break;
					}
				}
				if ( (f.eof()))
				{
					res = 0;
				}
			}
		}
		else
		{
			fprintf(stderr, "File <%s> does not exist.\n\n", p.c_str());
		}
	}
	catch (...)
	{

	}
	return (res);
}

#if 1
#undef CLASS
#define CLASS TMerlinConverter
CLASS::CLASS(ConfigOptions &opt) : TFileProcessor(opt)
{
	format_flags=CONVERT_TEST;
	//options=new ConfigOptions();
}
CLASS::~CLASS()
{
}
void CLASS::init(void)
{
	TFileProcessor::init();
	std::string s;
	lines.clear();
}

int CLASS::doline(int lineno, std::string line)
{
	UNUSED(lineno);

	MerlinLine l(line, options);
	lines.push_back(l);
	return 0;
}

void CLASS::process(void)
{

	char buff[128*1024];
	uint32_t ct = (uint32_t)lines.size();
	uint8_t orval=0x00;
	uint32_t flags;
	string s;
	int llen,oplen,operlen,comlen;
	string lable,opcode,operand,comment;

	uint32_t len, tlen,t, pos,i;

	tlen=0;
	flags=format_flags;

	for (uint32_t lineno = 0; lineno < ct; lineno++)
	{
		MerlinLine line = lines.at(lineno);
		//printf("line: |%s|\n",line.wholetext.c_str());
		orval=0x00;
		if (flags&CONVERT_HIGH)
		{
			orval=0x80;
		}
		len=0;
		pos = 0;

		lable=Poco::trimRight(line.printlable);
		llen=lable.length();
		opcode=Poco::trimRight(line.opcode);
		oplen=opcode.length();
		operand=Poco::trimRight(line.operand);
		operlen=operand.length();
		comment=Poco::trimRight(line.comment);
		comlen=comment.length();

		if ((llen+oplen+operlen)==0)
		{
			if (comlen > 0)
			{
				char c = comment[0];
				if ((c == '*') || (c == '/'))
				{
					len+=sprintf(&buff[len+tlen],"%s", comment.c_str());
				}
				else
				{
					t = tabs[2];
					if (flags&CONVERT_COMPRESS)
					{
						if (flags&CONVERT_TABS)
						{
							len += sprintf(&buff[len+tlen],"\t\t\t\t");
						}
						else
						{
							len += sprintf(&buff[len+tlen],"   ");
						}
					}
					else
					{
						while (len < t)
						{
							len += sprintf(&buff[len+tlen]," ");
						}
					}
					len+=sprintf(&buff[len+tlen],"%s", comment.c_str());
				}
			}
		}
		else
		{
			t = tabs[pos++];
			len += sprintf(&buff[len+tlen],"%s", lable.c_str());
			if ((oplen+operlen+comlen)>0)
			{
				if (flags&CONVERT_COMPRESS)
				{
					if (flags&CONVERT_TABS)
					{
						len += sprintf(&buff[len+tlen],"\t\t\t");
					}
					else
					{
						len += sprintf(&buff[len+tlen]," ");
					}
				}
				else
				{
					while (len < t)
					{
						len += sprintf(&buff[len+tlen]," ");
					}
				}
			}

			t = tabs[pos++];
			len += sprintf(&buff[len+tlen],"%s", opcode.c_str());
			if ((operlen+comlen)>0)
			{
				if (flags&CONVERT_COMPRESS)
				{
					if (flags&CONVERT_TABS)
					{
						len += sprintf(&buff[len+tlen],"\t\t\t");
					}
					else
					{
						len += sprintf(&buff[len+tlen]," ");
					}
				}
				else
				{
					while (len < t)
					{
						len += sprintf(&buff[len+tlen]," ");
					}
				}
			}

			t = tabs[pos++];
			len += sprintf(&buff[len+tlen],"%s", operand.c_str());
			if ((comlen)>0)
			{
				if (flags&CONVERT_COMPRESS)
				{
					if (flags&CONVERT_TABS)
					{
						len += sprintf(&buff[len+tlen],"\t\t\t");
					}
					else
					{
						len += sprintf(&buff[len+tlen]," ");
					}
				}
				else
				{
					while (len < t)
					{
						len += sprintf(&buff[len+tlen]," ");
					}
				}
			}

			len += sprintf(&buff[len+tlen],"%s", comment.c_str());
		}
		if (flags&CONVERT_CRLF)
		{
			len+=sprintf(&buff[len+tlen],"\r\n");
		}
		else if (flags&CONVERT_LF)
		{
			len+=sprintf(&buff[len+tlen],"\n");
		}
		else
		{
			len+=sprintf(&buff[len+tlen],"\r");
		}
		tlen+=len;
	}
	//printf("tlen=%d\n",tlen);
	if (tlen>0)
	{
		int tct=0;
		int idx=0;
		for (i=0; i<tlen; i++)
		{
			char c=buff[i];
			if (c==0x20)
			{
				if (tct<3)
				{
					buff[idx++]=0x20 | orval;
				}
				else
				{
					buff[idx++]=0x20;
				}
				tct++;
			}
			else if (c==0x0D)
			{
				buff[idx++]=0x0D | orval;
				tct=0;
			}
			else if (c==0x0A)
			{
				if ((flags&(CONVERT_COMPRESS|CONVERT_HIGH))==(CONVERT_COMPRESS | CONVERT_HIGH))
				{
					// don't allow any LFs if converting to merlin
				}
				else
				{
					buff[idx++]=0x0A;
				}
				tct=0;
			}
			else
			{
				buff[idx++]=c|orval;
			}
		}
		buff[idx]=0;
		fprintf(stdout,"%s",buff);
#if 0
		FILE *f=NULL;

		f=fopen("./aout.s","w+");
		if (f!=NULL)
		{
			fwrite(buff,1,idx,f);
			fclose(f);
			printf("file ok\n");
		}
		else
		{
			printf("file error\n");
		}
#endif
	}
}

void CLASS::complete(void)
{
}
#endif


#undef CLASS
#define CLASS T65816Asm

CLASS::CLASS(ConfigOptions &opt) : TFileProcessor(opt)
{
	lines.clear();
	psuedoops = new TPsuedoOp();
}

//#define OPHANDLER(ACB) std::bind(ACB, this, std::placeholders::_1, std::placeholders::_2)

CLASS::~CLASS()
{
	if (psuedoops != NULL)
	{
		delete(psuedoops);
		psuedoops = NULL;
	}
}

void CLASS::pushopcode(std::string op, uint8_t opcode, uint16_t flags, TOpCallback cb)
{
	TSymbol sym;

	sym.name = op;
	sym.opcode = opcode;
	sym.namelc = Poco::toLower(op);
	sym.stype = flags;
	sym.value = 0;
	sym.cb = cb;
	std::pair<std::string, TSymbol> p(Poco::toUpper(op), sym);

	opcodes.insert(p);
}

TSymbol * CLASS::addSymbol(std::string symname, uint32_t val, bool replace)
{
	TSymbol *res = NULL;
	TSymbol *fnd = NULL;

	std::string sym = symname;
	if (!casesen)
	{
		sym = Poco::toUpper(sym);
	}

	//printf("addSymbol: |%s|\n",sym.c_str());
	if (sym.length() > 0)
	{
		TSymbol s;
		s.name = sym;
		s.opcode = 0;
		s.namelc = Poco::toLower(sym);
		s.stype = 0;
		s.value = val;
		s.used = false;
		s.cb = NULL;
		std::pair<std::string, TSymbol> p(sym, s);

		if (sym[0] == ':')
		{
			//local symbol
			if (currentsym == NULL)
			{
				goto out;
			}
			else
			{
				fnd = findSymbol(sym);
				if ((fnd != NULL) && (!replace))
				{
					goto out;
				}

				if (fnd != NULL)
				{
					fnd->value = val;
					res = fnd;
					goto out;
				}
				if (currentsym != NULL)
				{
					currentsym->locals.insert(p);
				}
				res = findSymbol(sym);
				goto out;
			}
		}
		else
		{
			fnd = findSymbol(sym);

			if ((fnd != NULL) && (!replace))
			{
				goto out;
			}

			if (fnd != NULL)
			{
				//printf("replacing symbol: %s %08X\n",sym.c_str(),val);
				fnd->value = val;
				res = fnd;
				goto out;
			}

			symbols.insert(p);
			res = findSymbol(sym);
		}
	}
out:
	return (res);
}


TMacro * CLASS::findMacro(std::string symname)
{
	TMacro *res = NULL;

	std::string sym = symname;
	if (!casesen)
	{
		sym = Poco::toUpper(sym);
	}
	if (symname.length() > 0)
	{
		//printf("finding: %s\n",symname.c_str());
		auto itr = macros.find(sym);
		if (itr != macros.end())
		{
			res = &itr->second;
		}
	}
	return (res);
}

TSymbol * CLASS::findSymbol(std::string symname)
{
	TSymbol *res = NULL;

	std::string sym = symname;
	if (!casesen)
	{
		sym = Poco::toUpper(sym);
	}
	if (symname.length() > 0)
	{
		if (symname[0] == ']')
		{
			//printf("finding symbol: |%s|\n",symname.c_str());
			res = findVariable(symname, variables);
			if (res!=NULL)
			{
				//printf("symbol found: |%s| |%s|\n",symname.c_str(),res->var_text.c_str());
				TEvaluator eval(*this);
				int64_t er_val=0;
				uint8_t shift=0;
				int er;
				er = eval.evaluate(res->var_text, er_val, shift);
				if (er == 0)
				{
					res->value=er_val;
				}
			}
		}
		else if (symname[0] == ':')
		{
			if (currentsym == NULL)
			{
				goto out;
			}
			else
			{
				auto itr = currentsym->locals.find(sym);
				if (itr != currentsym->locals.end())
				{
					res = &itr->second;
					goto out;
				}
			}
		}
		else
		{
			//printf("finding: %s\n",symname.c_str());
			auto itr = symbols.find(sym);
			if (itr != symbols.end())
			{
				//printf("Found: %s 0x%08X\n",itr->second.name.c_str(),itr->second.value);
				res = &itr->second;
				goto out;
			}
		}
	}
out:
	return (res);
}

TSymbol * CLASS::addVariable(std::string symname, std::string val, TVariable &vars, bool replace)
{
	TSymbol *res = NULL;
	TSymbol *fnd = NULL;

	std::string sym = symname;
	if (!casesen)
	{
		sym = Poco::toUpper(sym);
	}

	//printf("addvariable\n");
	fnd = findVariable(sym, vars);

	if ((fnd != NULL) && (!replace))
	{
		return (NULL);  // it is a duplicate
	}

	if (fnd != NULL)
	{
		//printf("replacing symbol: %s %s\n",sym.c_str(),val.c_str());
		fnd->var_text = val;
		return (fnd);
	}

	TSymbol s;
	s.name = sym;
	s.opcode = 0;
	s.namelc = Poco::toLower(sym);
	s.stype = 0;
	s.value = 0;
	s.var_text = val;
	s.used = false;
	s.cb = NULL;

	//printf("addvariable: %s %s\n", s.name.c_str(), s.var_text.c_str());

	std::pair<std::string, TSymbol> p(sym, s);
	vars.vars.insert(p);
	res = findVariable(sym, vars);
	return (res);
}

TSymbol * CLASS::findVariable(std::string symname, TVariable &vars)
{
	TSymbol *res = NULL;

	if (!casesen)
	{
		symname = Poco::toUpper(symname);
	}

	if ((expand_macrostack.size() > 0) && (vars.id != expand_macro.variables.id))
	{
		res = findVariable(symname, expand_macro.variables);
		if (res != NULL)
		{
			return (res);
		}
	}

	//printf("finding: %s\n",symname.c_str());
	auto itr = vars.vars.find(symname);
	if (itr != vars.vars.end())
	{
		//printf("Found: %s 0x%08X\n",itr->second.name.c_str(),itr->second.value);
		res = &itr->second;

		return (res);
	}
	return (res);
}

void CLASS::showVariables(TVariable &vars)
{
	if (vars.vars.size() > 0)
	{
		printf("\nVariables:\n");

		for (auto itr = vars.vars.begin(); itr != vars.vars.end(); ++itr)
		{
			printf("%-16s %s\n", itr->first.c_str(), itr->second.var_text.c_str());
		}
		printf("\n");
	}
}

// set alpha to true to print table sorted by name or
// false to print by value;
void CLASS::showSymbolTable(bool alpha)
{
	if (symbols.size() > 0)
	{
		std::map<std::string, uint32_t> alphamap;
		std::map<uint32_t, std::string> nummap;

		int columns = getInt("asm.symcolumns", 3);
		int column = columns;

		for (auto itr = symbols.begin(); itr != symbols.end(); itr++)
		{
			TSymbol ptr = itr->second;
			alphamap.insert(pair<std::string, uint32_t>(ptr.name, ptr.value));
			nummap.insert(pair<uint32_t, std::string>(ptr.value, ptr.name));
		}

		if (alpha)
		{
			printf("\n\nSymbol table sorted alphabetically:\n\n");

			for (auto itr = alphamap.begin(); itr != alphamap.end(); ++itr)
			{
				printf("%-16s 0x%08X       ", itr->first.c_str(), itr->second);
				if ( !--column )
				{
					printf("\n");
					column = columns;
				}
			}
		}
		else
		{
			printf("\n\nSymbol table sorted numerically:\n\n");
			for (auto itr = nummap.begin(); itr != nummap.end(); ++itr)
			{
				printf("0x%08X       %-16s ", itr->first, itr->second.c_str());
				if ( !--column )
				{
					printf("\n");
					column = columns;
				}
			}
		}
		if (column > 0)
		{
			printf("\n");
		}
	}
}

// set alpha to true to print table sorted by name or
// false to print by value;
void CLASS::showMacros(bool alpha)
{
	if (macros.size() > 0)
	{
		std::map<std::string, uint32_t> alphamap;

		int columns = getInt("asm.symcolumns", 3);
		int column = columns;

		for (auto itr = macros.begin(); itr != macros.end(); itr++)
		{
			TMacro ptr = itr->second;
			alphamap.insert(pair<std::string, uint32_t>(ptr.name, 0));
		}

		if (alpha)
		{
			printf("\n\nmacros sorted alphabetically:\n\n");

			for (auto itr = alphamap.begin(); itr != alphamap.end(); ++itr)
			{
				printf("%-16s 0x%08X       ", itr->first.c_str(), itr->second);
				if ( !--column )
				{
					printf("\n");
					column = columns;
				}
			}
		}
		if (column > 0)
		{
			printf("\n");
		}
	}
}

int CLASS::callOpCode(std::string op, MerlinLine &line)
{
	int res = -1;
	char c;
	std::string s;

	// 'op' is always lowercase here

// during MACRO definition no opcodes are called (except for MAC, EOM, <<)
	if (macrostack.size() > 0)
	{
		// if something on the macro stack, then a macro is being defined
		if (!((op == "mac") || (op == "eom") || (op == "<<<")))
		{
			return 0;
		}
	}

	if (op.length() == 4) // check for 4 digit 'L' opcodes
	{
		c = op[3] & 0x7F;
		if ((c >= 'a') && (c <= 'z'))
		{
			c = c - 0x20;
		}
		switch (c)
		{
		case 'L':
			op = op.substr(0, 3);
			line.flags |= FLAG_FORCELONG; // 3 byte address
			break;
		default:  // any char but 'L' as in Merlin 16+
			s = Poco::toUpper(op);
			if ((s == "ELSE") || (s == "DEND"))
			{
				break;
			}
			if (c != 'D')
			{
				op = op.substr(0, 3);
				line.flags |= FLAG_FORCEABS; // 2 byte address
			}
			break;
		case 'Z':
			op = op.substr(0, 3);
			line.flags |= FLAG_FORCEDP; // one byte address
			break;
		}
	}

	if (line.addressmode == syn_imm) //page 83 merlin16 manual
	{
		//printf("immediate mode\n");
		switch (line.shiftchar)
		{
		case '<':
			//line.expr_value &= 0xFF;
			break;
		case '>':
			//line.expr_value >>= 8;
			//line.expr_value &= 0xFFFF;
			break;
		case '^':
			//line.expr_value = (line.expr_value >> 16);
			//line.expr_value = (line.expr_value >> 16) & 0xFFFF;
			break;
		case '|': // should never get here, handled in getAddrMode
			//if (syntax == SYNTAX_MERLIN)
			if (options.isMerlin())
			{
				line.setError(errBadOperand);
				line.expr_value = 0;
			}
			//line.shiftchar=0;
			break;
		}
	}
	else
	{
		switch (line.shiftchar)  // page 84 Merlin16 manual
		{
		case '<':
			if (options.isMerlin32())
			{
				line.flags |= FLAG_DP;
				line.expr_value &= 0xFF;
			}
			break;
		case '>':
			if (options.isMerlin32())
			{
				// bug in M32 or not, do what it does
				//line.flags |= FLAG_FORCEABS;
				line.flags |= FLAG_FORCELONG;
			}
			else
			{
				// Merlin16+ uses this to force long addressing
				// need to check Merlin16
				if (!options.isMerlin())  // not merlin8
				{
					line.flags |= FLAG_FORCELONG;
				}

			}
			break;
		case '|':
			if ((!options.isMerlin32()) && (options.isMerlinCompat()))
			{
				line.flags |= FLAG_FORCEABS;
				//line.shiftchar=0;
			}
			break;
		case '^':
			if (options.isMerlin32())
			{
				line.flags |= FLAG_DP;
				line.expr_value >>= 16;
			}
			break;
		}
	}
	if (line.expr_value >= 0x100)
	{
		line.flags |= FLAG_FORCEABS;
	}

	auto itr = opcodes.find(Poco::toUpper(op));
	if (itr != opcodes.end())
	{
		TSymbol s = itr->second;
		if (s.cb != NULL)
		{
			res = s.cb(line, s);
			if (res == -1)
			{
				res = -2;
			}
		}
	}
	else
	{
		line.setError(errBadOpcode);
	}
	return (res);
}

typedef struct
{
	std::string regEx;
	uint16_t addrMode;
	std::string text;
	//std::string expression;
} TaddrMode;

// these are the regular expressions that determine the addressing mode
// and extract the 'expr' part of the addr-mode

const TaddrMode addrRegEx[] =
{
	{ "^(?'expr'.+)\\,[s,S]{1}$", syn_s, "e,s"},    				// expr,s
	{"^[(]{1}(?'expr'.+)[,]{1}[(S|s)]{1}[)]{1}[,]{1}[(Y|y)]{1}$", syn_sy, "(e,s),y"}, // (expr,s),y
	{"^#{1}(.+)$", syn_imm, "immediate"}, 				//#expr,#^expr,#|expr,#<expr,#>expr
	{"^[(]{1}(?'expr'.+)[,]{1}[x,X]{1}\\)$", syn_diix, "(dp,x)"},  			// (expr,x)
	{"^[(]{1}(?'expr'.+)[\\)]{1}[\\,][(Y|y]{1}$", syn_diiy, "(dp),y"}, 	//(expr),y
	{"^[(]{1}(?'expr'.+)[\\)]{1}$", syn_di, "(dp)"},					// (expr)
	{"^\\[{1}(?'expr'.+)\\]{1}[,]{1}[(Y|y)]{1}$", syn_iyl, "[laddr],y"},	// [expr],y
	{"^\\[(?'expr'.+)\\]$", syn_dil, "[e]"}, 						// [expr]
	{"^(?'expr'.+)[,]{1}[(X|x)]{1}$", syn_absx, "addr,x"},				// expr,x
	{"^(?'expr'.+)[,]{1}[(Y|y)]{1}$", syn_absy, "addr,y"},				// expr,y
	{"^(?'expr'.+)[,]{1}(?'expr2'.+)$", syn_bm, "block"},  			// block move expr,expr1
	{"^(?'expr'.+)$", syn_abs, "absolute"},  							// expr (MUST BE LAST)
	{"", 0, ""}
};

//	one or more of any character except ][,();
//const std::string valExpression = "^([^\\]\\[,();]+)$";
const std::string valExpression = "^([^\\[,();]+)$";

// this one looks for ]variables
const std::string varExpression = "([]]{1}[:0-9A-Z_a-z]{1}[0-9A-Z_a-z]*)";
const std::string macExpression = "([]]{1}[:0-9]{1}[0-9]*)";

// opcode check. emitted opcodes are compared against this
// table, and if the XC status doesn't meet the requirements
// an error is thrown

// 0x00 = 6502
// 0x01 = 65C02
// 0x02 = 65816
uint8_t opCodeCompatibility[256] =
{
	0x00, 0x00, 0x02, 0x02, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x02, 0x02, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x02, 0x01, 0x00, 0x00, 0x02,
	0x01, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x01, 0x00, 0x01, 0x02,
	0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02,
	0x00, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x02, 0x00, 0x00, 0x01, 0x02, 0x02, 0x00, 0x00, 0x02
};

void CLASS::init(void)
{
	uint8_t b = opCodeCompatibility[0];
	if (b)
	{
	}
	TFileProcessor::init();
	lines.clear();

	insertOpcodes();

}

void CLASS::initpass(void)
{
	std::string s;

	casesen = getBool("asm.casesen", true);
	listing = getBool("asm.lst", true);
	showmx = getBool("asm.showmx", true);
	merlinerrors = getBool("asm.merlinerrors", true);

	outputbytes.clear();
	trackrep = getBool("asm.trackrep", false);
	if (options.isMerlin32())
	{
		trackrep = true; // can't turn this off in M32
	}
	else if (options.isMerlin())
	{
		trackrep = false; // can't turn this ON in M16
	}
	else if (options.isNative())
	{
		// we will allow this to be settable default off
		trackrep = false;
		trackrep = getBool("asm.trackrep", trackrep);

	}
	//merlincompat = getBool("asm.merlincompatible", true);
	allowdup = getBool("asm.allowduplicate", true);

	skiplist = false;

	PC.origin = 0x8000;
	PC.currentpc = PC.origin;
	PC.totalbytes = 0;
	PC.orgsave = PC.origin;

	s = getConfig("asm.cpu", "M6502");
	s = Poco::trim(Poco::toUpper(s));

	s=PAL::getString("option.instruction","");
	if (s!="")
	{
		//printf("CPU command line %s\n",s.c_str());
		cpumode = MODE_65816;
		mx = 0x03;

		if (s == "M65816")
		{
			cpumode = MODE_65816;
			mx = 0x03;
		}
		else if (s == "M65C02")
		{
			cpumode = MODE_65C02;
			mx = 0x03;
		}
		else if (s == "M6502")
		{
			cpumode = MODE_6502;
			mx = 0x03;
		}
		else
		{
			printf("Unknown CPU type in .ini\n");
			mx = 0x03;
		}
	}
	mx = getInt("asm.startmx", mx);;


	savepath = getConfig("option.objfile", "");
	//printf("savepath: %s\n",savepath.c_str());

	lastcarry = false;
	relocatable = false;
	currentsym = NULL;
	if (options.isMerlin32())
	{
		// M32 allows locals that don't have a global above. this is the catchall for that
		currentsym = &topSymbol;    // this is the default symbol for :locals without a global above;
	}
	currentsymstr = "";
	lineno = 0;
	errorct = 0;
	passcomplete = false;
	dumstartaddr = 0;
	dumstart = 0;
	truncdata = 0;
	variables.vars.clear(); // clear the variables for each pass

	while (!macrostack.empty())
	{
		macrostack.pop();
	}
	while (!expand_macrostack.empty())
	{
		expand_macrostack.pop();
	}
	while (!LUPstack.empty())
	{
		LUPstack.pop();
	}
	while (!DOstack.empty())
	{
		DOstack.pop();
	}
	while (!LSTstack.empty())
	{
		LSTstack.pop();
	}
	while (!PCstack.empty())
	{
		PCstack.pop();
	}
	currentmacro.clear();
	expand_macro.clear();
	curLUP.clear();
	curDO.clear();
}

void CLASS::complete(void)
{
	bool writeerr=false;
	if (savepath != "")
	{
		if (errorct == 0)
		{
			std::string currentdir = Poco::Path::current();

			//savepath = processFilename(savepath, currentdir, 0);
			savepath=options.formatPath(savepath);
			if (!options.isQuiet())
			{
				printf("saving to file: %s\n", savepath.c_str());
			}

			//std::ofstream f(savepath, std::ios::out|std::ios::trunc);
			std::ofstream f(savepath, std::ios::out);

			if (f.is_open())
			{
				for (unsigned int i=0; i<outputbytes.size(); i++)
				{
					f.put(outputbytes[i]);
				}
				f.flush();
				//printf("outbytect=%ld\n",outputbytes.size());

				if (f.fail())
				{
					writeerr=true;
				}
				f.close();
			}
			else
			{
				writeerr=true;
			}
		}
		else
		{
			printf("\nErrors in assembly. Output not SAVED.\n\n");
		}
		if (writeerr)
		{
			printf("unable to save file.\n"); // TODO SGQ need to push error up the so exit code is non-zero
		}
	}
	if ((!options.isQuiet()) || (options.isList()))
	{
		printf("\n\nEnd qASM assembly, %d bytes, %u errors, %lu lines, %lu symbols.\n", PC.totalbytes, errorct, lines.size(), symbols.size());
	}

	TFileProcessor::complete();

	if ((errorct==0) && (listing) && (!options.isQuiet()))
	{
		showSymbolTable(true);
		showSymbolTable(false);
		showVariables(variables);
		showMacros(true);
	}

}

int CLASS::evaluate(MerlinLine &line, std::string expr, int64_t &value)
{
	int res = -1;
	int64_t result = 0;

	if (expr.length() > 0)
	{

		TEvaluator eval(*this);
		line.eval_result = 0;

		res = eval.evaluate(expr, result, line.expr_shift);
		if (res != 0)
		{
			if (isDebug() > 2)
			{
				int c;
				if (options.useColor())
				{
					c = SetColor(CL_RED);
				}
				uint32_t rr = result & 0xFFFFFFFF;
				printf("eval Error=%d %08X |%s|\n", res, rr, eval.badsymbol.c_str());
				if (options.useColor())
				{
					SetColor(c);
				}
			}
		}
		if (res == 0)
		{
			uint64_t v1 = (uint64_t) result;
			value = result;
			if ((listing) && (pass > 0) && (isDebug() > 2))
			{
				uint32_t rr = v1 & 0xFFFFFFFF;
				printf("EV1=%08X '%c'\n", rr, line.expr_shift);
			}
			if (v1 >= 0x10000)
			{
				line.flags |= FLAG_BIGNUM;
			}
			if (v1 < 0x100)
			{
				line.flags |= FLAG_DP;
			}
		}
	}
	else
	{
		value = 0;
		res = 0;
	}
	if (isDebug() >= 3)
	{
		uint32_t rr = value & 0xFFFFFFFF;
		printf("Eval Result: %08X (status=%d)\n", rr, res);
	}
	return (res);
}

int CLASS::getAddrMode(MerlinLine & line)
{
	int  res = -1;
	uint16_t mode = syn_none;
	int idx, x;
	std::string s, oper;
	std::vector<std::string> groups;
	char shiftchar;

	oper = line.operand;
	int l=oper.length();
	int ol=line.opcode.length();
	if ((ol == 0) || (l <= 0))
	{
		if (ol>0)
		{
			return (syn_implied);
		}
		else
		{
			return(syn_none);
		}
	}

	bool supportbar=false;
	bool modified=false;

	shiftchar=oper[0];
	if (shiftchar=='#')
	{
		shiftchar=0;
		if (l>1)
		{
			shiftchar=oper[1];

			//oper=oper.substr(1);
			//oper="#"+oper;
		}
	}
	if (shiftchar=='^')
	{
		if (options.isMerlin())
		{
			return(syn_err);
			//shiftchar=0x00; // merlin8 does not support the bank addr
		}
	}
	if (shiftchar=='|')
	{
		if (options.isMerlinCompat())
		{
			if ((options.isMerlin() || options.isMerlin16())) // merlin8 and merlin16 do not support the bar
			{
				return(syn_err);
			}
			else
			{
				supportbar=true;
			}
		}
	}

	if ((shiftchar=='^') || (shiftchar=='<') || (shiftchar=='>') || (supportbar && (shiftchar=='|')))
	{
		modified=true;
	}

	if (modified)
	{
		line.shiftchar=shiftchar;
		if (oper[0]=='#')
		{
			oper=oper.substr(2);
			oper="#"+oper;
			l=oper.length();
		}
		else if (shiftchar!=0)
		{
			oper=oper.substr(1);
			l=oper.length();
		}
		if (isDebug()>1)
		{
			printf("old: |%s| new: |%s|\n",line.operand.c_str(),oper.c_str());
		}
		line.strippedoperand=oper;
	}

	if (supportbar && shiftchar=='|')
	{
		//if ((options.isMerlin32()) || (options.isNative()))
		if (options.isMerlin32())
		{
			// regular Merlin16/16+ seems to accept this character, but does NOT force long (bank) addressing
			line.flags|=FLAG_FORCELONG;
		}
		//shiftchar=0; // don't process this as a shift because we only needed to set a flag to force long addressing
	}

	idx = 0;
	RegularExpression valEx(valExpression, 0, true);

	while (mode == syn_none)
	{
		s = addrRegEx[idx].regEx;
		if (s == "")
		{
			mode = syn_err; // no more RegX left (nothing matched)
		}
		else
		{
			RegularExpression regex(s, 0, true);
			groups.clear();
			x = 0;
			try
			{
				//printf("oper: |%s|\n",oper.c_str());
				x = regex.split(oper, 0, groups, 0);
			}
			catch (...)
			{
				x = 0;
			}
			if (x > 0)
			{
				mode = addrRegEx[idx].addrMode;
				line.addrtext = addrRegEx[idx].text;
				//cout << "mode: " << line.addrtext << endl;
				int ct = 0;
				for (uint32_t i = 0; i < groups.size(); i++)
				{
					s = groups[i];
					//printf("ct=%zu idx=%d group: |%s|\n", groups.size(), i, s.c_str());

					if (s != "")
					{
						//if ((s != "^") && (s != "<") && (s != ">") && (s != "|"))
						{
							bool v = true;
							if (mode == syn_abs)
							{
								if (i > 0)
								{
									v = valEx.match(s, 0, 0);
									if (v)
									{
										if (pass == 0)
										{
											// can only check on pass 0, because if the A"
											// symbol is defined later, we will generate different
											// bytes on the next pass

											if (options.isMerlin32())
												//if ((line.syntax & SYNTAX_MERLIN32)  == SYNTAX_MERLIN32)
											{
												if (Poco::toUpper(oper) == "A") // check the whole operand, not just the expression
												{
													TSymbol *sym = findSymbol("A");
													if (sym == NULL)
													{
														line.flags |= FLAG_FORCEIMPLIED;
														mode = syn_implied; // if the label hasn't been defined yet, assume Immediate addressing
														goto out;
													}
												}
											}
										}
										else if (line.flags & FLAG_FORCEIMPLIED)
										{
											mode = syn_implied;
											goto out;
										}
									}
								}
							}
							if (!v)
							{
								//printf("invalid expression |%s|\n", s.c_str());
								mode = syn_none;
							}
							else if (ct == 1)
							{
								line.operand_expr = s;
							}
							else if (ct == 2)
							{
								line.operand_expr2 = s;
							}
							ct++;
							//printf("line expression=|%s|\n", s.c_str());
						}
						//else
						{
							// SGQ need to set a flag for a shift and process it after eval
						}
					}
				}
			}
		}
		idx++;
	}
out:
	if (mode == syn_none)
	{
		mode = syn_err;
	}
	res = mode;
	//printf("syn_mode=%d\n", mode);
	return (res);
}

int CLASS::parseOperand(MerlinLine & line)
{

	int res = -1;

	line.operand_expr = "";
	int  m = getAddrMode(line);
	if (m >= 0)
	{
		res = m;
	}
	else
	{
		//errorOut(errBadAddressMode);
	}
	if (isDebug()>1)
	{
		printf("addressmode=%d %s\n",res,options.addrModeEnglish(res).c_str());
	}
	return (res);
}


int CLASS::substituteVariables(MerlinLine & line, std::string &outop)
{
	int res = 0;
	int x,x1;
	std::string::size_type offset, slen;
	std::string oper = line.operand;
	std::string s;
	std::string operin;
	TSymbol *sym;
	uint32_t len, off, ct;

	bool done = false;
	operin = oper;
	ct = 0;
	bool mac_var;
restart:
	while (!done)
	{

		mac_var=false;
		slen = oper.length();
		if (slen > 0)
		{
			std::vector<std::string> groups;

			offset = 0;
			RegularExpression varEx(varExpression, 0, true);
			Poco::RegularExpression::MatchVec  mVec;

			//printf("|%s|%s|\n", varExpression.c_str(), oper.c_str());
			groups.clear();
			while (offset < slen)
			{
				try
				{
					varEx.match(oper, offset, mVec, 0);
				}
				catch (...)
				{
					offset = slen;
				}

				x = (int)mVec.size();
				if (x > 0)
				{
					res = 0;
					off = (uint32_t)mVec[0].offset;
					len = (uint32_t)mVec[0].length;
					s = oper.substr(off, len);
					slen = s.length();
					sym = NULL;
					if (expand_macrostack.size() > 0)
					{
						mac_var=true;
						sym = findVariable(s, expand_macro.variables);
						if (sym!=NULL)
						{
							RegularExpression varEx1(macExpression, 0, true);
							Poco::RegularExpression::MatchVec  mVec1;
							try
							{
								varEx1.match(oper, 0, mVec1, 0);
								x1 = (int)mVec1.size();
								if (x1>0)
								{
									mac_var=true;
									//printf("Found MACvar: |%s| |%s|\n",sym->name.c_str(),sym->var_text.c_str());
								}
							}
							catch(...)
							{

							}

						}
					}
					else
					{
						//mac_var=true;
					}
					if (sym == NULL)
					{
						sym = findVariable(s, variables);
					}

					if ((expand_macrostack.size() == 0) && (!mac_var))
					{
						//mac_var=true;
					}

					if ((sym != NULL) && (mac_var))
					{
						//printf("match |%s|\n",sym->var_text.c_str());

						if (sym->var_text != "")
						{
							oper = oper.replace(off, len, sym->var_text);
							slen = oper.length();
							ct++;
							if (pass > 0)
							{
								//printf("%d |%s|\n", ct, s.c_str());
							}
							goto restart;
						}
					}
					else
					{
						done = true;
					}
					offset += len;
				}
				else
				{
					offset = slen;
					done = true;
				}
			}

		}
		else
		{
			done = true;
		}
	}
//printf("inoper=|%s| outoper=|%s|\n",operin.c_str(),oper.c_str());
	if (ct > 0)
	{
		outop = oper;
		res = ct;
	}
	return (res);
}

bool CLASS::doOFF(void)
{
	bool res = curDO.doskip;
	std::stack<TDOstruct> tmpstack;
	TDOstruct doitem;

	uint32_t ct = (uint32_t)DOstack.size();
	if (ct > 0)
	{
		tmpstack = DOstack;
	}
	while (ct > 0)
	{
		doitem = tmpstack.top();
		tmpstack.pop();
		if (doitem.doskip)
		{
			res = true;
		}
		ct--;
	}
	//printf("DOOFF: %d\n",res);
	return (res);
}

// this function determines if code generation is turned off (IF,DO,LUP,MAC, etc
bool CLASS::codeSkipped(void)
{
	bool res = false;

	res = (curLUP.lupskip) ? true : res;
	res = doOFF() ? true : res;
	res = currentmacro.running ? true : res;

	//printf("codeskip: %d\n",res);

	return (res);
}

void CLASS::process(void)
{

#if 0
	uint32_t ct = lines.size();
	for (uint32_t lineno = 0; lineno < ct; lineno++)
	{
		//MerlinLine &line = lines.at(lineno);
		//printf("|%s| |%s| |%s| |%s|\n", line.lable.c_str()
		//       , line.opcode.c_str(), line.operand.c_str(), line.comment.c_str());
	}
#else

	uint32_t l;
	int x;;
	char c;
	char buff[256];
	MerlinLine errLine(options);
	std::string op, realop, operand, ls;

	pass = 0;
	while (pass < 2)
	{
		initpass();

		l = (uint32_t)lines.size();
		bool passdone = false;
		while ((!passdone) && (!passcomplete))
		{

			MerlinLine *ml = NULL;
			bool srcline = true;
			if (expand_macro.running)
			{
				srcline = false;
				if (expand_macro.currentline >= expand_macro.len)
				{
					// macro is complete
					lineno = expand_macro.sourceline + 1;
					if (expand_macrostack.size() > 0)
					{
						expand_macro = expand_macrostack.top();
						expand_macrostack.pop();
					}
					else
					{
						expand_macro.clear();
					}
					srcline = true;
				}
				else
				{
					ml = &expand_macro.lines[expand_macro.currentline];
					lineno = expand_macro.sourceline;
					expand_macro.currentline++;
				}
			}
			if (srcline)
			{
				if (lineno >= l)
				{
					passdone = true;
					goto passout;
				}
				else
				{
					ml = &lines[lineno];
				}
			}

			MerlinLine &line = *ml;

			//printf("lineno=%u %s\n", lineno, line.wholetext.c_str());

			line.eval_result = 0;
			line.lineno = lineno + 1;
			line.truncdata = truncdata;
			memcpy(line.tabs, tabs, sizeof(tabs));
			//printf("lineno: %d %d |%s|\n",lineno,l,line.operand.c_str());

			op = Poco::toLower(line.opcode);
			realop = line.opcode;
			operand = Poco::toLower(line.operand);
			line.startpc = PC.currentpc;
			line.linemx = mx;
			line.bytect = 0;
			line.showmx = showmx;
			//line.syntax = syntax;
			line.merlinerrors = merlinerrors;

			if ((line.lable != "") && (op != "mac"))
			{
				std::string lable = Poco::trim(line.lable);
				TSymbol *sym = NULL;
				bool dupsym = false;
				c = line.lable[0];
				switch (c)
				{
				case ']':
					sprintf(buff, "$%X", PC.currentpc);
					ls = buff;
					sym = addVariable(line.lable, ls, variables, true);
					//if (sym == NULL) { dupsym = true; }
					break;

				case ':':
				default:
					if (pass == 0)
					{
						sym = addSymbol(line.lable, PC.currentpc, false);
						if (sym == NULL)
						{
							dupsym = true;
							line.setError(errDupSymbol);
						}
					}
					if (c != ':')
					{
						currentsym = findSymbol(line.lable);
						currentsymstr = line.lable;
					}
					break;
				}
				if (dupsym)
				{
					line.setError(errDupSymbol);
				}
			}
			std::string outop;
			line.printoperand = line.operand;
			//printf("\nprintoperand: |%s|\n",line.printoperand.c_str());
			//printf("\noperand: |%s|\n",operand.c_str());

			x = 0;
			if (macrostack.size() == 0)
			{
				x = substituteVariables(line, outop);
			}
			if (x > 0)
			{
				line.printoperand = outop;
				line.operand = outop;
			}
			x = parseOperand(line);
			//if (x >= 0)
			//{
			line.addressmode = x;
			//}

			int64_t value = -1;
			x = evaluate(line, line.operand_expr, value);

			line.eval_result = x;
			if (x == 0)
			{
				value &= 0xFFFFFFFF;
				line.expr_value = (uint32_t)value;
			}
			else
			{
				line.expr_value = 0;
			}

			x = 0;
			if (op.length() > 0)
			{
				bool skipop = false;
				if (doOFF())
				{
					skipop = true;
					if ((op == "fin") || (op == "else") || (op == "do") || (op == "if"))
					{
						skipop = false;
					}
				}
				if (!skipop)
				{
					TMacro *mac = NULL;
					bool inoperand = false;
					if (macrostack.size() == 0)
					{
						mac = findMacro(realop);
						if (mac == NULL)
						{
							if (op == ">>>") // specal merlin way of calling a macro
							{
								Poco::StringTokenizer tok(operand, ", ", Poco::StringTokenizer::TOK_TRIM |
								                          Poco::StringTokenizer::TOK_IGNORE_EMPTY);
								std::string s = "";
								if (tok.count() > 0)
								{
									s = tok[0];
								}
								mac = findMacro(s);
								inoperand = true;
							}
						}
					}
					if (mac == NULL)
					{
						x = callOpCode(op, line);
					}
					if (mac != NULL)
					{
						expand_macrostack.push(expand_macro);
						expand_macro = *mac;

						expand_macro.lines.clear();
						//printf("mac start=%u end=%u\n", expand_macro.start, expand_macro.end);
						for (uint32_t lc = expand_macro.start; lc < expand_macro.end; lc++)
						{
							//printf("pushing %s\n", lines[lc].wholetext.c_str());
							MerlinLine nl(lines[lc].wholetext,options);  // create a new clean line (without errors,data)
							expand_macro.lines.push_back(nl);
						}
						expand_macro.running = true;
						expand_macro.sourceline = lineno;
						expand_macro.variables.vars.clear();
						// set the variables for the macro here SGQ

						std::string parms = line.operand;
						if (inoperand)
						{
							Poco::StringTokenizer tok(parms, ", ", Poco::StringTokenizer::TOK_TRIM |
							                          Poco::StringTokenizer::TOK_IGNORE_EMPTY);
							parms = "";
							if (tok.count() > 1)
							{
								parms = tok[1];
							}
						}
						Poco::StringTokenizer tok(parms, ",;", Poco::StringTokenizer::TOK_TRIM |
						                          Poco::StringTokenizer::TOK_IGNORE_EMPTY);

						uint32_t ct = 0;
						for (auto itr = tok.begin(); itr != tok.end(); ++itr)
						{
							//evaluate each of these strings, check for errors on pass 2
							std::string expr = *itr;
							std::string v = "]" + Poco::NumberFormatter::format(ct + 1);
							//printf("var: %s %s\n", v.c_str(), expr.c_str());
							addVariable(v, expr, expand_macro.variables, true);
							ct++;
						}
						x = 0;
						expand_macro.currentline = 0;
					}
				}
			}

			if ((x > 0) && (codeSkipped())) // has a psuedo-op turned off code generation? (LUP, IF, etc)
			{
				x = 0;
				line.outbytect = 0;
			}

			if (x > 0)
			{
				if (!PCstack.empty()) // are we inside a DUM section?
				{
					line.flags |= FLAG_INDUM;
				}
				if ((line.eval_result != 0) && (pass > 0))
				{
					line.setError(errBadOperand);
					line.errorText = line.operand_expr;
				}
				line.bytect = x;
				if (pass>0)
				{
					if ((line.flags & FLAG_INDUM) == 0) // don't write bytes if inside DUM section
					{
						for (unsigned int i=0; i<line.outbytes.size(); i++)
						{
							outputbytes.push_back(line.outbytes[i]);
						}
						if (line.datafillct>0)
						{
							for (int i=0; i<line.datafillct; i++)
							{
								outputbytes.push_back(line.datafillbyte);
							}
						}
					}
				}

				PC.currentpc += x;
				PC.totalbytes += x;
			}
			if (pass == 0)
			{
				line.pass0bytect = line.bytect;
			}

			if (dumstart > 0) // starting a dummy section
			{
				PCstack.push(PC);
				PC.origin = dumstartaddr;
				PC.currentpc = PC.origin;
				dumstart = 0;
				dumstartaddr = 0;
			}
			if (dumstart < 0)
			{
				PC = PCstack.top();
				PCstack.pop();
				dumstart = 0;
				dumstartaddr = 0;
			}

			if (pass == 1)
			{
				if ((line.pass0bytect != line.bytect) && (line.errorcode == 0))
				{
					if (expand_macrostack.size() == 0)  // if macro expanding, you can't make this check
					{
						line.setError(errBadByteCount);
					}
				}

				if (line.errorcode != 0)
				{
					errorct++;
				}
				if (((!skiplist) && (listing) && (pass == 1)) || (line.errorcode != 0) || (options.isList()))
				{
					line.print(lineno);
				}
				skiplist = false;
				line.outbytes.clear();  // clear the outbytes on the line so LUP works correctly
				line.outbytect=0;

			}
			lineno++;
		}
passout:
		// end of file reached here, do some final checks

#if 0
		if (LUPstack.size() > 0)
		{
			errLine.clear();
			errLine.setError(errUnexpectedEOF);
			errLine.print(lineno);
			pass = 2;
		}
#endif
		pass++;
	}
#endif
}

int CLASS::doline(int lineno, std::string line)
{
	int res = 0;
	int x;
	std::string op;

	UNUSED(lineno);

	MerlinLine l(line,options);

	op = Poco::toLower(l.opcode);
	lines.push_back(l);

	if ((op == "use") || (op == "put"))
	{
		std::string fn;
		x = processfile(l.operand, fn);
		//printf("processfile : %d\n",x);
		if (x < 0)
		{
			switch (x)
			{
			case -9:
				l.setError(errDuplicateFile);
				break;
			case -3:
				l.setError(errFileNotFound);
				break;
			case -2:
				l.setError(errFileNoAccess);
				break;
			default:
				l.setError(errFileNotFound);
				break;
			}
			l.operand = fn;
			l.print(0);
			errorct++;
			res = -1;
		}
	}

	return (res);
}

#undef CLASS

#define CLASS T65816Link

CLASS::CLASS(ConfigOptions &opt) : TFileProcessor(opt)
{
}

CLASS::~CLASS()
{
}

void CLASS::init(void)
{
	TFileProcessor::init();
}

void CLASS::process(void)
{

}
void CLASS::complete(void)
{
}

int CLASS::doline(int lineno, std::string line)
{