/**
 * CExprItem
 */
function CExprItem ()
{
	this.m_strType = "CExprItem";
	this.m_nExeId = -1;
	this.m_nSymbolId = MAX_VALUE;
	this.m_objSymbol = null;
	this.m_objFormExe = null;
}

CExprItem.prototype.ExprItem = function (nExeId, nSymbolId)
{
	this.m_nExeId = nExeId;
	this.m_nSymbolId = nSymbolId;
}

CExprItem.prototype.getFormExe = function ()
{
	return this.m_objFormExe;
}

CExprItem.prototype.setFormExe = function (pFormExe)
{
	this.m_objFormExe = pFormExe;
}

CExprItem.prototype.initialize = function (objObjectX)
{
	this.initializeExprItem(objObjectX);
}

CExprItem.prototype.initializeExprItem = function (objObjectX)
{
	if (null == this.m_objSymbol && MAX_VALUE != this.m_nSymbolId && -1 != this.m_nSymbolId)
	{
		if (null != (this.m_objSymbol = objObjectX.querySymbol(this.m_nExeId, this.m_nSymbolId)))
		{
			this.m_objSymbol.initialize(objObjectX);
		}
	}

	return (null != this.m_objSymbol) ? true : false;
}

CExprItem.prototype.getValue = function ()
{
	return this.m_objSymbol;
}

CExprItem.prototype.getSymbol = function ()
{
	return this.m_objSymbol;
}

CExprItem.prototype.getSymbolId = function ()
{
	return this.m_nSymbolId;
}

CExprItem.prototype.getTempSymbol = function ()
{
	return (null != this.m_objFormExe) ? this.m_objFormExe.getTempSymbol() : null;
}

CExprItem.prototype.releaseTempSymbol = function (pSymbol)
{
	if (null != this.m_objFormExe && null != pSymbol)
	{
		this.m_objFormExe.releaseTempSymbol(pSymbol);
	}
}

CExprItem.prototype.isOneBase = function ()
{
	return this.m_objFormExe.useEBLSource();
}


/**
 * CIDItem
 */
function CIDItem (nExeId, nSymbolId)
{
	this.m_strType = "CIDItem";
	
	this.ExprItem(nExeId, nSymbolId);
}

CIDItem.prototype = new CExprItem ()
CIDItem.prototype.constructor = CIDItem;

CIDItem.prototype.setValue = function (objValue)
{
	var objSymbol = this.getSymbol();
	if (null == objValue || null == objSymbol)
	{
		return;
	}
	
	objSymbol.assign(objValue);
}

function CFormatIDItem (nExeId, nSymbolId, waFormatExprItem)
{
	this.m_strType = "CFormatIDItem";
	
	this.m_waFormatExprItem = waFormatExprItem;
	this.m_oaFormatExprItem = null;
	
	this.ExprItem(nExeId, nSymbolId);
}

CFormatIDItem.prototype = new CIDItem ()
CFormatIDItem.prototype.constructor = CFormatIDItem;

CFormatIDItem.prototype.initialize = function (pObjectX)
{
	this.initializeExprItem(pObjectX);
	
	if (0 == this.m_waFormatExprItem.length)
		return false;
	
	if (null == this.m_oaFormatExprItem)
	{
		if (null == (this.m_oaFormatExprItem = new Array())) 
		{
			throw "CFormatIDItem.initialize";
		}

		for (var i = 0 ; i < this.m_waFormatExprItem.length; i++)
		{
			var pExeCore = pObjectX;
			
			var wID = this.m_waFormatExprItem[i];
			var pExprItem = pExeCore.queryExprItem(wID);
			if (null != pExprItem)
				this.m_oaFormatExprItem.push (pExprItem);
		}
	}

	return (0 < this.m_oaFormatExprItem.length) ? true : false;
}

CFormatIDItem.prototype.getValue = function ()
{
	var arValue;
	if (null != this.m_oaFormatExprItem)
	{
		var nTotalCount = this.m_oaFormatExprItem.length;
		arValue = new Array(nTotalCount); 
		
		for (var i =0; i < nTotalCount; i++)				
		{
			var pSymbol = null;
			var pBuffItem = this.m_oaFormatExprItem[i];

			if (null == pBuffItem || null == (pSymbol = pBuffItem.getValue()))
			{
				arValue[i] = "";
			}
			else
			{
				arValue[i] = pSymbol.toStringX ();
			}
		}
	}

	var strData = "";
	if (null != this.m_objSymbol)
	{
		strData = this.m_objSymbol.toStringX ();
	}

	//strData = Utils.replaceAll(strData, "'", "''");
	
	strData = this.messageFormat(strData, arValue);

	var pResult = this.getTempSymbol();
	if (null == pResult)
	{
		return null;
	}

	pResult.setValueType(CVariantX._vtString, strData);
	return pResult;
}

/**
 * {0}, {1} 형태의 메시지 포맷을 해당 배열 변수로 치환
 */
CFormatIDItem.prototype.messageFormat = function (strData, arValue)
{
	var strResult = "";
	var nIndex = 0, nLastIndex = 0;
	
	while (-1 < (nIndex = strData.indexOf("{", nIndex)))
	{
		strResult += strData.substring(nLastIndex, nIndex)
		
		var nEndIndex = strData.indexOf("}", nIndex);
		
		if (nIndex < nEndIndex)
		{
			var strIndex = strData.substring(nIndex + 1, nEndIndex);
			
			var nArrayIndex = Utils.parseInt(strIndex);
			
			strResult += arValue[nArrayIndex];
			
			nIndex = nEndIndex + 1;
		}
		
		nLastIndex = nIndex;
	}
	
	strResult += strData.substring(nLastIndex);
	
	return strResult;
}

/**
 * CFuncItem
 */
function CFuncItem (nExeId, nSymbolId, arArgIdList) 
{
	this.m_strType = "CFuncItem";
	
	this.m_arArgIdList = arArgIdList;
	this.m_arArgList = null;
	
	this.ExprItem(nExeId, nSymbolId);
}

CFuncItem.prototype = new CExprItem ()
CFuncItem.prototype.constructor = CFuncItem;

CFuncItem.prototype.FuncItem = function (nExeId, nSymbolId, arArgIdList)
{
	this.m_arArgIdList = arArgIdList;
	this.m_arArgList = null;
	
	this.ExprItem(nExeId, nSymbolId);
}

CFuncItem.prototype.initialize = function (objObjectX)
{
	this.initializeFuncItem(objObjectX);
}

CFuncItem.prototype.initializeFuncItem = function (objObjectX)
{
	if (false == this.initializeExprItem(objObjectX))
	{
		return false;
	}

	if (null == this.m_arArgIdList || 0 == this.m_arArgIdList.length)
	{
		return true;
	}

	if (null == this.m_arArgList)
	{
		this.m_arArgList = new Array();

		var objExeCore = null;
		var objExprExe = null;

		for (var i = 0, nSize = this.m_arArgIdList.length; i < nSize; i+=1)
		{
			var nId = this.m_arArgIdList[i];

			objExeCore = objObjectX;
			objExprExe = objExeCore.queryExprExe(nId);
			if (null != objExprExe)
			{
				objExprExe.setOwnerBlock(objExeCore.getOwnerBlock());
				objExprExe.initialize(objObjectX);

				this.m_arArgList.push(objExprExe);
			}
		}
	}

	if (0 == this.m_arArgIdList.length ||
			(null != this.m_arArgList && 0 < this.m_arArgList.length))
	{
		return true;
	}

	return false;
}

CFuncItem.prototype.getValue = function ()
{
	var objFuncSymbol = this.getSymbol();

	if (null == objFuncSymbol || ScriptDefine._FUNCTION != objFuncSymbol.getSymbolKind())
	{
		return null;
	}
	
	var strFuncName = objFuncSymbol.getFunctionName();
	if (g_bHasServerScript && null != g_htScriptIDSymbolMap[strFuncName])
	{
		// qwp 서버 스크립트 함수 실행
		var arArgs = null;
		if (null != this.m_arArgList && 0 < this.m_arArgList.length)
		{
			var nCount = this.m_arArgList.length;
			arArgs = new Array(nCount + 1);
			this.makeArgumentList(nCount, arArgs);
		}
	
		g_objPQScript.executeServerScript(strFuncName, objFuncSymbol.getFuncExeID(), arArgs);
		return;
	}
	
	var objFormExe = this.getFormExe();
	var objFuncExe = null;
	if (null == objFormExe || null == (objFuncExe = objFuncSymbol.getFuncExe()))
	{
		return null;
	}

	objFuncExe.setExeId(objFuncSymbol.getFuncExeID());
	objFuncExe.setOwnerBlock(objFormExe);

	objFormExe.regCallStack(objFuncExe);

	var arArgs = null;
	if (null != this.m_arArgList && 0 < this.m_arArgList.length)
	{
		var nCount = this.m_arArgList.length;
		arArgs = new Array(nCount + 1);
		this.makeArgumentList(nCount, arArgs);
	}

	objFuncExe.initialize(objFormExe);

	if (null != arArgs)
	{
		objFuncExe.attachArgList(arArgs);
	}

	objFuncExe.execute();

	objFormExe.unRegCallStack(objFuncExe);

	return objFuncSymbol;
}

CFuncItem.prototype.makeArgumentList = function (nCount, arArgs)
{
	if (null == this.m_arArgList || 0 == nCount || null == arArgs)
		return false;

	// 0 번째는 인자 갯수가 들어간다..
	arArgs[0] = new CVariantX (CVariantX._vtInt, nCount);
	for (var i = 0 ; i < nCount ; i+=1)
	{
		var pExprExe = this.m_arArgList[i];
		if (null == pExprExe)
			continue;

		var pResult = pExprExe.getResult ();
		arArgs[i + 1] = new CVariantX (pResult.getType(), pResult.getValue());

		if (pResult.getType() == CVariantX._vtExeServer)
		{
			// CDataColServer, CDataRowServer형태의 데이터는 CStringArray형태로 변환해서 넘긴다
			if (pResult.toExeServer() instanceof CDataRowServer || pResult.toExeServer() instanceof CDataColServer)
			{
				/*
				var saData = new Array ();

				var pDTServer = pResult.toExeServer();
				pDTServer.getStringArrayData (saData);

				// CStringArray로 넘어갔을 때 값을 리턴할 때 TrimEnd를 하지 않으므로 미리 공백제거 후 넣는다.
				for (var cnt = 0; cnt < saData.getCount(); cnt+=1)
				{
					var str = saData.get(cnt).toString();
					saData.setAt(cnt, StringLib.trimEnd(str));
				}
				
				arArgs[i + 1] = new CVariantX(saData);
				*/
			}
		}

		this.releaseTempSymbol (pResult);
	}

	return true;
}


