// MgAsmBase.cpp: implementation of the CMgAsmBase class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "MgAsmCom.h"
#include "MgAsmComDef.h"


//-------------------------------------------------------------------------------------------------------------------------
//全局变量声明:


//-------------------------------------------------------------------------------------------------------------------------
//
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMgAsmBase::CMgAsmBase()
{
	//
	m_pAsmCmd = NULL;          // Pointer to 0-terminated source line
	m_nScan = 0;             // Type of last scanned element
	m_nPrio = 0;             // Priority of operation (0: highest)

	//
	memset(m_sdata, 0, TEXTLEN);            // Last scanned name (depends on type)

	//
	m_idata = 0;             // Last scanned value
	m_fdata = 0;             // Floating-point number
	m_pAsmError = NULL;		  // Explanation of last error, or NULL

	//
	m_nIDEAL = 0;             // Force IDEAL decoding mode
	m_nSizeSens = 0;             // How to decode size-sensitive mnemonics
}

CMgAsmBase::~CMgAsmBase()
{

}


//--------------------------------------------------------------------------------
// Simple and slightly recursive scanner shared by Assemble(). The scanner is
// straightforward and ineffective, but high speed is not a must here. As
// input, it uses global pointer to source line asmcmd. On exit, it fills in
// global variables scan, prio, sdata, idata and/or fdata. If some error is
// detected, asmerror points to error message, otherwise asmerror remains
// unchanged.
//--------------------------------------------------------------------------------
void		CMgAsmBase::Scanasm(int mode)
{
	int i, j, base, maxdigit;
	long decimal, hex;
	long double floating, divisor;
	char s[TEXTLEN], * pcmd;

	m_sdata[0] = '\0';
	m_idata = 0;

	//
	if (m_pAsmCmd == NULL)
	{
		m_pAsmError = ("NULL input line");
		m_nScan = SCAN_ERR;
		return;
	}

	//
	while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
	{
		m_pAsmCmd++;    // Skip leading spaces
	}

	//
	if (*m_pAsmCmd == '\0' || *m_pAsmCmd == ';')
	{
		m_nScan = SCAN_EOL;    // Empty line
		return;
	}

	//
	if (isalpha(*m_pAsmCmd) || *m_pAsmCmd == '_' || *m_pAsmCmd == '@')
	{
		m_sdata[0] = *m_pAsmCmd++;
		i = 1;         // Some keyword or identifier
		while ((isalnum(*m_pAsmCmd) || *m_pAsmCmd == '_' || *m_pAsmCmd == '@') && i < sizeof(m_sdata))
		{
			m_sdata[i++] = *m_pAsmCmd++;
		}
		if (i >= sizeof(m_sdata))
		{
			m_pAsmError = ("Too long identifier");
			m_nScan = SCAN_ERR;
			return;
		}

		m_sdata[i] = '\0';

		while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
		{
			m_pAsmCmd++;                        // Skip trailing spaces
		}
		strcpy(s, m_sdata);
		strupr(s);

		for (j = 0; j <= 8; j++)
		{
			// j==8 means "any register"
			if (strcmp(s, g_szRegName[0][j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_REG8;       // 8-bit register
			return;
		}

		for (j = 0; j <= 8; j++)
		{
			if (strcmp(s, g_szRegName[1][j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_REG16;      // 16-bit register
			return;
		}

		for (j = 0; j <= 8; j++)
		{
			if (strcmp(s, g_szRegName[2][j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_REG32;      // 32-bit register
			return;
		}

		for (j = 0; j < 6; j++)
		{
			if (strcmp(s, g_szSegName[j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_SEG;        // Segment register
			while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
			{
				m_pAsmCmd++;      // Skip trailing spaces
			}
			return;
		}

		if (strcmp(s, "ST") == 0)
		{
			pcmd = m_pAsmCmd;
			Scanasm(SA_NAME);   // FPU register
			if (m_nScan != SCAN_SYMB || m_idata != '(')
			{
				m_pAsmCmd = pcmd;                 // Undo last scan
				m_idata = 0;
				m_nScan = SCAN_FPU;
				return;
			}
			Scanasm(SA_NAME);
			j = m_idata;
			if ((m_nScan != SCAN_ICONST && m_nScan != SCAN_DCONST) || m_idata < 0 || m_idata > 7)
			{
				m_pAsmError = ("FPU registers have indexes 0 to 7");
				m_nScan = SCAN_ERR;
				return;
			}

			Scanasm(SA_NAME);
			if (m_nScan != SCAN_SYMB || m_idata != ')')
			{
				m_pAsmError = ("Closing parenthesis expected");
				m_nScan = SCAN_ERR;
				return;
			}
			m_idata = j;
			m_nScan = SCAN_FPU;
			return;
		}
		for (j = 0; j <= 8; j++)
		{
			if (strcmp(s, g_szFPUName[j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_FPU;        // FPU register (alternative coding)
			return;
		}
		for (j = 0; j <= 8; j++)
		{
			if (strcmp(s, g_szMMXName[j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_MMX;        // MMX register
			return;
		}
		for (j = 0; j <= 8; j++)
		{
			if (strcmp(s, g_szCRName[j]) != 0)
			{
				continue;
			}
			m_idata = j;
			m_nScan = SCAN_CR;         // Control register
			return;
		}
		for (j = 0; j <= 8; j++)
		{
			if (strcmp(s, g_szDRName[j]) != 0) continue;
			m_idata = j;
			m_nScan = SCAN_DR;         // Debug register
			return;
		}
		for (j = 0; j < sizeof(g_szSizeName) / sizeof(g_szSizeName[0]); j++)
		{
			if (strcmp(s, g_szSizeName[j]) != 0)
			{
				continue;
			}
			pcmd = m_pAsmCmd;
			Scanasm(SA_NAME);
			if (m_nScan != SCAN_PTR)            // Fetch non-functional "PTR"
			{
				m_pAsmCmd = pcmd;
			}
			m_idata = j;
			m_nScan = SCAN_OPSIZE;     // Operand (data) size in bytes
			return;
		}
		if (strcmp(s, ("EIP")) == 0)
		{
			// Register EIP
			m_nScan = SCAN_EIP;
			m_idata = 0;
			return;
		}
		if (strcmp(s, ("SHORT")) == 0)
		{
			// Relative jump has 1-byte offset
			m_nScan = SCAN_JMPSIZE;
			m_idata = 1;
			return;
		}
		if (strcmp(s, ("LONG")) == 0)
		{
			// Relative jump has 4-byte offset
			m_nScan = SCAN_JMPSIZE;
			m_idata = 2;
			return;
		}
		if (strcmp(s, ("NEAR")) == 0)
		{
			// Jump within same code segment
			m_nScan = SCAN_JMPSIZE;
			m_idata = 4;
			return;
		}
		if (strcmp(s, ("FAR")) == 0)
		{
			// Jump to different code segment
			m_nScan = SCAN_JMPSIZE;
			m_idata = 8;
			return;
		}
		if (strcmp(s, ("LOCAL")) == 0 && *m_pAsmCmd == '.')
		{
			m_pAsmCmd++;
			while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
			{
				m_pAsmCmd++;    // Skip trailing spaces
			}
			if (!isdigit(*m_pAsmCmd))
			{
				m_pAsmError = ("Integer number expected");
				m_nScan = SCAN_ERR;
				return;
			}
			while (isdigit(*m_pAsmCmd))         // LOCAL index is decimal number!
			{
				m_idata = m_idata * 10 + (*m_pAsmCmd++) - '0';
			}
			m_nScan = SCAN_LOCAL;
			return;
		}
		if (strcmp(s, ("ARG")) == 0 && *m_pAsmCmd == '.')
		{
			m_pAsmCmd++;
			while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
			{
				m_pAsmCmd++;    // Skip trailing spaces
			}
			if (!isdigit(*m_pAsmCmd))
			{
				m_pAsmError = ("Integer number expected");
				m_nScan = SCAN_ERR;
				return;
			}
			while (isdigit(*m_pAsmCmd))         // ARG index is decimal number!
			{
				m_idata = m_idata * 10 + (*m_pAsmCmd++) - '0';
			}
			m_nScan = SCAN_ARG;
			return;
		}
		if (strcmp(s, ("REP")) == 0)
		{
			m_nScan = SCAN_REP;    // REP prefix
			return;
		}
		if (strcmp(s, ("REPE")) == 0 || strcmp(s, ("REPZ")) == 0)
		{
			m_nScan = SCAN_REPE;    // REPE prefix
			return;
		}
		if (strcmp(s, ("REPNE")) == 0 || strcmp(s, ("REPNZ")) == 0)
		{
			m_nScan = SCAN_REPNE;    // REPNE prefix
			return;
		}
		if (strcmp(s, ("LOCK")) == 0)
		{
			m_nScan = SCAN_LOCK;    // LOCK prefix
			return;
		}
		if (strcmp(s, ("PTR")) == 0)
		{
			m_nScan = SCAN_PTR;    // PTR in MASM addressing statements
			return;
		}
		if (strcmp(s, ("CONST")) == 0 || strcmp(s, ("OFFSET")) == 0)
		{
			m_nScan = SCAN_OFS;    // Present but undefined offset/constant
			return;
		}
		if (strcmp(s, ("SIGNED")) == 0)
		{
			m_nScan = SCAN_SIGNED;    // Keyword "SIGNED" (in expressions)
			return;
		}
		if (strcmp(s, ("UNSIGNED")) == 0)
		{
			m_nScan = SCAN_UNSIGNED;    // Keyword "UNSIGNED" (in expressions)
			return;
		}
		if (strcmp(s, ("CHAR")) == 0)
		{
			m_nScan = SCAN_CHAR;    // Keyword "CHAR" (in expressions)
			return;
		}
		if (strcmp(s, ("FLOAT")) == 0)
		{
			m_nScan = SCAN_FLOAT;    // Keyword "FLOAT" (in expressions)
			return;
		}
		if (strcmp(s, ("DOUBLE")) == 0)
		{
			m_nScan = SCAN_DOUBLE;    // Keyword "DOUBLE" (in expressions)
			return;
		}
		if (strcmp(s, ("FLOAT10")) == 0)
		{
			m_nScan = SCAN_FLOAT10;    // Keyword "FLOAT10" (in expressions)
			return;
		}
		if (strcmp(s, ("STRING")) == 0)
		{
			m_nScan = SCAN_STRING;    // Keyword "STRING" (in expressions)
			return;
		}
		if (strcmp(s, ("UNICODE")) == 0)
		{
			m_nScan = SCAN_UNICODE;    // Keyword "UNICODE" (in expressions)
			return;
		}
		if (strcmp(s, ("MSG")) == 0)
		{
			m_nScan = SCAN_MSG;    // Pseudovariable MSG (in expressions)
			return;
		}
		if (mode & SA_NAME)
		{
			m_idata = i;
			m_nScan = SCAN_NAME;       // Don't try to decode symbolic label
			return;
		}
		m_pAsmError = ("Unknown identifier");
		m_nScan = SCAN_ERR;
		return;
	}
	else if (isdigit(*m_pAsmCmd))            // Constant
	{
		base = 0;
		maxdigit = 0;
		decimal = hex = 0L;
		floating = 0.0;
		if (m_pAsmCmd[0] == '0' && toupper(m_pAsmCmd[1]) == 'X')
		{
			base = 16;
			m_pAsmCmd += 2;
		}           // Force hexadecimal number
		while (1)
		{
			if (isdigit(*m_pAsmCmd))
			{
				decimal = decimal * 10 + (*m_pAsmCmd) - '0';
				floating = floating * 10.0 + (*m_pAsmCmd) - '0';
				hex = hex * 16 + (*m_pAsmCmd) - '0';
				if (maxdigit == 0)
				{
					maxdigit = 9;
				}
				m_pAsmCmd++;

			}
			else if (isxdigit(*m_pAsmCmd))
			{
				hex = hex * 16 + toupper(*m_pAsmCmd++) - 'A' + 10;
				maxdigit = 15;
			}
			else
			{
				break;
			}
		}
		if (maxdigit == 0)
		{
			m_pAsmError = ("Hexadecimal digits after 0x... expected");
			m_nScan = SCAN_ERR;
			return;
		}
		if (toupper(*m_pAsmCmd) == 'H')
		{
			// Force hexadecimal number
			if (base == 16)
			{
				m_pAsmError = ("Please don't mix 0xXXXX and XXXXh forms");
				m_nScan = SCAN_ERR;
				return;
			}
			m_pAsmCmd++;
			m_idata = hex;
			m_nScan = SCAN_ICONST;
			while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
			{
				m_pAsmCmd++;
			}
			return;
		}
		if (*m_pAsmCmd == '.')
		{
			// Force decimal number
			if (base == 16 || maxdigit > 9)
			{
				m_pAsmError = ("Not a decimal number");
				m_nScan = SCAN_ERR;
				return;
			}
			m_pAsmCmd++;
			if (isdigit(*m_pAsmCmd) || toupper(*m_pAsmCmd) == 'E')
			{
				divisor = 1.0;
				while (isdigit(*m_pAsmCmd))
				{
					// Floating-point number
					divisor /= 10.0;
					floating += divisor * (*m_pAsmCmd - '0');
					m_pAsmCmd++;
				}
				if (toupper(*m_pAsmCmd) == 'E')
				{
					m_pAsmCmd++;
					if (*m_pAsmCmd == '-')
					{
						base = -1;
						m_pAsmCmd++;
					}
					else
					{
						base = 1;
					}
					if (!isdigit(*m_pAsmCmd))
					{
						m_pAsmError = ("Invalid exponent");
						m_nScan = SCAN_ERR;
						return;
					}
					decimal = 0;
					while (isdigit(*m_pAsmCmd))
					{
						if (decimal < 65536L) decimal = decimal * 10 + (*m_pAsmCmd++) - '0';
					}
					//floating*=pow10l(decimal*base);
					floating *= powl(10, decimal * base);
				}
				m_fdata = floating;
				m_nScan = SCAN_FCONST;
				return;
			}
			else
			{
				m_idata = decimal;
				m_nScan = SCAN_DCONST;
				while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
				{
					m_pAsmCmd++;
				}
				return;
			}
		}
		m_idata = hex;
		m_nScan = SCAN_ICONST;     // Default is hexadecimal
		while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
		{
			m_pAsmCmd++;
		}
		return;
	}
	else if (*m_pAsmCmd == '\'')             // Character constant
	{
		m_pAsmCmd++;
		if (*m_pAsmCmd == '\0' || (*m_pAsmCmd == '\\' && m_pAsmCmd[1] == '\0'))
		{
			m_pAsmError = ("Unterminated character constant");
			m_nScan = SCAN_ERR;
			return;
		}
		if (*m_pAsmCmd == '\'')
		{
			m_pAsmError = ("Empty character constant");
			m_nScan = SCAN_ERR;
			return;
		}
		if (*m_pAsmCmd == '\\')
		{
			m_pAsmCmd++;
		}
		m_idata = *m_pAsmCmd++;
		if (*m_pAsmCmd != '\'')
		{
			m_pAsmError = ("Unterminated character constant");
			m_nScan = SCAN_ERR;
			return;
		}
		m_pAsmCmd++;
		while (*m_pAsmCmd == ' ' || *m_pAsmCmd == '\t')
		{
			m_pAsmCmd++;
		}
		m_nScan = SCAN_ICONST;
		return;
	}
	else                                  // Any other character or combination
	{
		m_idata = m_sdata[0] = *m_pAsmCmd++;
		m_sdata[1] = m_sdata[2] = '\0';
		if (m_idata == '|' && *m_pAsmCmd == '|')
		{
			m_idata = '||';
			m_nPrio = 10;           // '||'
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '&' && *m_pAsmCmd == '&')
		{
			m_idata = '&&';
			m_nPrio = 9;            // '&&'
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '=' && *m_pAsmCmd == '=')
		{
			m_idata = '==';
			m_nPrio = 5;            // '=='
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '!' && *m_pAsmCmd == '=')
		{
			m_idata = '!=';
			m_nPrio = 5;            // '!='
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '<' && *m_pAsmCmd == '=')
		{
			m_idata = '<=';
			m_nPrio = 4;            // '<='
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '>' && *m_pAsmCmd == '=')
		{
			m_idata = '>=';
			m_nPrio = 4;            // '>='
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '<' && *m_pAsmCmd == '<')
		{
			m_idata = '<<';
			m_nPrio = 3;            // '<<'
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '>' && *m_pAsmCmd == '>')
		{
			m_idata = '>>';
			m_nPrio = 3;            // '>>'
			m_sdata[1] = *m_pAsmCmd++;
		}
		else if (m_idata == '|')
		{
			m_nPrio = 8;    // '|'
		}
		else if (m_idata == '^')
		{
			m_nPrio = 7;    // '^'
		}
		else if (m_idata == '&')
		{
			m_nPrio = 6;    // '&'
		}
		else if (m_idata == '<')
		{
			if (*m_pAsmCmd == '&')
			{
				// Import pseudolabel (for internal use)
				if ((mode & SA_IMPORT) == 0)
				{
					m_pAsmError = ("Syntax error");
					m_nScan = SCAN_ERR;
					return;
				}
				m_pAsmCmd++;
				i = 0;
				while (*m_pAsmCmd != '\0' && *m_pAsmCmd != '>')
				{
					m_sdata[i++] = *m_pAsmCmd++;
					if (i >= sizeof(m_sdata))
					{
						m_pAsmError = ("Too long import name");
						m_nScan = SCAN_ERR;
						return;
					}
				}
				if (*m_pAsmCmd != '>')
				{
					m_pAsmError = ("Unterminated import name");
					m_nScan = SCAN_ERR;
					return;
				}
				m_pAsmCmd++;
				m_sdata[i] = '\0';
				m_nScan = SCAN_IMPORT;
				return;
			}
			else
			{
				m_nPrio = 4;    // '<'
			}
		}
		else if (m_idata == '>')
		{
			m_nPrio = 4;     // '>'
		}
		else if (m_idata == '+')
		{
			m_nPrio = 2;     // '+'
		}
		else if (m_idata == '-')
		{
			m_nPrio = 2;     // '-'
		}
		else if (m_idata == '*')
		{
			m_nPrio = 1;     // '*'
		}
		else if (m_idata == '/')
		{
			m_nPrio = 1;     // '/'
		}
		else if (m_idata == '%')
		{
			m_nPrio = 1;     // '%'
		}
		else if (m_idata == ']')
		{
			pcmd = m_pAsmCmd;
			Scanasm(SA_NAME);
			if (m_nScan != SCAN_SYMB || m_idata != '[')
			{
				m_idata = ']';
				m_pAsmCmd = pcmd;
				m_nPrio = 0;
			}
			else
			{
				m_idata = '+';    // Translate '][' to '+'
				m_nPrio = 2;
			}
		}
		else
		{
			m_nPrio = 0;     // Any other character
		}
		m_nScan = SCAN_SYMB;
		return;
	}
}

// Fetches one complete operand from the input line and fills in structure op  with operand's data
// Expects that first token of the operand is already
// scanned. Supports operands in generalized form (for example, R32 means any
// of general-purpose 32-bit integer registers).
void		CMgAsmBase::Parseasmoperand(t_asmoperand* op)
{
	int i, j, bracket, sign, xlataddr;
	int reg, r[9];
	long offset;
	if (m_nScan == SCAN_EOL || m_nScan == SCAN_ERR)
	{
		return;    // No or bad operand
	}

	// Jump or call address may begin with address size modifier(s) SHORT, LONG,
	// NEAR and/or FAR. Not all combinations are allowed. After operand is
	// completely parsed, this function roughly checks whether modifier is
	// allowed. Exact check is done in Assemble().
	if (m_nScan == SCAN_JMPSIZE)
	{
		j = 0;
		while (m_nScan == SCAN_JMPSIZE)
		{
			j |= m_idata;                      // Fetch all size modifiers
			Scanasm(0);
		}
		if (
			((j & 0x03) == 0x03) ||          // Mixed SHORT and LONG
			((j & 0x0C) == 0x0C) ||          // Mixed NEAR and FAR
			((j & 0x09) == 0x09)             // Mixed FAR and SHORT
			)
		{
			m_pAsmError = ("Invalid combination of jump address modifiers");
			m_nScan = SCAN_ERR;
			return;
		}
		if ((j & 0x08) == 0)
		{
			j |= 0x04;    // Force NEAR if not FAR
		}
		op->jmpmode = j;
	}


	// Simple operands are either register or constant, their processing is

	//简单的操作数为寄存器或常数，它们的处理

	// obvious and straightforward.
	if (m_nScan == SCAN_REG8 || m_nScan == SCAN_REG16 || m_nScan == SCAN_REG32)
	{
		op->type = REG;
		op->index = m_idata;   // Integer general-purpose register  整数通用寄存器
		if (m_nScan == SCAN_REG8)
		{
			op->size = 1;
		}
		else if (m_nScan == SCAN_REG16)
		{
			op->size = 2;
		}
		else
		{
			op->size = 4;
		}
	}
	else if (m_nScan == SCAN_FPU)            // FPU register
	{
		op->type = RST;
		op->index = m_idata;
	}
	else if (m_nScan == SCAN_MMX)            // MMX or 3DNow! register
	{
		op->type = RMX;
		op->index = m_idata;
	}
	else if (m_nScan == SCAN_CR)             // Control register
	{
		op->type = CRX;
		op->index = m_idata;
	}
	else if (m_nScan == SCAN_DR)             // Debug register
	{
		op->type = DRX;
		op->index = m_idata;
	}
	else if (m_nScan == SCAN_SYMB && m_idata == '-')
	{
		Scanasm(0);                        // Negative constant
		if (m_nScan != SCAN_ICONST && m_nScan != SCAN_DCONST && m_nScan != SCAN_OFS)
		{
			m_pAsmError = ("Integer number expected");
			m_nScan = SCAN_ERR;
			return;
		}
		op->type = IMM;
		op->offset = -m_idata;
		if (m_nScan == SCAN_OFS)
		{
			op->anyoffset = 1;
		}

	}
	else if (m_nScan == SCAN_SYMB && m_idata == '+')
	{
		Scanasm(0);                        // Positive constant
		if (m_nScan != SCAN_ICONST && m_nScan != SCAN_DCONST && m_nScan != SCAN_OFS)
		{
			m_pAsmError = ("Integer number expected");
			m_nScan = SCAN_ERR;
			return;
		}
		op->type = IMM;
		op->offset = m_idata;
		if (m_nScan == SCAN_OFS)
		{
			op->anyoffset = 1;
		}

	}
	else if (m_nScan == SCAN_ICONST || m_nScan == SCAN_DCONST || m_nScan == SCAN_OFS)
	{
		j = m_idata;
		if (m_nScan == SCAN_OFS)
		{
			op->anyoffset = 1;
		}
		Scanasm(0);
		if (m_nScan == SCAN_SYMB && m_idata == ':')
		{
			Scanasm(0);                      // Absolute long address (seg:offset)
			if (m_nScan != SCAN_ICONST && m_nScan != SCAN_DCONST && m_nScan != SCAN_OFS)
			{
				m_pAsmError = ("Integer address expected");
				m_nScan = SCAN_ERR;
				return;
			}
			op->type = JMF;
			op->offset = m_idata;
			op->segment = j;
			if (m_nScan == SCAN_OFS) op->anyoffset = 1;
		}
		else
		{
			op->type = IMM;
			op->offset = j;    // Constant without sign
			return;                          // Next token already scanned
		}
	}
	else if (m_nScan == SCAN_FCONST)
	{
		m_pAsmError = ("Floating-point numbers are not allowed in command");
		m_nScan = SCAN_ERR;
		return;
	}
	else if (m_nScan == SCAN_SEG || m_nScan == SCAN_OPSIZE || (m_nScan == SCAN_SYMB && m_idata == '[')) // Segment register or address
	{
		bracket = 0;
		if (m_nScan == SCAN_SEG)
		{
			j = m_idata;
			Scanasm(0);
			if (m_nScan != SCAN_SYMB || m_idata != ':')
			{
				op->type = SGM;
				op->index = j;   // Segment register as operand
				return;                     // Next token already scanned
			}
			op->segment = j;
			Scanasm(0);
		}

		// Scan 32-bit address. This parser does not support 16-bit addresses.
		// First of all, get size of operand (optional), segment register (optional)
		// and opening bracket (required).
		while (1)
		{
			if (m_nScan == SCAN_SYMB && m_idata == '[')
			{
				if (bracket)
				{
					// Bracket
					m_pAsmError = ("Only one opening bracket allowed");
					m_nScan = SCAN_ERR;
					return;
				}
				bracket = 1;
			}
			else if (m_nScan == SCAN_OPSIZE)
			{
				if (op->size != 0)
				{
					// Size of operand
					m_pAsmError = ("Duplicated size modifier");
					m_nScan = SCAN_ERR;
					return;
				}
				op->size = m_idata;
			}
			else if (m_nScan == SCAN_SEG)
			{
				if (op->segment != SEG_UNDEF)
				{
					// Segment register
					m_pAsmError = ("Duplicated segment register");
					m_nScan = SCAN_ERR;
					return;
				}

				op->segment = m_idata;
				Scanasm(0);
				if (m_nScan != SCAN_SYMB || m_idata != ':')
				{
					m_pAsmError = ("Semicolon expected");
					m_nScan = SCAN_ERR;
					return;
				}
			}
			else if (m_nScan == SCAN_ERR)
			{
				return;
			}
			else
			{
				break;     // None of expected address elements
			}
			Scanasm(0);
		}
		if (bracket == 0)
		{
			m_pAsmError = ("Address expression requires brackets");
			m_nScan = SCAN_ERR;
			return;
		}


		// Assembling a 32-bit address may be a kind of nigthmare, due to a large
		// number of allowed forms. Parser collects immediate offset in op->offset
		// and count for each register in array r[]. Then it decides whether this
		// combination is valid and determines scale, index and base. Assemble()
		// will use these numbers to select address form (with or without SIB byte,
		// 8- or 32-bit offset, use segment prefix or not). As a useful side effect
		// of this technique, one may specify, for example, [EAX*5] which will
		// correctly assemble to [EAX*4+EAX].
		for (i = 0; i <= 8; i++)
		{
			r[i] = 0;
		}
		sign = '+';                        // Default sign for the first operand
		xlataddr = 0;

		while (1)
		{
			// Get SIB and offset
			if (m_nScan == SCAN_SYMB && (m_idata == '+' || m_idata == '-'))
			{
				sign = m_idata;
				Scanasm(0);
			}
			if (m_nScan == SCAN_ERR)
			{
				return;
			}
			if (sign == '?')
			{
				m_pAsmError = ("Syntax error");
				m_nScan = SCAN_ERR;
				return;
			}

			// Register AL appears as part of operand of (seldom used) command XLAT.
			if (m_nScan == SCAN_REG8 && m_idata == REG_EAX)
			{
				if (sign == '-')
				{
					m_pAsmError = ("Unable to subtract register");
					m_nScan = SCAN_ERR;
					return;
				}
				if (xlataddr != 0)
				{
					m_pAsmError = ("Too many registers");
					m_nScan = SCAN_ERR;
					return;
				}
				xlataddr = 1;
				Scanasm(0);
			}
			else if (m_nScan == SCAN_REG16)
			{
				m_pAsmError = ("Sorry, 16-bit addressing is not supported");
				m_nScan = SCAN_ERR;
				return;
			}
			else if (m_nScan == SCAN_REG32)
			{
				if (sign == '-')
				{
					m_pAsmError = ("Unable to subtract register");
					m_nScan = SCAN_ERR;
					return;
				}
				reg = m_idata;
				Scanasm(0);
				if (m_nScan == SCAN_SYMB && m_idata == '*')
				{
					Scanasm(0);                  // Try index*scale
					if (m_nScan == SCAN_ERR)
					{
						return;
					}
					if (m_nScan == SCAN_OFS)
					{
						m_pAsmError = ("Undefined scale is not allowed");
						m_nScan = SCAN_ERR;
						return;
					}
					if (m_nScan != SCAN_ICONST && m_nScan != SCAN_DCONST)
					{
						m_pAsmError = ("Syntax error");
						m_nScan = SCAN_ERR;
						return;
					}
					if (m_idata == 6 || m_idata == 7 || m_idata > 9)
					{
						m_pAsmError = ("Invalid scale");
						m_nScan = SCAN_ERR;
						return;
					}
					r[reg] += m_idata;
					Scanasm(0);
				}
				else
				{
					r[reg]++;    // Simple register
				}
			}
			else if (m_nScan == SCAN_LOCAL)
			{
				r[REG_EBP]++;
				op->offset -= m_idata * 4;
				Scanasm(0);
			}
			else if (m_nScan == SCAN_ARG)
			{
				r[REG_EBP]++;
				op->offset += (m_idata + 1) * 4;
				Scanasm(0);
			}
			else if (m_nScan == SCAN_ICONST || m_nScan == SCAN_DCONST)
			{
				offset = m_idata;
				Scanasm(0);
				if (m_nScan == SCAN_SYMB && m_idata == '*')
				{
					Scanasm(0);                  // Try scale*index
					if (m_nScan == SCAN_ERR)
					{
						return;
					}
					if (sign == '-')
					{
						m_pAsmError = ("Unable to subtract register");
						m_nScan = SCAN_ERR;
						return;
					}
					if (m_nScan == SCAN_REG16)
					{
						m_pAsmError = ("Sorry, 16-bit addressing is not supported");
						m_nScan = SCAN_ERR;
						return;
					}
					if (m_nScan != SCAN_REG32)
					{
						m_pAsmError = ("Syntax error");
						m_nScan = SCAN_ERR;
						return;
					}
					if (offset == 6 || offset == 7 || offset > 9)
					{
						m_pAsmError = ("Invalid scale");
						m_nScan = SCAN_ERR;
						return;
					}
					r[m_idata] += offset;
					Scanasm(0);
				}
				else
				{
					if (sign == '-')
					{
						op->offset -= offset;
					}
					else
					{
						op->offset += offset;
					}
				}
			}
			else if (m_nScan == SCAN_OFS)
			{
				Scanasm(0);
				if (m_nScan == SCAN_SYMB && m_idata == '*')
				{
					m_pAsmError = ("Undefined scale is not allowed");
					m_nScan = SCAN_ERR;
					return;
				}
				else
				{
					op->anyoffset = 1;
				}
			}
			else
			{
				break;    // None of expected address elements
			}
			if (m_nScan == SCAN_SYMB && m_idata == ']')
			{
				break;
			}
			sign = '?';
		}
		if (m_nScan == SCAN_ERR)
		{
			return;
		}
		if (m_nScan != SCAN_SYMB || m_idata != ']')
		{
			m_pAsmError = ("Syntax error");
			m_nScan = SCAN_ERR;
			return;
		}

		// Process XLAT address separately.
		if (xlataddr != 0)
		{
			// XLAT address in form [EBX+AX]
			for (i = 0; i <= 8; i++)
			{
				// Check which registers used
				if (i == REG_EBX)
				{
					continue;
				}
				if (r[i] != 0) break;
			}
			if (i <= 8 || r[REG_EBX] != 1 || op->offset != 0 || op->anyoffset != 0)
			{
				m_pAsmError = ("Invalid address");
				m_nScan = SCAN_ERR;
				return;
			}
			op->type = MXL;

		}
		else  	// Determine scale, index and base.
		{
			j = 0;                           // Number of used registers
			for (i = 0; i <= 8; i++)
			{
				if (r[i] == 0)
				{
					continue;    // Unused register
				}
				if (r[i] == 3 || r[i] == 5 || r[i] == 9)
				{
					if (op->index >= 0 || op->base >= 0)
					{
						if (j == 0)
						{
							m_pAsmError = ("Invalid scale");
						}
						else
						{
							m_pAsmError = ("Too many registers");
						}
						m_nScan = SCAN_ERR;
						return;
					}
					op->index = op->base = i;
					op->scale = r[i] - 1;
				}
				else if (r[i] == 2 || r[i] == 4 || r[i] == 8)
				{
					if (op->index >= 0)
					{
						if (j <= 1)
						{
							m_pAsmError = ("Only one register may be scaled");
						}
						else
						{
							m_pAsmError = ("Too many registers");
						}
						m_nScan = SCAN_ERR;
						return;
					}
					op->index = i;
					op->scale = r[i];
				}
				else if (r[i] == 1)
				{
					if (op->base < 0)
					{
						op->base = i;
					}
					else if (op->index < 0)
					{
						op->index = i;
						op->scale = 1;
					}
					else
					{
						m_pAsmError = ("Too many registers");
						m_nScan = SCAN_ERR;
						return;
					}

				}
				else
				{
					m_pAsmError = ("Invalid scale");
					m_nScan = SCAN_ERR;
					return;
				}
				j++;
			}
			op->type = MRG;
		}
	}
	else
	{
		m_pAsmError = ("Unrecognized operand");
		m_nScan = SCAN_ERR;
		return;
	}

	// In general, address modifier is allowed only with address expression which
	// is a constant, a far address or a memory expression. More precise check
	// will be done later in Assemble().
	if (op->jmpmode != 0 && op->type != IMM && op->type != JMF && op->type != MRG)
	{
		m_pAsmError = ("Jump address modifier is not allowed");
		m_nScan = SCAN_ERR;
		return;
	}
	Scanasm(0);                          // Fetch next token from input line
}


//--------------------------------------------------------------------------------
// Function assembles text into 32-bit 80x86 machine code. It supports imprecise
// operands (for example, R32 stays for any general-purpose 32-bit register).
// This allows to search for incomplete commands. Command is precise when all
// significant bytes in model.mask are 0xFF. Some commands have more than one
// decoding. By calling Assemble() with attempt=0,1... and constsize=0,1,2,3 one
// gets also alternative variants (bit 0x1 of constsize is responsible for size
// of address constant and bit 0x2 - for immediate data). However, only one
// address form is generated ([EAX*2], but not [EAX+EAX]; [EBX+EAX] but not
// [EAX+EBX]; [EAX] will not use SIB byte; no DS: prefix and so on). Returns
// number of bytes in assembled code or non-positive number in case of detected
// error. This number is the negation of the offset in the input text where the
// error encountered. Unfortunately, BC 4.52 is unable to compile the switch
// (arg) in this code when any common subexpression optimization is on. The
// next #pragma statement disables all optimizations.
//--------------------------------------------------------------------------------
int			CMgAsmBase::Assemble(char* cmd, ulong ip, t_asmmodel* model, int attempt, int constsize, char* errtext)
{
	int i, j, k, namelen, nameok, arg, match, datasize, addrsize, bytesize, minop, maxop;
	int rep, lock, segment, jmpsize, jmpmode, longjump;
	int hasrm, hassib, dispsize, immsize;
	int anydisp, anyimm, anyjmp;
	long l, displacement, immediate, jmpoffset;
	char name[32], * nameend;
	unsigned char tcode[MAXCMDSIZE], tmask[MAXCMDSIZE];
	t_asmoperand aop[3], * op;            // 最多允许3个操作数 Allows up to three operands
	t_cmddata* pd;


	if (model != NULL)
	{
		model->length = 0;
	}
	if (cmd == NULL || model == NULL || errtext == NULL)
	{
		if (errtext != NULL) strcpy(errtext, ("Internal OLLYDBG error"));
		return 0;
	}                       // 错误的参数 Wrong parameter

//
	m_pAsmCmd = cmd;
	rep = lock = 0;
	errtext[0] = '\0';

	//
	Scanasm(SA_NAME);

	if (m_nScan == SCAN_EOL)                // 行结束, nothing to assemble
	{
		return 0;
	}
	while (1)
	{
		// Fetch all REPxx and LOCK prefixes  取所有REPxx和LOCK前缀
		if (m_nScan == SCAN_REP || m_nScan == SCAN_REPE || m_nScan == SCAN_REPNE)
		{
			if (rep != 0)
			{
				strcpy(errtext, ("Duplicated REP prefix(重复REP前缀)"));
				goto error;
			}
			rep = m_nScan;
		}
		else if (m_nScan == SCAN_LOCK)
		{
			if (lock != 0)
			{
				strcpy(errtext, ("Duplicated LOCK prefix(重复LOCK前缀)"));
				goto error;
			};
			lock = m_nScan;
		}
		else
		{
			break;    // No more prefixes 没有更多的前缀
		}
		Scanasm(SA_NAME);
	}

	if (m_nScan != SCAN_NAME || m_idata > 16)
	{
		strcpy(errtext, ("Command mnemonic expected(预期指令助记符)"));
		goto error;
	}

	//
	nameend = m_pAsmCmd;
	strupr(m_sdata);

	// Prepare full mnemonic (including repeat prefix, if any). 获取操作符
	if (rep == SCAN_REP)
	{
		sprintf(name, ("REP %s"), m_sdata);
	}
	else if (rep == SCAN_REPE)
	{
		sprintf(name, ("REPE %s"), m_sdata);
	}
	else if (rep == SCAN_REPNE)
	{
		sprintf(name, ("REPNE %s"), m_sdata);
	}
	else
	{
		strcpy(name, m_sdata);
	}
	Scanasm(0);

	// Parse command operands (up to 3). Note: jump address is always the first
	// (and only) operand in actual command set.

	//分析指令的操作数（最多3个） 。注：跳转地址永远是第一位

	for (i = 0; i < 3; i++)
	{
		aop[i].type = NNN;                 // No operand 无操作数
		aop[i].size = 0;                   // Undefined size 未定义的大小
		aop[i].index = -1;                 // No index 没有索引
		aop[i].scale = 0;                  // No scale 没有形成规模
		aop[i].base = -1;                  // No base 无基址
		aop[i].offset = 0;                 // No offset 无偏移
		aop[i].anyoffset = 0;              // No offset  无偏移
		aop[i].segment = SEG_UNDEF;        // No segment 在段
		aop[i].jmpmode = 0;              // No jump size modifier
	}

	//
	Parseasmoperand(aop + 0);
	jmpmode = aop[0].jmpmode;
	if (jmpmode != 0)
	{
		jmpmode |= 0x80;
	}

	if (m_nScan == SCAN_SYMB && m_idata == ',')
	{
		Scanasm(0);
		Parseasmoperand(aop + 1);
		if (m_nScan == SCAN_SYMB && m_idata == ',')
		{
			Scanasm(0);
			Parseasmoperand(aop + 2);
		}
	}

	if (m_nScan == SCAN_ERR)
	{
		strcpy(errtext, m_pAsmError);
		goto error;
	};
	if (m_nScan != SCAN_EOL)
	{
		strcpy(errtext, ("Extra input after operand"));
		goto error;
	};

	// If jump size is not specified, function tries to use short jump. If
	// attempt fails, it retries with long form.
	longjump = 0;                        // Try short jump on the first pass 在第一轮尝试短跳

	//label:-------------------------------
retrylongjump:


	nameok = 0;
	// Some commands allow different number of operands. Variables minop and
	// maxop accumulate their minimal and maximal counts. The numbers are not
	// used in assembly process but allow for better error diagnostics.

	minop = 3;
	maxop = 0;

	// Main assembly loop: try to find the command which matches all operands,
	// but do not process operands yet.
	namelen = strlen(name);

	for (pd = g_CmdData; pd->mask != 0; pd++)
	{
		//匹配操作符
		if (pd->name[0] == '&')
		{
			// Mnemonic depends on operand size
			j = 1;
			datasize = 2;
			addrsize = 4;
			while (1)
			{
				// Try all mnemonics (separated by ':')
				for (i = 0; pd->name[j] != '\0' && pd->name[j] != ':'; j++)
				{
					if (pd->name[j] == '*')
					{
						if (name[i] == 'W')
						{
							datasize = 2;
							i++;
						}
						else if (name[i] == 'D')
						{
							datasize = 4;
							i++;
						}
						else if (m_nSizeSens == 0)
						{
							datasize = 2;
						}
						else
						{
							datasize = 4;
						}
					}
					else if (pd->name[j] == name[i])
					{
						i++;
					}
					else
					{
						break;
					}
				}

				if (name[i] == '\0' && (pd->name[j] == '\0' || pd->name[j] == ':'))
				{
					break;     // Bingo!
				}
				while (pd->name[j] != '\0' && pd->name[j] != ':')
				{
					j++;
				}
				if (pd->name[j] == ':')
				{
					j++;    // Retry with 32-bit mnenonic
					datasize = 4;
				}
				else
				{
					i = 0;    // Comparison failed
					break;
				}
			}
			if (i == 0)
			{
				continue;
			}
		}
		else if (pd->name[0] == '$')        // Mnemonic depends on address size
		{
			j = 1;
			datasize = 0;
			addrsize = 2;
			while (1)
			{
				// Try all mnemonics (separated by ':')
				for (i = 0; pd->name[j] != '\0' && pd->name[j] != ':'; j++)
				{
					if (pd->name[j] == '*')
					{
						if (name[i] == 'W')
						{
							addrsize = 2;
							i++;
						}
						else if (name[i] == 'D')
						{
							addrsize = 4;
							i++;
						}
						else if (m_nSizeSens == 0)
						{
							addrsize = 2;
						}
						else
						{
							addrsize = 4;
						}
					}
					else if (pd->name[j] == name[i])
					{
						i++;
					}
					else
					{
						break;
					}
				}

				if (name[i] == '\0' && (pd->name[j] == '\0' || pd->name[j] == ':'))
				{
					break;    // Bingo!
				}
				while (pd->name[j] != '\0' && pd->name[j] != ':')
				{
					j++;
				}
				if (pd->name[j] == ':')
				{
					j++;    // Retry with 32-bit mnenonic
					addrsize = 4;
				}
				else
				{
					i = 0;    // Comparison failed
					break;
				}
			}
			if (i == 0)
			{
				continue;
			}
		}
		else                                // Compare with all synonimes
		{
			j = k = 0;
			datasize = 0;                    // Default settings
			addrsize = 4;
			while (1)
			{
				while (pd->name[j] != ',' && pd->name[j] != '\0')
				{
					j++;
				}
				if (j - k == namelen && strnicmp(name, pd->name + k, namelen) == 0)//匹配操作符
				{
					break;
				}
				k = j + 1;
				if (pd->name[j] == '\0')
				{
					break;
				}
				j = k;
			}
			if (k > j)
			{
				continue;
			}
		}

		// For error diagnostics it is important to know whether mnemonic exists.
		nameok++;
		if (pd->arg1 == NNN || pd->arg1 >= PSEUDOOP)
		{
			minop = 0;
		}
		else if (pd->arg2 == NNN || pd->arg2 >= PSEUDOOP)
		{
			if (minop > 1)
			{
				minop = 1;
			}
			if (maxop < 1)
			{
				maxop = 1;
			}
		}
		else if (pd->arg3 == NNN || pd->arg3 >= PSEUDOOP)
		{
			if (minop > 2)
			{
				minop = 2;
			}
			if (maxop < 2)
			{
				maxop = 2;
			}
		}
		else
		{
			maxop = 3;
		}

		// Determine default and allowed operand size(s).
		if (pd->bits == FF)
		{
			datasize = 2;    // Forced 16-bit size
		}
		if (pd->bits == WW || pd->bits == WS || pd->bits == W3 || pd->bits == WP)
		{
			bytesize = 1;     // 1-byte size allowed
		}
		else
		{
			bytesize = 0;    // Word/dword size only
		}

		// Check whether command operands match specified. If so, variable match
		// remains zero, otherwise it contains kind of mismatch. This allows for
		// better error diagnostics.
		match = 0;
		for (j = 0; j < 3; j++)
		{
			// Up to 3 operands
			op = aop + j;
			if (j == 0)
			{
				arg = pd->arg1;
			}
			else if (j == 1)
			{
				arg = pd->arg2;
			}
			else
			{
				arg = pd->arg3;
			}
			if (arg == NNN || arg >= PSEUDOOP)
			{
				if (op->type != NNN)           // No more arguments
				{
					match |= MA_NOP;
				}
				break;
			}
			if (op->type == NNN)
			{
				match |= MA_NOP;    // No corresponding operand
				break;
			}

			//
			switch (arg)
			{
			case REG:                      // Integer register in Reg field
			case RCM:                      // Integer register in command byte
			case RAC:                      // Accumulator (AL/AX/EAX, implicit)
			{
				if (op->type != REG)
				{
					match |= MA_TYP;
				}
				if (arg == RAC && op->index != REG_EAX && op->index != 8)
				{
					match |= MA_TYP;
				}
				if (bytesize == 0 && op->size == 1)
				{
					match |= MA_SIZ;
				}
				if (datasize == 0)
				{
					datasize = op->size;
				}
				if (datasize != op->size)
				{
					match |= MA_DIF;
				}
				break;
			}
			case RG4:                      // Integer 4-byte register in Reg field
			{
				if (op->type != REG)
				{
					match |= MA_TYP;
				}
				if (op->size != 4)
				{
					match |= MA_SIZ;
				}
				if (datasize == 0)
				{
					datasize = op->size;
				}
				if (datasize != op->size)
				{
					match |= MA_DIF;
				}
				break;
			}
			case RAX:                      // AX (2-byte, implicit)
			{
				if (op->type != REG || (op->index != REG_EAX && op->index != 8))
				{
					match |= MA_TYP;
				}
				if (op->size != 2)
				{
					match |= MA_SIZ;
				}
				if (datasize == 0)
				{
					datasize = op->size;
				}
				if (datasize != op->size)
				{
					match |= MA_DIF;
				}
				break;
			}
			case RDX:                      // DX (16-bit implicit port address)
			{
				if (op->type != REG || (op->index != REG_EDX && op->index != 8))
				{
					match |= MA_TYP;
				}
				if (op->size != 2)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case RCL:                      // Implicit CL register (for shifts)
			{
				if (op->type != REG || (op->index != REG_ECX && op->index != 8))
				{
					match |= MA_TYP;
				}
				if (op->size != 1)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case RS0:                      // Top of FPU stack (ST(0))
			{
				if (op->type != RST || (op->index != 0 && op->index != 8))
				{
					match |= MA_TYP;
				}
				break;
			}
			case RST:                      // FPU register (ST(i)) in command byte
			{
				if (op->type != RST)
				{
					match |= MA_TYP;
				}
				break;
			}
			case RMX:                      // MMX register MMx
			case R3D:                      // 3DNow! register MMx
			{
				if (op->type != RMX)
				{
					match |= MA_TYP;
				}
				break;
			}
			case MRG:                      // Memory/register in ModRM byte
			{
				if (op->type != MRG && op->type != REG)
				{
					match |= MA_TYP;
				}
				if (bytesize == 0 && op->size == 1)
				{
					match |= MA_SIZ;
				}
				if (datasize == 0)
				{
					datasize = op->size;
				}
				if (op->size != 0 && op->size != datasize)
				{
					match |= MA_DIF;
				}
				break;
			}
			case MR1:                      // 1-byte memory/register in ModRM byte
			{
				if (op->type != MRG && op->type != REG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 1)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MR2:                      // 2-byte memory/register in ModRM byte
			{
				if (op->type != MRG && op->type != REG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 2)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MR4:                      // 4-byte memory/register in ModRM byte
			{
				if (op->type != MRG && op->type != REG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 4)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case RR4:                      // 4-byte memory/register (register only)
			{
				if (op->type != REG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 4)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MRJ:                      // Memory/reg in ModRM as JUMP target
			{
				if (op->type != MRG && op->type != REG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 4)
				{
					match |= MA_SIZ;
				}
				if ((jmpmode & 0x09) != 0)
				{
					match |= MA_JMP;
				}
				jmpmode &= 0x7F;
				break;
			}
			case MR8:                      // 8-byte memory/MMX register in ModRM
			case MRD:                      // 8-byte memory/3DNow! register in ModRM
			{
				if (op->type != MRG && op->type != RMX)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 8)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case RR8:                      // 8-byte MMX register only in ModRM
			case RRD:                      // 8-byte memory/3DNow! (register only)
			{
				if (op->type != RMX)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 8)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MMA:                      // Memory address in ModRM byte for LEA
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				break;
			}
			case MML:                      // Memory in ModRM byte (for LES)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 6)
				{
					match |= MA_SIZ;
				}
				if (datasize == 0)
				{
					datasize = 4;
				}
				else if (datasize != 4)
				{
					match |= MA_DIF;
				}
				break;
			}
			case MMS:                      // Memory in ModRM byte (as SEG:OFFS)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 6)
				{
					match |= MA_SIZ;
				}
				if ((jmpmode & 0x07) != 0)
				{
					match |= MA_JMP;
				}
				jmpmode &= 0x7F;
				break;
			}
			case MM6:                      // Memory in ModRm (6-byte descriptor)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 6)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MMB:                      // Two adjacent memory locations (BOUND)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				k = op->size;
				if (m_nIDEAL == 0 && k > 1)
				{
					k /= 2;
				}
				if (k != 0 && k != datasize)
				{
					match |= MA_DIF;
				}
				break;
			}
			case MD2:                      // Memory in ModRM byte (16-bit integer)
			case MB2:                      // Memory in ModRM byte (16-bit binary)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 2)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MD4:                      // Memory in ModRM byte (32-bit integer)
			case MF4:                      // Memory in ModRM byte (32-bit float)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 4)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MD8:                      // Memory in ModRM byte (64-bit integer)
			case MF8:                      // Memory in ModRM byte (64-bit float)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 8)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MDA:                      // Memory in ModRM byte (80-bit BCD)
			case MFA:                      // Memory in ModRM byte (80-bit float)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0 && op->size != 10)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MFE:                      // Memory in ModRM byte (FPU environment)
			case MFS:                      // Memory in ModRM byte (FPU state)
			case MFX:                      // Memory in ModRM byte (ext. FPU state)
			{
				if (op->type != MRG)
				{
					match |= MA_TYP;
				}
				if (op->size != 0)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case MSO:                      // Source in string operands ([ESI])
			{
				if (op->type != MRG || op->base != REG_ESI || op->index != -1 ||
					op->offset != 0 || op->anyoffset != 0)
				{
					match |= MA_TYP;
				}
				if (datasize == 0)
				{
					datasize = op->size;
				}
				if (op->size != 0 && op->size != datasize)
				{
					match |= MA_DIF;
				}
				break;
			}
			case MDE:                      // Destination in string operands ([EDI])
			{
				if (op->type != MRG || op->base != REG_EDI ||
					op->index != -1 || op->offset != 0 || op->anyoffset != 0)
				{
					match |= MA_TYP;
				}
				if (op->segment != SEG_UNDEF && op->segment != SEG_ES)
				{
					match |= MA_SEG;
				}
				if (datasize == 0)
				{
					datasize = op->size;
				}
				if (op->size != 0 && op->size != datasize)
				{
					match |= MA_DIF;
				}
				break;
			}
			case MXL:                      // XLAT operand ([EBX+AL])
			{
				if (op->type != MXL)
				{
					match |= MA_TYP;
				}
				break;
			}
			case IMM:                      // Immediate data (8 or 16/32)
			case IMU:                      // Immediate unsigned data (8 or 16/32)
			{
				if (op->type != IMM)
				{
					match |= MA_TYP;
				}
				break;
			}
			case VXD:                      // VxD service (32-bit only)
			{
				if (op->type != IMM)
				{
					match |= MA_TYP;
				}
				if (datasize == 0)
				{
					datasize = 4;
				}
				if (datasize != 4)
				{
					match |= MA_SIZ;
				}
				break;
			}
			case JMF:                      // Immediate absolute far jump/call addr
			{
				if (op->type != JMF)
				{
					match |= MA_TYP;
				}
				if ((jmpmode & 0x05) != 0)
				{
					match |= MA_JMP;
				}
				jmpmode &= 0x7F;
				break;
			}
			case JOB:                      // Immediate byte offset (for jumps)
			{
				if (op->type != IMM || longjump)
				{
					match |= MA_TYP;
				}
				if ((jmpmode & 0x0A) != 0)
				{
					match |= MA_JMP;
				}
				jmpmode &= 0x7F;
				break;
			}
			case JOW:                      // Immediate full offset (for jumps)
			{
				if (op->type != IMM)
				{
					match |= MA_TYP;
				}
				if ((jmpmode & 0x09) != 0)
				{
					match |= MA_JMP;
				}
				jmpmode &= 0x7F;
				break;
			}
			case IMA:                      // Immediate absolute near data address
			{
				if (op->type != MRG || op->base >= 0 || op->index >= 0)
				{
					match |= MA_TYP;
				}
				break;
			}
			case IMX:                      // Immediate sign-extendable byte
			{
				if (op->type != IMM)
				{
					match |= MA_TYP;
				}
				if (op->offset < -128 || op->offset > 127)
				{
					match |= MA_RNG;
				}
				break;
			}
			case C01:                      // Implicit constant 1 (for shifts)
			{
				if (op->type != IMM || (op->offset != 1 && op->anyoffset == 0))
				{
					match |= MA_TYP;
				}
				break;
			}
			case IMS:                      // Immediate byte (for shifts)
			case IM1:                      // Immediate byte
			{
				if (op->type != IMM)
				{
					match |= MA_TYP;
				}
				if (op->offset < -128 || op->offset > 255)
				{
					match |= MA_RNG;
				}
				break;
			}
			case IM2:                      // Immediate word (ENTER/RET)
			{
				if (op->type != IMM)
				{
					match |= MA_TYP;
				}
				if (op->offset < 0 || op->offset > 65535)
				{
					match |= MA_RNG;
				}
				break;
			}
			case SGM:                      // Segment register in ModRM byte
			{
				if (op->type != SGM)
				{
					match |= MA_TYP;
				}
				if (datasize == 0)
				{
					datasize = 2;
				}
				if (datasize != 2)
				{
					match |= MA_DIF;
				}
				break;
			}
			case SCM:                      // Segment register in command byte
			{
				if (op->type != SGM)
				{
					match |= MA_TYP;
				}
				break;
			}
			case CRX:                      // Control register CRx
			case DRX:                      // Debug register DRx
			{
				if (op->type != arg)
				{
					match |= MA_TYP;
				}
				if (datasize == 0)
				{
					datasize = 4;
				}
				if (datasize != 4)
				{
					match |= MA_DIF;
				}
				break;
			}
			case PRN:                      // Near return address (pseudooperand)
			case PRF:                      // Far return address (pseudooperand)
			case PAC:                      // Accumulator (AL/AX/EAX, pseudooperand)
			case PAH:                      // AH (in LAHF/SAHF, pseudooperand)
			case PFL:                      // Lower byte of flags (pseudooperand)
			case PS0:                      // Top of FPU stack (pseudooperand)
			case PS1:                      // ST(1) (pseudooperand)
			case PCX:                      // CX/ECX (pseudooperand)
			case PDI:                      // EDI (pseudooperand in MMX extentions)
			{
				break;
			}
			default:                       // Undefined type of operand
			{
				strcpy(errtext, ("Internal Assembler error"));
				goto error;
			}
			}                               // End of switch (arg)

			if ((jmpmode & 0x80) != 0)
			{
				match |= MA_JMP;
			}
			if (match != 0)
			{
				break;     // Some of the operands doesn't match
			}
		}                                 // End of operand matching loop
		if (match == 0)
		{
			// Exact match found
			if (attempt > 0)
			{
				--attempt;    // Well, try to find yet another match
				nameok = 0;
			}
			else
			{
				break;
			}
		}
	}                                  // End of command search loop


// Check whether some error was detected. If several errors were found
// similtaneously, report one (roughly in order of significance).
	if (nameok == 0)
	{
		// Mnemonic unavailable
		strcpy(errtext, ("Unrecognized command"));
		m_pAsmCmd = nameend;
		goto error;
	}
	if (match != 0)
	{
		// Command not found
		if (minop > 0 && aop[minop - 1].type == NNN)
		{
			strcpy(errtext, ("Too few operands"));
		}
		else if (maxop < 3 && aop[maxop].type != NNN)
		{
			strcpy(errtext, ("Too many operands"));
		}
		else if (nameok > 1)               // More that 1 command
		{
			strcpy(errtext, ("Command does not support given operands"));
		}
		else if (match & MA_JMP)
		{
			strcpy(errtext, ("Invalid jump size modifier"));
		}
		else if (match & MA_NOP)
		{
			strcpy(errtext, ("Wrong number of operands"));
		}
		else if (match & MA_TYP)
		{
			strcpy(errtext, ("Command does not support given operands"));
		}
		else if (match & MA_NOS)
		{
			strcpy(errtext, ("Please specify operand size"));
		}
		else if (match & MA_SIZ)
		{
			strcpy(errtext, ("Bad operand size"));
		}
		else if (match & MA_DIF)
		{
			strcpy(errtext, ("Different size of operands"));
		}
		else if (match & MA_SEG)
		{
			strcpy(errtext, ("Invalid segment register"));
		}
		else if (match & MA_RNG)
		{
			strcpy(errtext, ("Constant out of expected range"));
		}
		else
		{
			strcpy(errtext, ("Erroneous command"));
		}

		//
		goto error;
	}


	// Exact match found. Now construct the code.
	hasrm = 0;                           // Whether command has ModR/M byte
	hassib = 0;                          // Whether command has SIB byte
	dispsize = 0;                        // Size of displacement (if any)
	immsize = 0;                         // Size of immediate data (if any)
	segment = SEG_UNDEF;                 // Necessary segment prefix
	jmpsize = 0;                         // No relative jumps

	//
	memset(tcode, 0, sizeof(tcode));
	*(ulong*)tcode = pd->code & pd->mask;
	memset(tmask, 0, sizeof(tmask));
	*(ulong*)tmask = pd->mask;

	//
	i = pd->len - 1;                     // Last byte of command itself
	if (rep)
	{
		i++;    // REPxx prefixes count as extra byte
	}

	// In some cases at least one operand must have explicit size declaration (as
	// in MOV [EAX],1). This preliminary check does not include all cases.
	if (pd->bits == WW || pd->bits == WS || pd->bits == WP)
	{
		if (datasize == 0)
		{
			strcpy(errtext, ("Please specify operand size"));
			goto error;
		}
		else if (datasize > 1)
		{
			tcode[i] |= 0x01;    // WORD or DWORD size of operands
			//message(tcode[i]);
		}
		tmask[i] |= 0x01;
	}
	else if (pd->bits == W3)
	{
		if (datasize == 0)
		{
			strcpy(errtext, ("Please specify operand size"));
			goto error;
		}
		else if (datasize > 1)
		{
			tcode[i] |= 0x08;    // WORD or DWORD size of operands
		}
		tmask[i] |= 0x08;
	}

	// Present suffix of 3DNow! command as immediate byte operand.
	if ((pd->type & C_TYPEMASK) == C_NOW)
	{
		immsize = 1;
		immediate = (pd->code >> 16) & 0xFF;
	}

	// Process operands again, this time constructing the code.
	anydisp = anyimm = anyjmp = 0;
	for (j = 0; j < 3; j++)
	{
		// Up to 3 operands
		op = aop + j;
		if (j == 0)
		{
			arg = pd->arg1;
		}
		else if (j == 1)
		{
			arg = pd->arg2;
		}
		else
		{
			arg = pd->arg3;
		}
		if (arg == NNN)
		{
			break;    // All operands processed
		}
		switch (arg)
		{
		case REG:                        // Integer register in Reg field
		case RG4:                        // Integer 4-byte register in Reg field
		case RMX:                        // MMX register MMx
		case R3D:                        // 3DNow! register MMx
		case CRX:                        // Control register CRx
		case DRX:                        // Debug register DRx
		{
			hasrm = 1;
			if (op->index < 8)
			{
				tcode[i + 1] |= (char)(op->index << 3);
				tmask[i + 1] |= 0x38;
			}
			break;
		}
		case RCM:                        // Integer register in command byte
		case RST:                        // FPU register (ST(i)) in command byte
		{
			if (op->index < 8)
			{
				tcode[i] |= (char)op->index;
				tmask[i] |= 0x07;
			}
			break;
		}
		case RAC:                        // Accumulator (AL/AX/EAX, implicit)
		case RAX:                        // AX (2-byte, implicit)
		case RDX:                        // DX (16-bit implicit port address)
		case RCL:                        // Implicit CL register (for shifts)
		case RS0:                        // Top of FPU stack (ST(0))
		case MDE:                        // Destination in string op's ([EDI])
		case C01:                        // Implicit constant 1 (for shifts)
		{
			break;                         // Simply skip implicit operands
		}
		case MSO:                        // Source in string op's ([ESI])
		case MXL:                        // XLAT operand ([EBX+AL])
		{
			if (op->segment != SEG_UNDEF && op->segment != SEG_DS)
			{
				segment = op->segment;
			}
			break;
		}
		case MRG:                        // Memory/register in ModRM byte
		case MRJ:                        // Memory/reg in ModRM as JUMP target
		case MR1:                        // 1-byte memory/register in ModRM byte
		case MR2:                        // 2-byte memory/register in ModRM byte
		case MR4:                        // 4-byte memory/register in ModRM byte
		case RR4:                        // 4-byte memory/register (register only)
		case MR8:                        // 8-byte memory/MMX register in ModRM
		case RR8:                        // 8-byte MMX register only in ModRM
		case MRD:                        // 8-byte memory/3DNow! register in ModRM
		case RRD:                        // 8-byte memory/3DNow! (register only)
		{
			hasrm = 1;
			if (op->type != MRG)
			{
				// Register in ModRM byte
				tcode[i + 1] |= 0xC0;
				tmask[i + 1] |= 0xC0;
				if (op->index < 8)
				{
					tcode[i + 1] |= (char)op->index;
					tmask[i + 1] |= 0x07;
				}
				break;
			}
		}                            // Note: NO BREAK, continue with address
		case MMA:                        // Memory address in ModRM byte for LEA
		case MML:                        // Memory in ModRM byte (for LES)
		case MMS:                        // Memory in ModRM byte (as SEG:OFFS)
		case MM6:                        // Memory in ModRm (6-byte descriptor)
		case MMB:                        // Two adjacent memory locations (BOUND)
		case MD2:                        // Memory in ModRM byte (16-bit integer)
		case MB2:                        // Memory in ModRM byte (16-bit binary)
		case MD4:                        // Memory in ModRM byte (32-bit integer)
		case MD8:                        // Memory in ModRM byte (64-bit integer)
		case MDA:                        // Memory in ModRM byte (80-bit BCD)
		case MF4:                        // Memory in ModRM byte (32-bit float)
		case MF8:                        // Memory in ModRM byte (64-bit float)
		case MFA:                        // Memory in ModRM byte (80-bit float)
		case MFE:                        // Memory in ModRM byte (FPU environment)
		case MFS:                        // Memory in ModRM byte (FPU state)
		case MFX:                        // Memory in ModRM byte (ext. FPU state)
		{
			hasrm = 1;
			displacement = op->offset;
			anydisp = op->anyoffset;
			if (op->base < 0 && op->index < 0)
			{
				dispsize = 4;                // Special case of immediate address
				if (op->segment != SEG_UNDEF && op->segment != SEG_DS)
				{
					segment = op->segment;
				}
				tcode[i + 1] |= 0x05;
				tmask[i + 1] |= 0xC7;

			}
			else if (op->index < 0 && op->base != REG_ESP)
			{
				tmask[i + 1] |= 0xC0;        // SIB byte unnecessary
				if (op->offset == 0 && op->anyoffset == 0 && op->base != REG_EBP)
				{
				}// [EBP] always requires offset
				else if ((constsize & 1) != 0 && ((op->offset >= -128 && op->offset < 128) || op->anyoffset != 0))
				{
					tcode[i + 1] |= 0x40;      // Disp8
					dispsize = 1;
				}
				else
				{
					tcode[i + 1] |= 0x80;      // Disp32
					dispsize = 4;
				}
				if (op->base < 8)
				{
					if (op->segment != SEG_UNDEF && op->segment != g_addr32[op->base].defseg)
					{
						segment = op->segment;
					}
					tcode[i + 1] |= (char)op->base;       // Note that case [ESP] has base<0.
					tmask[i + 1] |= 0x07;
				}
				else
				{
					segment = op->segment;
				}
			}
			else                            // SIB byte necessary
			{
				hassib = 1;
				if (op->base == REG_EBP &&   // EBP as base requires offset, optimize
					op->index >= 0 && op->scale == 1 && op->offset == 0 && op->anyoffset == 0)
				{
					op->base = op->index;
					op->index = REG_EBP;
				}
				if (op->index == REG_ESP &&  // ESP cannot be an index, reorder
					op->scale <= 1)
				{
					op->index = op->base;
					op->base = REG_ESP;
					op->scale = 1;
				}
				if (op->base < 0 &&          // No base means 4-byte offset, optimize
					op->index >= 0 && op->scale == 2 && op->offset >= -128 && op->offset < 128 && op->anyoffset == 0)
				{
					op->base = op->index;
					op->scale = 1;
				}

				if (op->index == REG_ESP)
				{
					// Reordering was unsuccessfull
					strcpy(errtext, ("Invalid indexing mode"));
					goto error;
				}

				if (op->base < 0)
				{
					tcode[i + 1] |= 0x04;
					dispsize = 4;
				}
				else if (op->offset == 0 && op->anyoffset == 0 && op->base != REG_EBP)
				{
					tcode[i + 1] |= 0x04;     // No displacement
				}
				else if ((constsize & 1) != 0 && ((op->offset >= -128 && op->offset < 128) || op->anyoffset != 0))
				{
					tcode[i + 1] |= 0x44;      // Disp8
					dispsize = 1;
				}
				else
				{
					tcode[i + 1] |= 0x84;      // Disp32
					dispsize = 4;
				}

				tmask[i + 1] |= 0xC7;        // ModRM completed, proceed with SIB
				if (op->scale == 2)
				{
					tcode[i + 2] |= 0x40;
				}
				else if (op->scale == 4)
				{
					tcode[i + 2] |= 0x80;
				}
				else if (op->scale == 8)
				{
					tcode[i + 2] |= 0xC0;
				}

				tmask[i + 2] |= 0xC0;
				if (op->index < 8)
				{
					if (op->index < 0)
					{
						op->index = 0x04;
					}
					tcode[i + 2] |= (char)(op->index << 3);
					tmask[i + 2] |= 0x38;
				}
				if (op->base < 8)
				{
					if (op->base < 0)
					{
						op->base = 0x05;
					}
					if (op->segment != SEG_UNDEF && op->segment != g_addr32[op->base].defseg)
					{
						segment = op->segment;
					}
					tcode[i + 2] |= (char)op->base;
					tmask[i + 2] |= 0x07;
				}
				else
				{
					segment = op->segment;
				}
			}
			break;
		}
		case IMM:                        // Immediate data (8 or 16/32)
		case IMU:                        // Immediate unsigned data (8 or 16/32)
		case VXD:                        // VxD service (32-bit only)
		{
			if (datasize == 0 && pd->arg2 == NNN && (pd->bits == SS || pd->bits == WS))
			{
				datasize = 4;
			}
			if (datasize == 0)
			{
				strcpy(errtext, ("Please specify operand size"));
				goto error;
			}
			immediate = op->offset;
			anyimm = op->anyoffset;
			if (pd->bits == SS || pd->bits == WS)
			{
				if (datasize > 1 && (constsize & 2) != 0 &&
					((immediate >= -128 && immediate < 128) || op->anyoffset != 0))
				{
					immsize = 1;
					tcode[i] |= 0x02;
				}
				else
				{
					immsize = datasize;
				}
				tmask[i] |= 0x02;
			}
			else
			{
				immsize = datasize;
			}
			break;
		}
		case IMX:                        // Immediate sign-extendable byte
		case IMS:                        // Immediate byte (for shifts)
		case IM1:                        // Immediate byte
		{
			if (immsize == 2)              // To accomodate ENTER instruction
			{
				immediate = (immediate & 0xFFFF) | (op->offset << 16);
			}
			else
			{
				immediate = op->offset;
			}
			anyimm |= op->anyoffset;
			immsize++;
			break;
		}
		case IM2:                        // Immediate word (ENTER/RET)
		{
			immediate = op->offset;
			anyimm = op->anyoffset;
			immsize = 2;
			break;
		}
		case IMA:                        // Immediate absolute near data address
		{
			if (op->segment != SEG_UNDEF && op->segment != SEG_DS)
			{
				segment = op->segment;
			}
			displacement = op->offset;
			anydisp = op->anyoffset;
			dispsize = 4;
			break;
		}
		case JOB:                        // Immediate byte offset (for jumps)
		{
			jmpoffset = op->offset;
			anyjmp = op->anyoffset;
			jmpsize = 1;
			break;
		}
		case JOW:                        // Immediate full offset (for jumps)
		{
			jmpoffset = op->offset;
			anyjmp = op->anyoffset;
			jmpsize = 4;
			break;
		}
		case JMF:                        // Immediate absolute far jump/call addr
		{
			displacement = op->offset;
			anydisp = op->anyoffset;
			dispsize = 4;
			immediate = op->segment;
			anyimm = op->anyoffset;
			immsize = 2;
			break;
		}
		case SGM:                        // Segment register in ModRM byte
		{
			hasrm = 1;
			if (op->index < 6)
			{
				tcode[i + 1] |= (char)(op->index << 3);
				tmask[i + 1] |= 0x38;
			}
			break;
		}
		case SCM:                        // Segment register in command byte
		{
			if (op->index == SEG_FS || op->index == SEG_GS)
			{
				tcode[0] = (char)(0x0F);
				tmask[0] = (char)(0xFF);
				i = 1;
				if (strcmp(name, ("PUSH")) == 0)
				{
					tcode[i] = (char)((op->index << 3) | 0x80);
				}
				else
				{
					tcode[i] = (char)((op->index << 3) | 0x81);
				}
				tmask[i] = (char)(0xFF);
			}
			else if (op->index < 6)
			{
				if (op->index == SEG_CS && strcmp(name, ("POP")) == 0)
				{
					strcpy(errtext, ("Unable to POP CS"));
					goto error;
				}
				tcode[i] = (char)((tcode[i] & 0xC7) | (op->index << 3));
			}
			else
			{
				tcode[i] &= 0xC7;
				tmask[i] &= 0xC7;
			}
			break;
		}
		case PRN:                        // Near return address (pseudooperand)
		case PRF:                        // Far return address (pseudooperand)
		case PAC:                        // Accumulator (AL/AX/EAX, pseudooperand)
		case PAH:                        // AH (in LAHF/SAHF, pseudooperand)
		case PFL:                        // Lower byte of flags (pseudooperand)
		case PS0:                        // Top of FPU stack (pseudooperand)
		case PS1:                        // ST(1) (pseudooperand)
		case PCX:                        // CX/ECX (pseudooperand)
		case PDI:                        // EDI (pseudooperand in MMX extentions)
		{
			break;                         // Simply skip preudooperands
		}
		default:                         // Undefined type of operand
		{
			strcpy(errtext, ("Internal Assembler error"));
			goto error;
		}
		}
	}

	// Gather parts of command together in the complete command.
	j = 0;
	if (lock != 0)
	{
		// Lock prefix specified
		model->code[j] = (char)0xF0;
		model->mask[j] = (char)0xFF;
		j++;
	}
	if (datasize == 2 && pd->bits != FF)
	{
		// Data size prefix necessary
		model->code[j] = (char)0x66;
		model->mask[j] = (char)0xFF;
		j++;
	}
	if (addrsize == 2)
	{
		// Address size prefix necessary
		model->code[j] = (char)0x67;
		model->mask[j] = (char)0xFF;
		j++;
	}
	if (segment != SEG_UNDEF)
	{
		// Segment prefix necessary
		if (segment == SEG_ES)
		{
			model->code[j] = 0x26;
		}
		else if (segment == SEG_CS)
		{
			model->code[j] = 0x2E;
		}
		else if (segment == SEG_SS)
		{
			model->code[j] = 0x36;
		}
		else if (segment == SEG_DS)
		{
			model->code[j] = 0x3E;
		}
		else if (segment == SEG_FS)
		{
			model->code[j] = 0x64;
		}
		else if (segment == SEG_GS)
		{
			model->code[j] = 0x65;
		}
		else
		{
			strcpy(errtext, ("Internal Assembler error"));
			goto error;
		}
		model->mask[j] = (char)0xFF;
		j++;
	}
	if (dispsize > 0)
	{
		memcpy(tcode + i + 1 + hasrm + hassib, &displacement, dispsize);
		if (anydisp == 0)
		{
			memset(tmask + i + 1 + hasrm + hassib, 0xFF, dispsize);
		}
	}
	if (immsize > 0)
	{
		if (immsize == 1)
		{
			l = 0xFFFFFF00L;
		}
		else if (immsize == 2)
		{
			l = 0xFFFF0000L;
		}
		else
		{
			l = 0L;
		}
		if ((immediate & l) != 0 && (immediate & l) != l)
		{
			strcpy(errtext, ("Constant does not fit into operand"));
			goto error;
		}

		memcpy(tcode + i + 1 + hasrm + hassib + dispsize, &immediate, immsize);
		if (anyimm == 0)
		{
			memset(tmask + i + 1 + hasrm + hassib + dispsize, 0xFF, immsize);
		}
	}

	//
	i = i + 1 + hasrm + hassib + dispsize + immsize;
	jmpoffset = jmpoffset - (i + j + jmpsize);
	model->jmpsize = jmpsize;
	model->jmpoffset = jmpoffset;
	model->jmppos = i + j;

	//
	if (jmpsize != 0)
	{
		if (ip != 0)
		{
			jmpoffset = jmpoffset - ip;
			if (jmpsize == 1 && anyjmp == 0 && (jmpoffset < -128 || jmpoffset >= 128))
			{
				if (longjump == 0 && (jmpmode & 0x03) == 0)
				{
					longjump = 1;
					goto retrylongjump;
				}
				sprintf(errtext, ("Relative jump out of range, use %s LONG form"), name);
				goto error;
			}
			memcpy(tcode + i, &jmpoffset, jmpsize);
		}
		if (anyjmp == 0)
		{
			memset(tmask + i, 0xFF, jmpsize);
		}
		i += jmpsize;
	}

	//
	memcpy(model->code + j, tcode, i);
	memcpy(model->mask + j, tmask, i);
	i += j;
	model->length = i;
	return i;                            // Positive value: length of code


error:
	model->length = 0;
	return cmd - m_pAsmCmd;                 // Negative value: position of error
}