/**
 * CObjectItem
 */
function CObjectItem (nExeId, nSymbolId, nObjId, nPropId)
{
	this.m_strType = "CObjectItem";
	
	this.m_nObjId = nObjId;			// 자신의 하위 객체에 대한 아이디..
	this.m_nPropId = nPropId;		// 속성 또는 함수에 대한 아이디..
	
	this.m_arArgIdListEx = null;	// 확장 계열 Item 에서 함수인 경우 파라미터 리스트..
	this.m_arArgListEx = null;
	
	this.FuncItem(nExeId, nSymbolId);
}

CObjectItem.prototype = new CFuncItem ()
CObjectItem.prototype.constructor = CObjectItem;

CObjectItem.prototype.CObjectItem = function (nExeId, nSymbolId, nObjId, nPropId, arArgIdList, arArgIdListEx)
{
	this.m_nObjId = nObjId;			// 자신의 하위 객체에 대한 아이디..
	this.m_nPropId = nPropId;		// 속성 또는 함수에 대한 아이디..
	
	this.m_arArgIdListEx = arArgIdListEx;	// 확장 계열 Item 에서 함수인 경우 파라미터 리스트..
	this.m_arArgListEx = null;
	
	this.FuncItem(nExeId, nSymbolId, arArgIdList);
}

CObjectItem.prototype.initialize = function (objObjectX)
{
	this.initializeObjectItem(objObjectX);
}

CObjectItem.prototype.initializeObjectItem = function (objObjectX)
{
	if (false == this.initializeFuncItem(objObjectX))
	{
		return false;
	}

	var arArgIdListEx = this.m_arArgIdListEx;
	if (null == arArgIdListEx || 0 == arArgIdListEx.length)
	{
		return true;
	}

	if (null == this.m_arArgListEx)
	{
		this.m_arArgListEx = new Array();

		var objExeCore = null;
		var objExprExe = null;
		var nSize = arArgIdListEx.length;
		for (var i = 0; i < nSize; i++)
		{
			var nId = Utils.parseInt(arArgIdListEx[i]);
			
			objExeCore = objObjectX;
			objExprExe = objExeCore.queryExprExe(nId);
			if (null != objExprExe)
			{
				objExprExe.setOwnerBlock(objExeCore.getOwnerBlock());
				objExprExe.initialize(objObjectX);
				this.m_arArgListEx.push(objExprExe);
			}
		}
	}

	return (0 == arArgIdListEx.length || (null != this.m_arArgListEx && 0 < this.m_arArgListEx.length)) ? true : false;
}

CObjectItem.prototype.setValue = function (objValue)
{
	var objSymbol = this.getSymbol();
	if (null == objSymbol)
	{
		return;
	}

	objSymbol.setProperty(this.m_nObjId, this.m_nPropId, null, objValue, this.isOneBase());
}

CObjectItem.prototype.getValue = function ()
{
	return this.getValueRun();
}

CObjectItem.prototype.getValueRun = function ()
{
	var objSymbol = this.getSymbol();
	if (null == objSymbol)
	{
		return null;
	}

	var objResult = this.getTempSymbol();

	//EBL 1Base지원
	if (null != objResult && StdCore.S_OK == objSymbol.getProperty(this.m_nObjId, this.m_nPropId, objResult, this.isOneBase()))
	{
		return objResult;
	}

	this.releaseTempSymbol(objResult);

	return null;
}

CObjectItem.prototype.getValueEx = function (objResult, nPropIdEx)
{
	var objResultEx = null;
	try
	{
		if (null == (objResultEx = this.getTempSymbol()))
		{
			throw "CObjectItem.getValueEx";
		}

		var nResult = StdCore.E_FAIL;

		if (null == this.m_arArgIdListEx)
		{
			nResult = objResult.getProperty(StdCore._INIT_WVALUE, nPropIdEx, objResultEx, this.isOneBase());
		}
		else
		{
			var arArgsEx = null;
			if (null != this.m_arArgListEx && 0 < this.m_arArgListEx.length)
			{
				var nCount = this.m_arArgListEx.length;
				arArgsEx = new Array(nCount + 1);
				
				this.makeArgumentListEx(nCount, arArgsEx);
			}

			nResult = objResult.action(StdCore._INIT_WVALUE, nPropIdEx, arArgsEx, objResultEx, this.isOneBase());

			if (null != arArgsEx)
			{
				this.exChangeOutputData(arArgsEx, this.m_arArgListEx);
			}
		}

		this.releaseTempSymbol(objResult);

		if (StdCore.S_OK != nResult)
		{
			throw "CObjectItem.getValueEx";
		}
	}
	catch (e)
	{
		this.releaseTempSymbol(objResultEx);

		throw e;
	}

	return objResultEx;
}

CObjectItem.prototype.makeArgumentListEx = function (nCount, arArgListEx)
{
	if (null == this.m_arArgListEx || 0 == nCount || null == this.m_arArgListEx)
	{
		return false;
	}

	arArgListEx[0] = new CVariantX(CVariantX._vtInt, nCount);

	var objExprExe = null;
	var objResult = null;
	for (var i = 0; i < nCount; i+=1)
	{
		objExprExe = this.m_arArgListEx[i];
		if (null == objExprExe)
		{
			continue;
		}

		objResult = objExprExe.getResult();

		arArgListEx[i + 1] = new CVariantX(CVariantX._vtObject, objResult);

		this.releaseTempSymbol(objResult);
	}

	return true;
}

CObjectItem.prototype.exChangeOutputData = function (arArgs, arArgList)
{
	if (null == arArgs || null == arArgList || 0 == arArgList.length)
	{
		return false;
	}

	if (arArgs[0].toInt() != arArgList.length)
	{
		return false;
	}

	for (var i = 0; i < arArgList.length; i++)
	{
		if (false == arArgs[i + 1].isOutputParam())
		{
			continue;
		}

		var objExprExe = arArgList[i];
		if (null != objExprExe)
		{
			var objIDItem = objExprExe.getFirstItem();
			if (null != objIDItem)
			{
				var objSymbol = objIDItem.getSymbol();
				if (null != objSymbol && ScriptDefine._SYMBOL == objSymbol.getSymbolKind())
				{
					objSymbol.setValue(arArgs[i + 1]);
				}
			}
		}
	}

	return true;
}


function CObjectItemEx (nExeId, nSymbolId, nObjId, nPropId, nPropIdEx)
{
	this.m_strType = "CObjectItemEx";
	this.m_nPropIdEx = nPropIdEx;
	
	this.CObjectItem(nExeId, nSymbolId, nObjId, nPropId);
}

CObjectItemEx.prototype = new CObjectItem ()
CObjectItemEx.prototype.constructor = CObjectItemEx;

CObjectItemEx.prototype.getValue = function ()
{
	var objResult = this.getValueRun();
	if (null == objResult)
	{
		return null;
	}
	
	return this.getValueEx(objResult, this.m_nPropIdEx);
}

/**
 * CFuncObjItem 클래스
 */
function CFuncObjItem (nExeId, nSymbolId, nObjId, nPropId, arArgIdList)
{
	this.m_strType = "CFuncObjItem";
	
	this.CObjectItem(nExeId, nSymbolId, nObjId, nPropId, arArgIdList)
}

CFuncObjItem.prototype = new CObjectItem ()
CFuncObjItem.prototype.constructor = CFuncObjItem;

CFuncObjItem.prototype.getValue = function ()
{
	return this.getValueRun();
}

CFuncObjItem.prototype.getValueRun = function ()
{
	if (null == this.m_objSymbol)
	{
		return null;
	}

	var pResult = null;
	var pvaArgs  = null;
	try
	{
		// 1. 반환값을 받아갈 Temp Symbol 을 받아온다..
		if (null == (pResult = this.getTempSymbol ()))
		{
			throw "CFuncObjItem.getValueRun";
		}

		// 2. 인자가 있는 경우..Argument List 를 맹글어 준다..
		if (null != this.m_arArgList && 0 < this.m_arArgList.length)
		{
			var nCount = this.m_arArgList.length;
			
			pvaArgs = new Array(nCount + 1);
			this.makeArgumentList(nCount, pvaArgs);
		}

		// 3. 함수를 Call 해준다.. EBL 1Base지원
		if (StdCore.S_OK != this.m_objSymbol.action (this.m_nObjId, this.m_nPropId, pvaArgs, pResult, this.isOneBase()))
		{
			throw "CFuncObjItem.getValueRun";
		}

		// Output Parameter 처리를 해준다..
		if (null != pvaArgs)
		{
			this.exChangeOutputData (pvaArgs, this.m_arArgList); 
		}
	}
	catch(e)
	{
		this.releaseTempSymbol (pResult);
		pResult = null;
	}

	return pResult;
}

CFuncObjItem.prototype.setValue = function (objValue)
{
	if (null == objValue || null == this.m_objSymbol)
		return ;
	if (null == this.m_arArgList || 0 == this.m_arArgList.length)
		return ;

	var nResult = StdCore.E_FAIL;
	var pvaArgs = null;
	try
	{
		// 1. Argument List 를 맹글어 준다..
		var nCount = this.m_arArgList.length;
		pvaArgs = new Array(nCount + 1);
		this.makeArgumentList (nCount, pvaArgs);

		// 2. 함수를 Call 해준다..
		if (StdCore.S_OK != (nResult = this.m_objSymbol.setProperty (this.m_nObjId, this.m_nPropId, pvaArgs, objValue, this.isOneBase())))
		{
			throw "CFuncObjItem.setValue";
		}
	}
	catch (e)
	{
	}
}


/**
 * CFuncObjItemEx 클래스
 */
function CFuncObjItemEx (nExeId, nSymbolId, nObjId, nPropId, nPropIdEx, arArgIdList, arArgIdListEx)
{
	this.m_strType = "CFuncObjItemEx";
	this.m_nPropIdEx = nPropIdEx;
	
	this.CObjectItem(nExeId, nSymbolId, nObjId, nPropId, arArgIdList, arArgIdListEx);
}

CFuncObjItemEx.prototype = new CFuncObjItem ()
CFuncObjItemEx.prototype.constructor = CFuncObjItemEx;

CFuncObjItemEx.prototype.getValue = function ()
{
	var pResult = this.getValueRun ();
	if (null == pResult)
	{
		return null;
	}
	return this.getValueEx (pResult, this.m_nPropIdEx);
}


function CTempItem (nExeId, nSymbolId, nObjId, nPropId, arArgIdList)
{
	this.m_strType = "CTempItem";
	
	this.CObjectItem(nExeId, nSymbolId, nObjId, nPropId, arArgIdList);
}

CTempItem.prototype = new CObjectItem ()
CTempItem.prototype.constructor = CTempItem;

CTempItem.prototype.initAtomIndex = function (objExeCore, nAtomIndex)
{
	var objAtomIndex = objExeCore.queryExprExe(nAtomIndex);
	if (null != objAtomIndex)
	{
		objAtomIndex.setOwnerBlock(objExeCore.getOwnerBlock());
		objAtomIndex.initialize(objExeCore);
	}
	return objAtomIndex;
}

CTempItem.prototype.getValue = function ()
{
	return this.internalGetProperty(null, null);
}

CTempItem.prototype.setValue = function (objValue)
{
	this.internalSetProperty(objValue, null, null);
}

CTempItem.prototype.internalGetProperty = function (objAtomIndex, objPropIDEx)
{
	var objFormExe = this.getFormExe();
	var objSymbol = this.getSymbol();
	if (null == objFormExe || null == objSymbol)
	{
		return null;
	}

	var objResult = null;
	try
	{
		// 1. 반환값을 받아갈 Temp Symbol 을 받아온다..
		if (null == (objResult = this.getTempSymbol()))
		{
			throw "CTempItem.internalGetProperty";
		}

		// 2. 인덱스에 해당하는 고유변수명을 받아온다..
		var strObjName = (StdCore._INIT_WVALUE != this.m_nObjId) ? this.m_objFormExe.getTempString(this.m_nObjId) : "";

		// 3. 아톰 고유변수명에 인덱싱 처리를 해준다..
		var strRealObjName = strObjName;
		if (null != objAtomIndex)
		{
			strRealObjName = this.getRealAtomName (strObjName, objAtomIndex, objPropIDEx);
		}

		// 4. 속성을 받아온다..
		if (Utils.isEmpty(strRealObjName) || 
				StdCore.S_OK != objSymbol.getPropertyS(strRealObjName, this.m_nPropId, objResult))
		{
			throw "CTempItem.internalGetProperty";
		}
	}
	catch (e)
	{
		this.releaseTempSymbol(objResult);

		throw e;
	}
	return objResult;
}

CTempItem.prototype.internalSetProperty = function (objValue, objAtomIndex, objPropIDEx)
{
	var objFormExe = this.getFormExe();
	var objSymbol = this.getSymbol();
	if (null == objValue || null == objFormExe || null == objSymbol)
	{
		return null;
	}
	
	var arArgs = null;
	var arArgList = this.m_arArgList;
	if (null != arArgList && 0 < arArgList.length)
	{
		var nCount = arArgList.length;
		arArgs = new Array (nCount + 1);
		this.makeArgumentList(nCount, arArgs);
	}
	
	// 2. 인덱스에 해당하는 고유변수명을 받아온다.. 
	// EBL에서 부모폼 또는 자식폼의 아톰명(.값 생략)에 접근 가능하도록 했다. 
	var wPropID = this.m_nPropId;
	var strObjName = "";
	if (StdCore._INIT_WVALUE == this.m_nObjId) // 사용자 정의 함수 Call
	{
		strObjName = (StdCore._INIT_WVALUE != this.m_nPropId) ? this.m_objFormExe.getTempString(this.m_nPropId) : "";
		wPropID = StdCore._INIT_WVALUE;
	}
	else
	{	// 아톰의 속성이나 함수 호출..
		strObjName = (StdCore._INIT_WVALUE != this.m_nObjId) ? this.m_objFormExe.getTempString(this.m_nObjId) : "";
	}

	// 3. 아톰 고유변수명에 인덱싱 처리를 해준다..
	var strRealObjName = strObjName;
	if (null != objAtomIndex)
	{
		strRealObjName = this.getRealAtomName (strObjName, objAtomIndex, objPropIDEx);
	}
	
	if (Utils.isEmpty(strRealObjName) || 
			StdCore.S_OK != objSymbol.setPropertyS(strRealObjName, wPropID, arArgs, objValue))
	{
		throw "CTempItem.internalSetProperty";
	}

	return;
}

CTempItem.prototype.internalAction = function (objAtomIndex, nPropIDEx)
{
	var objSymbol = this.getSymbol();
	if (null == objSymbol)
	{
		return null;
	}
	
	var objResult = null;
	var arArgs = null;
	try
	{
		if (null == (objResult = this.getTempSymbol()))
		{
			throw PQScriptException.create(this, PQExceptionMessage.s_PQScript_FailExecuteScript, "");
		}
		
		var arArgList = this.m_arArgList;
		if (null != arArgList && 0 < arArgList.length)
		{
			var nCount = arArgList.length;
			arArgs = new Array(nCount + 1);
			
			this.makeArgumentList(nCount, arArgs);
		}
		
		var wPropID = this.m_nPropId;
		var strObjName = "";
		// 3. 인덱스에 해당하는 값을 받아온다..
		if (StdCore._INIT_WVALUE == this.m_nObjId) // 사용자 정의 함수 Call
		{
			strObjName = (StdCore._INIT_WVALUE != this.m_nPropId) ? this.m_objFormExe.getTempString(this.m_nPropId) : "";
			wPropID = StdCore._INIT_WVALUE;
		}
		else
		{
			// 아톰의 속성이나 함수 호출..
			strObjName = (StdCore._INIT_WVALUE != this.m_nObjId) ? this.m_objFormExe.getTempString(this.m_nObjId) : "";
		}
		
		if (0 == strObjName.length)
		{
			throw "CTempItem.internalAction";
		}
		
		// 아톰 고유변수명에 인덱싱 처리를 해준다..
		var strRealObjName = strObjName;
		if (null != objAtomIndex)
			strRealObjName = this.getRealAtomName (strObjName, objAtomIndex, nPropIDEx);
		
		if (Utils.isEmpty(strRealObjName) || 
				StdCore.S_OK != objSymbol.actionS(strRealObjName, wPropID, arArgs, objResult))
		{
			throw "CTempItem.internalAction";
		}

		if (null != arArgs)
		{
			this.exChangeOutputData(arArgs, arArgList);
		}
	}
	catch (e)
	{
		this.releaseTempSymbol(objResult);
		objResult = null;
		throw e;
	}
	return objResult;
}

CTempItem.prototype.getRealAtomName = function (strObjName, objAtomIndex, objPropIDEx)
{
	var strRealObjName = strObjName;
	if (null != objAtomIndex)
	{
		var pIndex = objAtomIndex.getResult();
		var nAtomIndex = pIndex.toInt ();
		
		this.releaseTempSymbol (pIndex);
		strRealObjName = strObjName + "[" + nAtomIndex + "]";
	}

	// 배열 속성을 갖을 경우에 대한 처리 추가
	if (null != objPropIDEx)
	{
		var pIndex = objPropIDEx.getResult ();
		var nAtomIndex = pIndex.toInt ();
		
		this.releaseTempSymbol (pIndex);
		strRealObjName = strRealObjName + "[" + nAtomIndex + "]";
	}
	
	return strRealObjName;
}


function CTempItemEx (nExeId, nSymbolId, nObjId, nPropId, nPropIdEx, arArgIdList, arArgIdListEx)
{
	this.m_strType = "CTempItemEx";
	this.m_nPropIdEx = nPropIdEx;
	
	this.CObjectItem(nExeId, nSymbolId, nObjId, nPropId, arArgIdList, arArgIdListEx);
}

CTempItemEx.prototype = new CTempItem ()
CTempItemEx.prototype.constructor = CTempItemEx;

CTempItemEx.prototype.getValue = function ()
{
	var objResult = this.internalGetProperty(null, null);
	if (null == objResult)
	{
		return null;
	}
	
	return this.getValueEx(objResult, this.m_nPropIdEx);
}

function CTempItemS (nExeId, nSymbolId, nObjId, nPropId, nPropIdEx, nAtomIndex)
{
	this.m_strType = "CTempItemS";
	
	this.m_nAtomIndex = nAtomIndex;
	this.m_objAtomIndex = null;
	
	this.m_nPropIDEx= nPropIdEx;	// 배열 속성에 대한 인덱스 2008. 01. 08 황성민
	this.m_objPropIDEx;
	
	this.CObjectItem(nExeId, nSymbolId, nObjId, nPropId, null, null);
}

CTempItemS.prototype = new CTempItem ()
CTempItemS.prototype.constructor = CTempItemS;

CTempItemS.prototype.initialize = function (objObjectX)
{
	if (false == this.initializeObjectItem(objObjectX))
	{
		return false;
	}

	if (StdCore._INIT_WVALUE != this.m_nAtomIndex && null == this.m_objAtomIndex)
	{
		this.m_objAtomIndex = this.initAtomIndex(objObjectX, this.m_nAtomIndex);
	}
	if (StdCore._INIT_WVALUE != this.m_nPropIDEx && null == this.m_objPropIDEx)
	{
		this.m_objPropIDEx = this.initAtomIndex (objObjectX, this.m_nPropIDEx);
	}
	
	return (null != this.m_objAtomIndex) ? true : false;
}

CTempItemS.prototype.getValue = function ()
{
	return this.internalGetProperty(this.m_objAtomIndex, this.m_objPropIDEx);
}

CTempItemS.prototype.setValue = function (objValue)
{
	this.internalSetProperty(objValue, this.m_objAtomIndex, this.m_objPropIDEx);
}
	

/**
 * COpItem 클래스
 */
COpItem.s_PLUS = 0;
COpItem.s_MINUS = 1;
COpItem.s_MULTIPLY = 2;
COpItem.s_DIVISION = 3;
COpItem.s_MODULUS = 4;
COpItem.s_CONCAT = 5;

COpItem.s_EQUAL = 6; // =
COpItem.s_LESS_THAN = 7; // <
COpItem.s_GREATER_THAN = 8; // >
COpItem.s_LESS_EQUAL = 9; // <=
COpItem.s_GREATER_EQUAL = 10; // >=
COpItem.s_NOT_EQUAL = 11; // !=
COpItem.s_AND = 12; // &&
COpItem.s_OR = 13; // ||
COpItem.s_NEGATE = 14; // -

function COpItem (nExeId, nSymbolId)
{
	this.m_strType = "COpItem";
	
	this.ExprItem(nExeId, nSymbolId);
}

COpItem.prototype = new CExprItem ()
COpItem.prototype.constructor = COpItem;

COpItem.prototype.isUnary = function ()
{
	return (COpItem.s_NEGATE <= this.getSymbolId()) ? true : false;
}

COpItem.prototype.evaluate = function (objLOpnd, objROpnd)
{
	if (null == objLOpnd)
	{
		return null;
	}

	var objResult = this.getTempSymbol();
	if (null == objResult)
	{
		return null;
	}

	var nSymbolId = this.getSymbolId();
	if (CVariantX._vtNull == objLOpnd.getType() || (null != objROpnd && CVariantX._vtNull == objROpnd.getType()))
	{
		if (COpItem.s_EQUAL == nSymbolId || COpItem.s_LESS_THAN == nSymbolId || COpItem.s_GREATER_THAN == nSymbolId || 
				COpItem.s_LESS_EQUAL == nSymbolId || COpItem.s_GREATER_EQUAL == nSymbolId || COpItem.s_NOT_EQUAL == nSymbolId || 
				COpItem.s_AND == nSymbolId || COpItem.s_OR == nSymbolId)
		{
			objResult.setValueType(CVariantX._vtInt, 0);
		}
		else
		{
			if (CVariantX._vtNull == objLOpnd.getType())
			{
				objResult.copy(objROpnd);
			}
			else if (null != objROpnd && CVariantX._vtNull == objROpnd.getType())
			{
				objResult.copy(objLOpnd);
			}
		}
	}
	else
	{
		switch (nSymbolId)
		{
			case COpItem.s_PLUS:
				objResult.plus(objLOpnd, objROpnd);
				break;
			case COpItem.s_MINUS:
				objResult.minus(objLOpnd, objROpnd);
				break;
			case COpItem.s_MULTIPLY:
				objResult.multiply(objLOpnd, objROpnd);
				break;
			case COpItem.s_DIVISION:
				objResult.division(objLOpnd, objROpnd);
				break;
			case COpItem.s_MODULUS:
				objResult.modulus(objLOpnd, objROpnd);
				break;
			case COpItem.s_CONCAT:
				objResult.concat(objLOpnd, objROpnd);
				break;
			case COpItem.s_EQUAL:
				objResult.equal(objLOpnd, objROpnd);
				break;
			case COpItem.s_LESS_THAN:
				objResult.lessThan(objLOpnd, objROpnd);
				break;
			case COpItem.s_GREATER_THAN:
				objResult.greaterThan(objLOpnd, objROpnd);
				break;
			case COpItem.s_LESS_EQUAL:
				objResult.lessEqual(objLOpnd, objROpnd);
				break;
			case COpItem.s_GREATER_EQUAL:
				objResult.greaterEqual(objLOpnd, objROpnd);
				break;
			case COpItem.s_NOT_EQUAL:
				objResult.notEqual(objLOpnd, objROpnd);
				break;
			case COpItem.s_AND:
				objResult.and(objLOpnd, objROpnd);
				break;
			case COpItem.s_OR:
				objResult.or(objLOpnd, objROpnd);
				break;
			case COpItem.s_NEGATE:
				objResult.negate(objLOpnd);
				break;
			default:
				break;
		}
	}

	this.releaseTempSymbol(objLOpnd);
	this.releaseTempSymbol(objROpnd);
	
	return objResult;
}

////////////////////////////////////////////////////
// Symbol 클래스 시작

function CVariantX (nType, objValue) 
{
	this.m_strType = "CVariantX";
	this.m_nType = nType,
	
	this.m_nValue = 0;
	this.m_dValue = 0;
	this.m_strValue = "";
	this.m_objExeServer = null;
	this.m_objValue = null;
	this.m_arValue = null;
	
	this.m_bOutputParam = false;
	
	this.setValue(objValue);
}

CVariantX._vtNull = 0;
CVariantX._vtInt = 1;
CVariantX._vtReal = 2;
CVariantX._vtString = 3;
CVariantX._vtExeServer = 4;
CVariantX._vtObject = 5;
CVariantX._vtArray = 6;
CVariantX._vtByte = 7;
CVariantX._vtDataTable = 8;

CVariantX.prototype.VariantX = function (nType, objValue)
{
	this.m_nType = nType
	this.m_nValue = 0;
	this.m_dValue = 0;
	this.m_strValue = "";
	this.m_objExeServer = null;
	this.m_objValue = null;
	this.m_arValue = null;
	
	this.m_bOutputParam = false;
	
	if (null != objValue)
	{
		this.setValue(objValue);
	}
}

CVariantX.prototype.getType = function ()
{
	return this.m_nType;
}

CVariantX.prototype.setType = function (nType)
{
	this.m_nType = nType;
}

CVariantX.prototype.getValue = function ()
{
	var objValue = null;
	
	switch (this.m_nType)
	{
		case CVariantX._vtInt:
			objValue = this.m_nValue;
			break;
		case CVariantX._vtReal:
			objValue = this.m_dValue;
			break;
		case CVariantX._vtString:
			objValue = this.m_strValue;
			break;
		case CVariantX._vtArray:
			objValue = this.m_arValue;
			break;
		default:
			break;
	}
	
	return objValue;
}

CVariantX.prototype.setValue = function (objValue)
{
	if (objValue instanceof CVariantX)
	{
		this.copy(objValue);
	}
	else
	{
		if (CVariantX._vtNull == this.m_nType)
		{
		}
		else if (CVariantX._vtInt == this.m_nType)
		{
			this.m_nValue = Utils.parseInt(objValue);
		}
		else if (CVariantX._vtReal == this.m_nType)
		{
			this.m_dValue = objValue;
		}
		else if (CVariantX._vtString == this.m_nType)
		{
			this.m_strValue = objValue;
		}
		else if (CVariantX._vtExeServer == this.m_nType)
		{
			this.m_objExeServer = objValue;
		}
		else if (CVariantX._vtObject == this.m_nType)
		{
			this.m_objValue = objValue;
		}
		else if (CVariantX._vtArray == this.m_nType)
		{
			this.m_arValue = objValue;
		}
	}
}

/**
 * 캐스팅으로 인자를 구분할수 없으므로, 변수형을 변환시켜서 값을 설정할 경우 사용해야함
 */
CVariantX.prototype.setValueType = function (nType, objValue)
{
	this.m_nType = nType;
	
	this.setValue(objValue);
}

CVariantX.prototype.initValue = function ()
{
	this.m_nType = CVariantX._vtNull;
	
	this.m_nValue = 0;
	this.m_dValue = 0;
	this.m_strValue = "";
	this.m_objExeServer = null;
	this.m_objValue = null;
	this.m_arValue = null;
	
	this.m_bOutputParam = false;
}

CVariantX.prototype.clear = function ()
{
	if (CVariantX._vtNull == this.m_nType)
	{
		return;
	}

	switch (this.m_nType)
	{
		case CVariantX._vtArray:
			if (this.isVarArray())
			{
				this.m_arValue.removeAll();
				this.m_arValue = null;
			}
			break;
		case CVariantX._vtExeServer:
			if (null != this.m_objExeServer)
			{
				this.m_objExeServer = null;
			}
			break;
			default:
			break;
	}

	this.initValue();
}

CVariantX.prototype.isOutputParam = function ()
{
	return this.m_bOutputParam;
}

CVariantX.prototype.setOutputParam = function (bOutputParam)
{
	this.m_bOutputParam = bOutputParam;
}

CVariantX.prototype.isVarArray = function ()
{
	return (CVariantX._vtArray == this.m_nType && null != this.m_arValue) ? true : false;
}

CVariantX.prototype.makeVarArray = function ()
{
	if (CVariantX._vtArray == this.m_nType && null != this.m_arValue)
	{
		return true;
	}
	
	this.clear();

	this.m_nType = CVariantX._vtArray;
	this.m_arValue = new CVarArrayX();
	
	return true;
}

CVariantX.prototype.copy = function (objValue)
{
	if (null == objValue)
	{
		return null;
	}
	
	// 같은변수 = 같은변수  <-값을 했을 때 값이 들어가지 않는 문제 해결
	if (this != objValue)
		this.clear ();

	this.m_nType = objValue.getType();
	switch (this.m_nType)
	{
		case CVariantX._vtInt:
			this.m_nValue = objValue.toInt();
			break;
		case CVariantX._vtReal:
			this.m_dValue = objValue.toDouble();
			break;
		case CVariantX._vtString:
			this.m_strValue = objValue.toStringX();
			break;
		case CVariantX._vtExeServer:
			this.m_objExeServer = objValue.toExeServer();
			break;
		case CVariantX._vtObject:
			this.m_objValue = objValue.toObject();
			break;
		case CVariantX._vtArray:
			if (this.makeVarArray() && null != this.m_arValue)
			{
				this.m_arValue.copy(objValue.toArray(), true);
			}
			break;
		default:
			break;
	}
	return this;
}

CVariantX.prototype.toInt = function ()
{
	var nValue = 0;
	
	switch (this.m_nType)
	{
		case CVariantX._vtInt:
			nValue = this.m_nValue;
			break;
		case CVariantX._vtReal:
			nValue = Utils.parseInt(this.m_dValue);
			break;
		case CVariantX._vtString:
			var nPoint = this.m_strValue.indexOf(".");
			if (0 < nPoint)
			{
				this.m_strValue = this.m_strValue.substring(0, nPoint - 1);
			}
			
			nValue = Utils.parseInt(this.m_strValue);
			break;
		default:
			break;
	}
	
	return nValue;
}

CVariantX.prototype.toDouble = function ()
{
	var dValue = 0;
	
	switch (this.m_nType)
	{
		case CVariantX._vtInt:
			dValue = this.m_nValue;
			break;
		case CVariantX._vtReal:
			dValue = this.m_dValue;
			break;
		case CVariantX._vtString:
			dValue = parseFloat(this.m_strValue);
			break;
		default:
			break;
	}
	
	return dValue;
}

CVariantX.prototype.toBoolean = function ()
{
	var bValue = false;
	
	switch (this.m_nType)
	{
		case CVariantX._vtInt:
			bValue = (0 == this.m_nValue) ? false : true ;
			break;
		case CVariantX._vtReal:
			bValue = (0 == this.m_nValue) ? false : true ;
			break;
		case CVariantX._vtString:
			bValue = ("" == this.m_strValue || "0" == this.m_strValue) ? false : true;
			break;
		default:
			break;
	}
	
	return bValue;
}

CVariantX.prototype.toStringX = function ()
{
	var strValue = "";
	
	switch (this.m_nType)
	{
		case CVariantX._vtInt:
			strValue = this.m_nValue + "";
			break;
		case CVariantX._vtReal:
			strValue = this.m_dValue + "";
			break;
		case CVariantX._vtString:
			strValue = this.m_strValue;
			break;
		default:
			break;
	}
	
	return strValue;
}

CVariantX.prototype.toArray = function ()
{
	return this.m_arValue;
}

CVariantX.prototype.toExeServer = function ()
{
	return this.m_objExeServer;
}

CVariantX.prototype.setValueExeServer = function (objExeServer)
{
	this.clear();
	
	this.m_nType = CVariantX._vtExeServer;
	this.m_objExeServer = objExeServer;
}

CVariantX.setReturnValue = function (strData, objRetVal, strType)
{
	if (null != strType)
	{
		if (strType == "int")
		{
			if (null == strData || strData.length == 0)
			{
				strData = "0"; 
			}
			objRetVal.setValueType(CVariantX._vtInt, Utils.parseInt(strData));
		}
		else if (strType == "float" || strType == "double")
		{
			objRetVal.setValueType(CVariantX._vtReal, parseFloat(strData));
		}
		else if (strType == "char")
		{
			objRetVal.setValueType(CVariantX._vtString, strData);
		}
		else
		{
			objRetVal.setValue(strData);
		}
	}
}


function CSymbol (nType)
{
	this.m_strType = "CSymbol";
	this.m_bOneBase = false; //EBL 1Base지원
	
	this.VariantX(nType);
}

CSymbol.prototype = new CVariantX();
CSymbol.prototype.constructor = CSymbol;

CSymbol.prototype.Symbol = function (nType, objValue)
{
	this.VariantX(nType, objValue);
}

CSymbol.prototype.initialize = function (objObjectX)
{
	return true;
}

CSymbol.prototype.getSymbolKind = function ()
{
	return ScriptDefine._SYMBOL;
}

CSymbol.prototype.getRealIndex = function (nIndex)
{
	var nRealIndex = nIndex;

	if (this.m_bOneBase == true && 0 < nRealIndex)
	{
		nRealIndex--;
	}

	return nRealIndex;
}

CSymbol.prototype.getRealReturnIndex = function (nIndex)
{
	if (this.m_bOneBase == true && 0 <= nIndex)
	{
		nIndex++;
	}

	return nIndex;
}

CSymbol.prototype.assign = function (pROpnd)
{
	return this.copy(pROpnd);
}

CSymbol.prototype.setProperty = function (nObjID, nPropID, arArgs, objValue, bOneBase)
{
	if (StdCore._INIT_WVALUE == nPropID || null == objValue)
	{
		return StdCore.E_NOT_DEF_PROPERTY;
	}

	this.m_bOneBase = bOneBase;
	var nResult = StdCore.S_OK;

	try
	{
		if (CVariantX._vtObject == this.getType()) // 아무 동작을 하지 않는다
		{
		}

		// 1. Server Class를 갖는 Symbol 인경우... (예) 자신, 내장, 데이터베이스 등...
		if (CVariantX._vtExeServer == this.getType())
		{
			var pExeServer = this.toExeServer();
			if (null == pExeServer || false == pExeServer.isValidServer())
			{
				throw "CSymbol.setProperty";
			}
			// CFormServer는 ScriptDoc 이나 아톰의 스크립트를 실행한다.
			else if (pExeServer instanceof CFormServer)
			{
				nResult = pExeServer.setProperty(nObjID, nPropID, arArgs, objValue);
			}
			else
			{
				nResult = pExeServer.setPropertyL(nPropID, arArgs, objValue);
			}
		}
		else
		{
			nResult = this.setPropertyL(nPropID, arArgs, objValue);
		}
	}
	catch (e)
	{
		nResult = StdCore.E_NOT_DEF_PROPERTY;
	}

	return nResult;
}

CSymbol.prototype.setPropertyS = function (strObjName, wPropID, pvaArgs, pValue)
{
	// 자연어관련 속성값이 없을 때 디폴드값으로 설정
	if (StdCore._INIT_WVALUE == wPropID)
		wPropID = 0;

	if (StdCore._INIT_WVALUE == wPropID || null == pValue)
		return StdCore.E_NOT_DEF_PROPERTY;

	var nResult = StdCore.S_OK;

	try
	{
		if (CVariantX._vtExeServer != this.getType() || null == this.toExeServer())
		{
			throw "CSymbol.setPropertyS";
		}

		var pExeServer = this.toExeServer();
		if (null == pExeServer || false == pExeServer.isValidServer())
		{
			throw "CSymbol.setPropertyS";
		}

		nResult = pExeServer.setPropertyS(strObjName, wPropID, pvaArgs, pValue);
	}
	catch (e)
	{
		nResult = StdCore.E_NOT_DEF_PROPERTY;
		throw e;
	}

	return nResult;
}

CSymbol.prototype.setPropertyL = function (nPropID, arArgs, objRetVal)
{
	switch (nPropID)
	{
	case 0: case 203: return this.set_Property(203, arArgs, objRetVal);
	case 1: case 202: return this.set_Property(202, arArgs, objRetVal);
	case 5: case 201: return this.set_NULL_EX(201, arArgs, objRetVal);
	case 6: case 204: return this.set_Property(204, arArgs, objRetVal);
	case 7: case 221: return this.set_NULL_EX(221, arArgs, objRetVal);
	case 23: case 246: return this.set_NULL_EX(246, arArgs, objRetVal);
	case 24: case 247: return this.set_NULL_EX(247, arArgs, objRetVal);
	default : return StdCore.E_NOT_DEF_PROPERTY;
	}
}

CSymbol.prototype.set_Property = function (nNameID, arArgs, objValue)
{
	switch (nNameID)
	{
		case 201:
			return StdCore.E_NOT_SUPPORT_PROPERTY;
		case 202:
		{
			this.makeVarArray();
		
			var nSize = objValue.toInt();
			if (this.isVarArray() && 0 <= nSize)
				this.toArray().setSize(nSize);
		}
		break;
		case 203:
		{
			if (null == arArgs || 1 > arArgs.length)
				return StdCore.E_NOT_MATCH_PARAM_CNT;
	
			var nID = arArgs[1].toInt();
			nID = this.getRealIndex(nID);
			
			this.makeVarArray();
			if (this.isVarArray() && 0 <= nID)
				this.toArray().setAtGrow(nID, new CVariantX(objValue));
	
		}
		break;
		default:
			return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}

CSymbol.prototype.set_NULL_EX = function (nNameID, arArgs, objRetVal)
{
	return StdCore.E_NOT_DEF_PROPERTY;
}

CSymbol.prototype.getProperty = function (nObjID, nPropID, objRetVal, bOneBase)
{
	if (StdCore._INIT_WVALUE == nPropID || null == objRetVal)
	{
		return StdCore.E_NOT_DEF_PROPERTY;
	}

	this.m_bOneBase = bOneBase; //EBL 1Base지원 2007.07.05 이현숙

	var nResult = StdCore.S_OK;
	try
	{
		if (CVariantX._vtObject == this.getType()) // 아무 동작을 하지 않는다
		{
			//throw PQScriptException.create(this, PQExceptionMessage.s_PQScript_FailExecuteScript, "");
		}

		// 1. Server Class를 갖는 Symbol 인경우... (예) 자신, 내장, 전역 등..데이터베이스 등...
		if (CVariantX._vtExeServer == this.getType())
		{
			var pExeServer = this.toExeServer();
			if (null == pExeServer || false == pExeServer.isValidServer()) // Error
			{
				objRetVal.setValueType(CVariantX._vtInt, 0);
			}
			// CFormServer는 ScriptDoc 이나 아톰의 스크립트를 실행한다. 
			else if (pExeServer instanceof CFormServer)
			{
				nResult = pExeServer.getProperty(nObjID, nPropID, objRetVal);
			}
			else
			{
				nResult = pExeServer.getPropertyL(nPropID, null, objRetVal);
			}
		}
		else
		{
			nResult = this.getPropertyL(nPropID, null, objRetVal);
		}
	}
	catch (e)
	{
		nResult = StdCore.E_NOT_DEF_PROPERTY;
	}

	return nResult;
}

CSymbol.prototype.getPropertyL = function (nPropID, arArgs, objRetVal)
{
	switch (nPropID)
	{
	case 0: case 203: return this.get_Property(203, arArgs, objRetVal);
	case 1: case 202: return this.get_Property(202, arArgs, objRetVal);
	case 5: case 201: return this.get_Property(201, arArgs, objRetVal);
	case 6: case 204: return this.get_Property(204, arArgs, objRetVal);
	case 7: case 221: return this.get_Property(221, arArgs, objRetVal);

	/**
	 * 값.정수로 같은 스크립트 함수의 경우에는 빌더에서 getPropety 호출이지만 raw_action 함수를 수행한다.
	 * 빌더에서는 Map에서 id번호로 함수를 찾으므로 두 경우 모두 함수를 찾을수 있지만.
	 * 
	 * 바뀐 스크립트 함수 호출 방법 에서는
	 * action() 에서 함수 id가 없을 경우 getProperty()에서 id를 찾는 경우는 자동으로 되지만.
	 * 반대의 경우에는 getPropery에 action함수를 중복 설정해 주어야 빌더와 같이 함수를 찾을수 있다.
	 */
	case 8: case 206: return this.raw_Action(206, arArgs, objRetVal);
	case 9: case 207: return this.raw_Action(207, arArgs, objRetVal);
	case 10: case 208: return this.raw_Action(208, arArgs, objRetVal);
	case 11: case 209: return this.raw_Action(209, arArgs, objRetVal);
	case 19: case 215: return this.raw_Action(215, arArgs, objRetVal);
	case 20: case 487: return this.raw_Action(487, arArgs, objRetVal);
	case 25: case 337: return this.raw_Action(337, arArgs, objRetVal);

	case 12: case 210: return this.raw_StringFunc(210, arArgs, objRetVal);
	case 13: case 211: return this.raw_StringFunc(211, arArgs, objRetVal);
	case 14: case 212: return this.raw_StringFunc(212, arArgs, objRetVal);
	case 15: case 213: return this.raw_StringFunc(213, arArgs, objRetVal);
	case 16: case 214: return this.raw_StringFunc(214, arArgs, objRetVal);
	case 17: case 332: return this.raw_StringFunc(332, arArgs, objRetVal);
	case 18: case 333: return this.raw_StringFunc(333, arArgs, objRetVal);
	case 21: case 205: return this.raw_StringFunc(205, arArgs, objRetVal);

	default : return StdCore.E_NOT_DEF_PROPERTY;
	}
}

CSymbol.prototype.getPropertyS = function (strObjName, wPropID, pRetVal)
{
	// 자연어관련 속성값이 없을 때 디폴드값으로 설정
	if (StdCore._INIT_WVALUE == wPropID)
		wPropID = 0;

	if (StdCore._INIT_WVALUE == wPropID || null == pRetVal)
		return StdCore.E_NOT_DEF_PROPERTY;

	var nResult = StdCore.S_OK;
	try
	{
		if (CVariantX._vtExeServer != this.getType() || null == this.toExeServer())
		{
			throw "CSymbol.getPropertyS";
		}
		
		var pExeServer = this.toExeServer();
		if (null == pExeServer || false == pExeServer.isValidServer()) // Error
		{
			throw "CSymbol.getPropertyS";
		}
		
		nResult = pExeServer.getPropertyS(strObjName, wPropID, pRetVal);
	}
	catch (e)
	{
		nResult = StdCore.E_NOT_DEF_PROPERTY;
		throw e;
	}

	return nResult;
}

CSymbol.prototype.get_Property = function (nNameID, arArgs, objRetVal)
{
	switch (nNameID)
	{
	case 201:
	{
		var strVal = this.toStringX();
		objRetVal.setValueType(CVariantX._vtInt, strVal.length);
	}
	break;
	case 202:
	{
		var nSize = (this.isVarArray() && null != this.toArray()) ? this.toArray().getSize() : -1;
		objRetVal.setValueType(CVariantX._vtInt, nSize);
	} break;
	case 203: // 값
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var nID = arArgs[1].toInt();
		nID = this.getRealIndex(nID);

		if (this.isVarArray() && 0 <= nID && nID < this.toArray().getSize())
		{
			// 행으로 추가한 배열에 대한 [행, 열]에 대한 엑세스 추가
			var pva = this.toArray().getAt(nID);
			if (3 == arArgs.length)
			{
				var nRowID = arArgs[2].toInt();
				nRowID = this.getRealIndex (nRowID);
				if (true == pva.isVarArray() && 0 <= nRowID && nRowID < pva.toArray().getSize())
				{
					var pvaRow = pva.toArray().getAt(nRowID);
					objRetVal.setValueType(CVariantX._vtArray, pvaRow);
				}
			}
			else
			{
				objRetVal.setValueType(CVariantX._vtArray, pva); // 데이터 복사..
			}
		}
		else
		{
			/*
			 * 반복문에서 임시[반복횟수]를 사용할때 임시의 내용이 하나일 경우 즉 DB처리객체의 결과셋이
			 * 하나일때 이쪽 함수로 들어오게 된다. 현 상태에서 하나일때 값을 처리하지 못하는 오류로 인하여
			 * 특정 인자로 접근할 경우 기본값만 반환하도록 수정한다.
			 */
			switch (this.getType())
			{
				case CVariantX._vtInt	  : objRetVal.setValueType(CVariantX._vtInt, this.toInt()); break; // #정수
				case CVariantX._vtReal	  : objRetVal.setValueType(CVariantX._vtReal, this.toDouble()); break; // #실수
				case CVariantX._vtString  : objRetVal.setValueType(CVariantX._vtString, this.toStringX()); break; // #문자열
				case CVariantX._vtObject  : objRetVal.setValueType(CVariantX._vtObject, this.toObject()); break; // #배열
				default : break;
			}
		}
	} break;
	case 204:
	{
		var nType = -1;
		switch (this.getType())
		{
		case CVariantX._vtInt:
			nType = 1080;
			break;
		case CVariantX._vtReal:
			nType = 1081;
			break;
		case CVariantX._vtString:
			nType = 1082;
			break;
		case CVariantX._vtObject:
			nType = 1083;
			break;
		case CVariantX._vtArray:
			nType = 1083;
			break;
		default:
			break;
		}
		objRetVal.setValueType(CVariantX._vtInt, nType);

	}
	break;
	case 221:
		objRetVal.setValueType(CVariantX._vtInt, 0);
		break;
	case 247: // 바이트수
	case 246: // 바이트로
		break;
	default: return StdCore.E_NOT_DEF_PROPERTY;
	}

	return StdCore.S_OK;
}

CSymbol.prototype.action = function (nObjID, nPropID, arArgs, objRetVal, bOneBase)
{
	if (StdCore._INIT_WVALUE == nPropID || null == objRetVal)
	{
		return StdCore.E_NOT_DEF_PROPERTY;
	}

	this.m_bOneBase = bOneBase;

	var nResult = StdCore.S_OK;

	try
	{
		if (CVariantX._vtObject == this.getType()) // 아무 동작을 하지 않는다
		{
			throw "CSymbol.action";
		}

		// 1. Server Class를 갖는 Symbol 인경우... (예) 자신, 내장, 데이터베이스 등...
		if (CVariantX._vtExeServer == this.getType())
		{
			var pExeServer = this.toExeServer();
			if (null == pExeServer || false == pExeServer.isValidServer())
			{
				throw "CSymbol.action";
			}
			// CFormServer는 ScriptDoc 이나 아톰의 스크립트를 실행한다.
			else if (pExeServer instanceof CFormServer)
			{
				nResult = pExeServer.action(nObjID, nPropID, arArgs, objRetVal);
			}
			else
			{
				nResult = pExeServer.actionL(nPropID, arArgs, objRetVal);
			}
		}
		else
		{
			nResult = this.actionL(nPropID, arArgs, objRetVal);
		}
	}
	catch (e)
	{
		alert ("Script Engine: CSymbol.action");
		nResult = StdCore.E_NOT_DEF_PROPERTY;
		throw e;
	}

	return nResult;
}

CSymbol.prototype.actionS = function (strObjName, wPropID, pvaArgs, pRetVal)
{
	if (null == pRetVal)
		return StdCore.E_NOT_DEF_PROPERTY;

	var nResult = StdCore.S_OK;
	try
	{
		if (CVariantX._vtExeServer != this.getType() || null == this.toExeServer())
		{
			throw "CSymbol.actions";
		}
		
		var pExeServer = this.toExeServer();
		if (null == pExeServer || false == pExeServer.isValidServer())
		{
			throw "CSymbol.actions";
		}

		nResult = pExeServer.actionS(strObjName, wPropID, pvaArgs, pRetVal);
	}
	catch (e)
	{
		nResult = StdCore.E_NOT_DEF_PROPERTY;
		throw e;
	}

	return nResult;
}

CSymbol.prototype.actionL = function (nPropID, arArgs, objRetVal)
{
	switch (nPropID)
	{
	case 2: case 216: return this.raw_ArrayFunc (216, arArgs, objRetVal);	// 추가
	case 3: case 217: return this.raw_ArrayFunc (217, arArgs, objRetVal);	// 삭제
	case 4: case 218: return this.raw_ArrayFunc (218, arArgs, objRetVal);	// 모두삭제

	case 8: case 206: return this.raw_Action(206, arArgs, objRetVal);
	case 9: case 207: return this.raw_Action(207, arArgs, objRetVal);
	case 10: case 208: return this.raw_Action(208, arArgs, objRetVal);
	case 11: case 209: return this.raw_Action(209, arArgs, objRetVal);

	case 12: case 210: return this.raw_StringFunc(210, arArgs, objRetVal);
	case 13: case 211: return this.raw_StringFunc(211, arArgs, objRetVal);
	case 14: case 212: return this.raw_StringFunc(212, arArgs, objRetVal);
	case 15: case 213: return this.raw_StringFunc(213, arArgs, objRetVal);
	case 16: case 214: return this.raw_StringFunc(214, arArgs, objRetVal);
	case 17: case 332: return this.raw_StringFunc(332, arArgs, objRetVal);
	case 18: case 333: return this.raw_StringFunc(333, arArgs, objRetVal);

	case 19: case 215: return this.raw_Action(215, arArgs, objRetVal);
	case 20: case 487: return this.raw_Action(487, arArgs, objRetVal);
	case 21: case 205: return this.raw_StringFunc(205, arArgs, objRetVal);
	case 22: case 280: return this.raw_Action(280, arArgs, objRetVal);
	case 25: case 337: return this.raw_Action(337, arArgs, objRetVal);
	case 26: case 164: return this.raw_ArrayFunc(164, arArgs, objRetVal);
	default: return this.getPropertyL(nPropID, arArgs, objRetVal);
	}
}

CSymbol.prototype.raw_Action = function (nNameID, arArgs, objRetVal)
{
	switch (nNameID)
	{
	case 206: //소수점()
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var nArgCnt = arArgs[0].toInt();
		var nPeriod = arArgs[1].toInt();
		var strValue = "";

		if (0 >= nPeriod)
		{
			if (0 == nPeriod)
			{
				strValue = this.toStringX();
				var nPos = strValue.indexOf('.');
				strValue = (0 < nPos) ? strValue.substring(0, nPos) : strValue;
			}
			else
				strValue = this.toStringX();

			objRetVal.setValueType(CVariantX._vtString, strValue);
			return StdCore.S_OK;
		}

		strValue = this.toStringX();
		var nRound = (1 < nArgCnt) ? arArgs[2].toInt() : 1086;
		strValue = this.reCalcProcessPeriod(strValue, nPeriod, nRound);
		objRetVal.setValueType(CVariantX._vtString, strValue);

	}
	break;
	case 207:	// 정수로
		objRetVal.setValueType(CVariantX._vtInt, this.toInt());
		break;
	case 208:	// 실수로
		objRetVal.setValueType(CVariantX._vtReal, this.toDouble());
		break;
	case 209:	// 문자
		objRetVal.setValueType(CVariantX._vtString, this.toStringX());
		break;
	case 215:	// 제곱근
		//objRetVal.setValue((float)Math.sqrt(toDouble()));
		break;
	case 487:	// 객체배열
		this.makeVarArray();
		break;
	case 280:	// 정렬방법
		return StdCore.E_NOT_SUPPORT_PROPERTY;
	case 337: //콤마삽입()
	{
		var strValue = this.toStringX();
		//strValue = StringLib.insertComma(Utils.parseInt(strValue));
		break;
	}
	default:
		return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}

CSymbol.prototype.raw_ArrayFunc = function (nNameID, arArgs, objRetVal)
{
	switch (nNameID)
	{
	case 216:	// 추가
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		this.makeVarArray();
		if (false == this.isVarArray())
			return StdCore.E_FAIL;
		
		var nID = -1;
		var nArgCnt = arArgs[0].toInt();
		if (1 == nArgCnt)
		{
			nID = this.toArray().add(new CVariantX(arArgs[1].getType(), arArgs[1].getValue()));
		}
		else if (2 == nArgCnt)
		{
			nID = arArgs[1].toInt();
			if (0 > nID)
			{
				nID = this.toArray().add(new CVariantX(arArgs[2].getType(), arArgs[2].getValue()));
			}
			else
			{
				if (nID >= this.toArray().getSize())
					this.toArray().setAtGrow(nID, new CVariantX(arArgs[2].getType(), arArgs[2].getValue()));
				else
					this.toArray().insertAt(nID, new CVariantX(arArgs[2].getType(), arArgs[2].getValue()));
			}
		}
		objRetVal.setValueType(CVariantX._vtInt, nID);
	} break;
	case 164 : // 추가대입
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		//CDataColServer pServer = new CDataColServer (m_bOneBase);
		pServer.raw_ArrayFunc (164, arArgs, objRetVal);

		this.setValueType(CVariantX._vtExeServer, pServer);

	} break; 
	case 217:	// 삭제
	{
		if (this.isVarArray())
		{
			if (null == arArgs || 1 > arArgs.length)
				return StdCore.E_NOT_MATCH_PARAM_CNT;

			var nID = arArgs[1].toInt();

			var nDelCnt = (1 < arArgs[0].toInt()) ? arArgs[2].toInt() : 1;
			for (var i = 0; i < nDelCnt; i++)
			{
				if (0 > nID || nID >= this.toArray().getSize())
					break;

				this.toArray().removeAt(nID);
			}
		}

	}
	break;
	case 218:	// 모두삭제
	{
		if (this.isVarArray())
			this.toArray().removeAll();

	}
	break;
	default:
		return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}

CSymbol.prototype.raw_StringFunc = function (nNameID, arArgs, objRetVal)
{
	var strVal = this.toStringX();
	if (null == strVal)
	{
		strVal = "";
	}

	switch (nNameID)
	{
	case 205:	// 비교
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var bCheckCase = true;
		if (1 < arArgs[0].toInt())
			bCheckCase = arArgs[2].toBoolean();

		var strComp = arArgs[1].toStringX();

		if (0 == strVal.length && 0 == strComp.length)
		{
			objRetVal.setValueType(CVariantX._vtInt, 1);
			break;
		}
		else if (0 == strVal.length || 0 == strComp.length)
		{
			objRetVal.setValueType(CVariantX._vtInt, 0);
			break;
		}

		if (false == bCheckCase)
		{
			strVal = strVal.toUpperCase();
			strComp = strComp.toUpperCase();
		}
		objRetVal.setValue((strVal == strComp) ? 1 : 0);

	}
	break;
	case 210:	// 절단
	{
		var nArgCnt = (null != arArgs) ? arArgs[0].toInt() : 0;
		var nKind = (0 < nArgCnt) ? arArgs[1].toInt() : 1052;

		if (0 < strVal.length)
		{
			switch (nKind)
			{
			case 1089:
				objRetVal.setValueType(CVariantX._vtString, Utils.trim(strVal));
				break;
			case 1090:
				objRetVal.setValueType(CVariantX._vtString, Utils.trim(strVal));
				break;
			case 1052:
				objRetVal.setValueType(CVariantX._vtString, Utils.trim(strVal));
				break;
			}
		}
		else
			objRetVal.setValueType(CVariantX._vtString, "");
	}
	break;
	case 211:	// 찾기
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.S_OK;

		var nOffsets = (1 < arArgs[0].toInt()) ? arArgs[2].toInt() : 0;
		nOffsets = this.getRealIndex(nOffsets);

		var strFind = arArgs[1].toStringX();

		if (0 > nOffsets)
			nOffsets = 0;
		else if (strVal.length < nOffsets)
			nOffsets = strVal.length;

		if (0 == strVal.length || 0 == strFind.length)
			objRetVal.setValueType(CVariantX._vtInt, -1);
		else
			objRetVal.setValueType(CVariantX._vtInt, this.findStringW(strVal, strFind, nOffsets));

	}
	break;
	case 212:	// 뒤로 찾기
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var nOffsets = -1;
		var strFind = arArgs[1].toStringX();
		if (0 == strVal.length || 0 == strFind.length)
			objRetVal.setValueType(CVariantX._vtInt, -1);
		else
			objRetVal.setValueType(CVariantX._vtInt, this.findStringW(strVal, strFind, nOffsets));
	}
	break;
	case 213:	// 바꾸기
	{
		if (null == arArgs || 2 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var strOrg = arArgs[1].toStringX();
		var strNew = arArgs[2].toStringX();
		
		strVal = Utils.replaceAll(strVal, strOrg, strNew);
		objRetVal.setValueType(CVariantX._vtString, strVal);

	}
	break;
	case 214:	// 일부
	{
		if (null == arArgs || 1 > arArgs.length)
			return StdCore.E_NOT_MATCH_PARAM_CNT;

		var nArgCnt = arArgs[0].toInt();

		var nOffset = arArgs[1].toInt();	// 시작위치
		nOffset = this.getRealIndex(nOffset);

		var nCount = (1 < nArgCnt) ? arArgs[2].toInt() : -100;
		objRetVal.setValueType(CVariantX._vtString, this.subStringW(strVal, nOffset, nCount));
	}
	break;
	case 332:
		objRetVal.setValueType(CVariantX._vtString, (0 < strVal.length) ? strVal.toUpperCase() : "");
		break;
	case 333:
		objRetVal.setValueType(CVariantX._vtString, (0 < strVal.length) ? strVal.toLowerCase() : "");
		break;
	default:
		return StdCore.E_NOT_DEF_PROPERTY;
	}
	return StdCore.S_OK;
}

CSymbol.prototype.reCalcProcessPeriod = function (strString, nPeriod, nRound)
{
	var strValue = strString;

	if (0 == strValue.length || 0 > strValue.indexOf('.'))
	{
		var strResult = (0 < strValue.length) ? strValue : "0";
		strResult = strResult + ".";
		for (var i = 0; i < nPeriod; i++)
			strResult = strResult + "0";
		return strResult;
	}

	var nPos = strValue.indexOf('.');
	var strRight = strValue.substring(nPos + 1);
	if (nPeriod == strRight.length)
		return strValue;

	if (nPeriod > strRight.length)
	{
		for (var i = 0; i < nPeriod - strRight.length; i++)
			strValue = strValue + "0";
		return strValue;
	}

	strValue = strValue.substring(0, nPos + 1 + nPeriod);
	if (1088 == nRound)
		return strValue;

	var nLastNum = (null != strRight.substring(nPeriod, nPeriod + 1) && 0 < strRight.substring(nPeriod, nPeriod + 1).length) 
					? Utils.parseInt(strRight.substring(nPeriod, nPeriod + 1)) : 0;

	if ((1086 == nRound && 5 <= nLastNum) || (1087 == nRound && 0 < nLastNum))
	{
		if (0 != nPeriod)
		{
			var strTargetNum = strRight.substring(nPeriod - 1, nPeriod);
			var nTargetNum = 0 == strTargetNum.length ? 0 : Utils.parseInt(strTargetNum);
			nTargetNum += 1;

			strValue = strValue.substring(0, nPos + 1 + nPeriod - 1);
			strValue = strValue + nTargetNum;
		}
		else
		{
			var nTargetNum = Utils.parseInt(strValue.substring(0, nPos)) + 1;
			strValue = nTargetNum = "";
		}
	}
	else if (0 == nPeriod && -1 != strValue.indexOf("."))
	{
		strValue = strValue.replace(".", "");
	}

	return strValue;
}

CSymbol.prototype.findStringW = function (strVal, strFind, nOffsets)
{
	/*
	 * 찾은 결과에 대한 자연어 1BASE처리
	 */
	var nPos = -1;
	if (0 <= nOffsets)
	{
		nPos = strVal.indexOf(strFind, nOffsets);
		if (-1 != nPos)
		{
			nPos = this.getRealReturnIndex (nPos);
		}
	}
	else
	{
		nPos = strVal.lastIndexOf(strFind);
		if (-1 != nPos)
		{
			nPos = this.getRealReturnIndex (nPos);
		}
	}

	return nPos;
}

CSymbol.prototype.subStringW = function (strVal, nPosS, nCnt)
{
	if (null == strVal || 0 == strVal.length || nPosS > strVal.length)
	{
		return "";
	}

	if (0 > nPosS) // 오른쪽에서 nCnt 만큼 잘라온다..
	{
		if (-100 == nCnt)
		{
			return strVal;
		}
		nPosS = strVal.length - nCnt;
	}
	else if (0 > nCnt)
	{
		// 문자열의 두번째 인자의 값이 없거나, 혹은 음수가 들어왔을경우
		return strVal.substring(nPosS);
	}

	if (nPosS + nCnt >= strVal.length)
	{
		return strVal.substring(nPosS);
	}

	if (0 > nPosS)
	{
		return strVal;
	}

	return strVal.substring(nPosS, nPosS + nCnt);
}


/**
 * CFuncSymbol 클래스
 */
function CFuncSymbol (nType, strFuncName, nExeID)
{
	this.m_strType = "CFuncSymbol";
	this.m_strFuncName = strFuncName;
	this.m_nExeID = nExeID;
	this.m_objFuncExe = null;
	this.m_nSourceLine;
	
	this.Symbol(nType);
}

CFuncSymbol.prototype = new CSymbol();
CFuncSymbol.prototype.constructor = CFuncSymbol;

CFuncSymbol.prototype.initialize = function (objObjectX)
{
	if (null == this.m_objFuncExe && StdCore._INIT_WVALUE != this.m_nExeID)
	{
		this.m_objFuncExe = objObjectX.queryExecute(this.m_nExeID);
	}
	return (null != this.m_objFuncExe) ? true : false;
}

CFuncSymbol.prototype.getSymbolKind = function ()
{
	return ScriptDefine._FUNCTION;
}

CFuncSymbol.prototype.getFuncExe = function ()
{
	return this.m_objFuncExe;
}

CFuncSymbol.prototype.getFuncExeID = function ()
{
	return this.m_nExeID;
}

CFuncSymbol.prototype.getFunctionName = function ()
{
	return this.m_strFuncName;
}


function CConstant (nType, objValue)
{
	this.m_strType = "CConstant";
	
	this.Symbol(nType, objValue);
}

CConstant.prototype = new CSymbol();
CConstant.prototype.constructor = CConstant;


/**
 * TempSymbol
 */
function CTempSymbol ()
{
	this.m_strType = "CTempSymbol";
	
	this.Symbol(CVariantX._vtNull);
}

CTempSymbol.prototype = new CSymbol();
CTempSymbol.prototype.constructor = CTempSymbol;

CTempSymbol.prototype.getSymbolKind = function ()
{
	return ScriptDefine._TEMP_SYMBOL;
}

CTempSymbol.prototype.plus = function (objLOpnd, objROpnd)
{
	if (CVariantX._vtString == objLOpnd.getType() || CVariantX._vtString == objROpnd.getType())
	{
		this.setType(CVariantX._vtString);
		this.setValue(objLOpnd.toStringX() + objROpnd.toStringX());
	}
	else if (CVariantX._vtInt == objLOpnd.getType() && CVariantX._vtInt == objROpnd.getType())
	{
		this.setType(CVariantX._vtInt);
		this.setValue(objLOpnd.toInt() + objROpnd.toInt());
	}
	else
	{
		this.setType(CVariantX._vtReal);
		this.setValue(objLOpnd.toDouble() + objROpnd.toDouble());
	}
	return true;
}

CTempSymbol.prototype.minus = function (objLOpnd, objROpnd)
{
	if (CVariantX._vtInt == objLOpnd.getType() && CVariantX._vtInt == objROpnd.getType())
	{
		this.setType(CVariantX._vtInt);
		this.setValue(objLOpnd.toInt() - objROpnd.toInt());
	}
	else
	{
		this.setType(CVariantX._vtReal);
		this.setValue(objLOpnd.toDouble() - objROpnd.toDouble());
	}
	return true;
}

CTempSymbol.prototype.multiply = function (objLOpnd, objROpnd)
{
	if (CVariantX._vtInt == objLOpnd.getType() && CVariantX._vtInt == objROpnd.getType())
	{
		this.setType(CVariantX._vtInt);
		this.setValue(objLOpnd.toInt() * objROpnd.toInt());
	}
	else
	{
		this.setType(CVariantX._vtReal);
		this.setValue(objLOpnd.toDouble() * objROpnd.toDouble());
	}
	return true;
}

CTempSymbol.prototype.division = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtReal);

	var dblRVal = objROpnd.toDouble();
	if (0.0 == dblRVal)
	{
		// System.out.println(STD_CORE.S_IDS_DEVIDE_ERROR);
		return false;
	}

	this.setValueType(CVariantX._vtReal, objLOpnd.toDouble() / dblRVal);
	return true;
}

CTempSymbol.prototype.modulus = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	this.setValue(objLOpnd.toInt() % objROpnd.toInt());

	return true;
}

CTempSymbol.prototype.concat = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtString);
	this.setValue(objLOpnd.toStringX() + objROpnd.toStringX());

	return true;
}

CTempSymbol.prototype.equal = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);

	if (CVariantX._vtString == objLOpnd.getType() && CVariantX._vtString == objROpnd.getType())
	{
		this.setValue((objLOpnd.toStringX() == objROpnd.toStringX())? 1 : 0);
	}
	else if (CVariantX._vtString == objLOpnd.getType() || CVariantX._vtString == objROpnd.getType())
	{
		// (숫자   | 문자열) 비교일 때는 문자열이 실수로 변환 가능할 때만  비교한다.
		try 
		{
			var dLeft = 0.0;
			var dRight = 0.0;
			if (CVariantX._vtString == objLOpnd.getType())
			{
				var strValue = objLOpnd.toStringX();
				dLeft= parseFloat(strValue); 
			}
			else
			{
				dLeft = objLOpnd.toDouble();
			}

			if (CVariantX._vtString == objROpnd.getType())
			{
				var strValue = objROpnd.toStringX();
				dRight= parseFloat(strValue); 
			}
			else
			{
				dRight = objROpnd.toDouble();
			}

			this.setValue((dLeft == dRight) ? 1 : 0);
		}
		// (숫자   | 문자열) 비교일 때는 문자열이 실수로 변환 불가능 하면 not equal이다.
		catch (e)
		{
			this.setValue(0);
		} 
	}
	else
	{
		this.setValue((objLOpnd.toDouble() == objROpnd.toDouble()) ? 1 : 0);
	}
	return true;
}

CTempSymbol.prototype.lessThan = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	if (CVariantX._vtString == objLOpnd.getType() && CVariantX._vtString == objROpnd.getType())
		this.setValue((objLOpnd.toStringX().localeCompare(objROpnd.toStringX()) < 0) ? 1 : 0);
	else
		this.setValue((objLOpnd.toDouble() < objROpnd.toDouble()) ? 1 : 0);
	return true;
}

CTempSymbol.prototype.greaterThan = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	if (CVariantX._vtString == objLOpnd.getType() && CVariantX._vtString == objROpnd.getType())
		this.setValue((objLOpnd.toStringX().localeCompare(objROpnd.toStringX()) > 0) ? 1 : 0);
	else
		this.setValue((objLOpnd.toDouble() > objROpnd.toDouble()) ? 1 : 0);
	return true;
}

CTempSymbol.prototype.lessEqual = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	if (CVariantX._vtString == objLOpnd.getType() && CVariantX._vtString == objROpnd.getType())
		this.setValue((objLOpnd.toStringX().localeCompare(objROpnd.toStringX()) <= 0) ? 1 : 0);
	else
		this.setValue((objLOpnd.toDouble() <= objROpnd.toDouble()) ? 1 : 0);
	return true;
}

CTempSymbol.prototype.greaterEqual = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	if (CVariantX._vtString == objLOpnd.getType() && CVariantX._vtString == objROpnd.getType())
		this.setValue((objLOpnd.toStringX().localeCompare(objROpnd.toStringX()) >= 0) ? 1 : 0);
	else
		this.setValue((objLOpnd.toDouble() >= objROpnd.toDouble()) ? 1 : 0);
	return true;
}

CTempSymbol.prototype.notEqual = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	if (CVariantX._vtString == objLOpnd.getType() && CVariantX._vtString == objROpnd.getType())
	{
		var strPL = objLOpnd.toStringX();
		var strPR = objROpnd.toStringX();

		this.setValue(!(strPL == strPR) ? 1 : 0);
	}
	else
	{
		try
		{
			//(숫자   | 문자열) 비교일 때는 문자열이 실수로 변환 가능할 때만  비교한다.
			var dLeft = 0.0;
			var dRight = 0.0;
			if (CVariantX._vtString == objLOpnd.getType())
			{
				var strValue = objLOpnd.toStringX();
				dLeft= Double.parseFloat(strValue); 
			}
			else
			{
				dLeft = objLOpnd.toDouble();
			}

			if (CVariantX._vtString == objROpnd.getType())
			{
				var strValue = objROpnd.toStringX();
				dRight= Double.parseFloat(strValue); 
			}
			else
			{
				dRight = objROpnd.toDouble();
			}

			this.setValue((dLeft != dRight) ? 1 : 0);
		}
		catch (e)
		{
			this.setValue(1);
		}
	}

	return true;
}

CTempSymbol.prototype.and = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	this.setValue((false != objLOpnd.toBoolean() && false != objROpnd.toBoolean()) ? 1 : 0);
	return true;
}

CTempSymbol.prototype.or = function (objLOpnd, objROpnd)
{
	this.setType(CVariantX._vtInt);
	this.setValue((false != objLOpnd.toBoolean() || false != objROpnd.toBoolean()) ? 1 : 0);
	return true;
}

CTempSymbol.prototype.negate = function (objLOpnd)
{
	this.setType(objLOpnd.getType());
	switch (objLOpnd.getType())
	{
	case CVariantX._vtInt:
		this.setValue((-1) * objLOpnd.toInt());
		break;
	case CVariantX._vtReal:
		this.setValue((-1) * objLOpnd.toDouble());
		break;
	case CVariantX._vtString:
		this.setValue((-1) * objLOpnd.toDouble());
		break;
	default:
		break;
	}

	return true;
}


/**
 * CFieldSymbol 클래스
 */
function CFieldSymbol (nType, strFieldName)
{
	this.m_strType = "CFieldSymbol";
	
	this.m_strFieldName = strFieldName; 
	
	this.Symbol(CVariantX._vtExeServer);
}

CFieldSymbol.prototype = new CSymbol();
CFieldSymbol.prototype.constructor = CFieldSymbol;

CFieldSymbol.prototype.getSymbolKind = function ()
{
	return ScriptDefine._FIELD_SYMBOL; 
}

CFieldSymbol.prototype.initialize = function (objObjectX)
{
	if (null == this.toExeServer())
	{
		var pExeCore = objObjectX;
		var pFormSym = pExeCore.querySymbol(-1, ScriptDefine.FORM_SERVER);
		if (null != pFormSym)
		{
			this.setValueType (CVariantX._vtExeServer, new CFieldServer (this.m_strFieldName));
			this.toExeServer().initialize(pFormSym.toExeServer());
		}
	}
	return (null != this.toExeServer()) ? true : false;
}

CFieldSymbol.prototype.action = function (nObjID, nPropID, arArgs, objRetVal, bOneBase)
{
	return this.toExeServer().action (nObjID, nPropID, arArgs, objRetVal);
}

CFieldSymbol.prototype.getProperty = function (nObjID, nPropID, objRetVal, bOneBase)
{
	// 서버 스크립트 동작 결과로 필드값이 symbol에 이미 설정된 경우 처리
	if (null != this.m_strValue && 0 < this.m_strValue.length)
	{
		objRetVal.setValueType(CVariantX._vtString, this.m_strValue);
		return StdCore.S_OK;
	}
	
	return this.toExeServer().getProperty (nObjID, nPropID, objRetVal);
}