
/***************************************************************************
**
**    $Header:   D:/ECB2S/SRC/LOG/ERROR/MKERRORS.H__   1.0.1.1.1.5   17 Apr 1997 16:29:42   ZJRD  $
**
**    $Log:   D:/ECB2S/SRC/LOG/ERROR/MKERRORS.H__  $
** 
**    Rev 1.0.1.1.1.5   17 Apr 1997 16:29:42   ZJRD
** No change.
** 
**    Rev 1.0.1.1.1.4   16 Apr 1997 11:08:28   ZJRD
** No change.
** 
**    Rev 1.0.1.1.1.3   10 Apr 1997 15:55:08   ZJRD
** 2.09F
** 
**    Rev 1.0.1.1.1.1   03 Apr 1997 15:32:20   ZJRD
** No change.
** 
**    Rev 1.0.1.1.1.0   28 Mar 1997 10:36:26   ZJRD
** easy pack sld 2.09d
** 
**    Rev 1.0.1.0   19 Mar 1997 11:46:20   ZJRD
** No change.
** 
**    Rev 1.0   12 Mar 1997 15:00:22   ZJRD
** Initial revision.
** 
**    Rev 1.7.1.0.1.2   09 Dec 1996 10:24:10   ZJRD
** EasyPack/SLD Version 2.0P
** 
**    Rev 1.1   02 May 1996 10:34:16   ZJRD
** EasyPack/SLD Versio 1.92
** 
****************************************************************************/

/****************************************************************************
**
**  Name:  mkerrors.h
**
**  Description:
**     This is the ONLY file to change in order to add or change error
**     definitions in EP/SLD.  This file is the source for several
**     other files, which are automatically produced by mkerrors.exe.
**     The generated files are:
**       errcodec.h : error code defines in C format
**       errerr.h : error code offsets in the errtext.rc file
**       errtext.rc : string resources (error text)
**       mkerrors.new : the next version of THIS header file
**
**  Status:  PRELIMINARY
**
**  Date:     8 March 1996 09:11:00  by Jamoon Zhou
**
**
**  Copyright (C) 1996 Microtek International.  All rights reserved.
**
*****************************************************************************/

#define _MKERRORS_

                       /****************************
                        *                          *
                        *       INCLUDE FILES      *
                        *                          *
                        ****************************/

                       /****************************
                        *                          *
                        *        DEFINITIONS       *
                        *                          *
                        ****************************/

//  Here are all the error codes for all the error types in EP/SLD
//  The corresponding error text is in errtext.rc.
//  ONLY MAKE CHANGES BELOW THIS LINE (in mkerrors.h)
/*
{
	"ER_LDR_",
	( 0x400 ),
	
}, 
*/
{
	"ER_LDR_MEMORY_ALLOC",
	E_SEVERE | ( 0x4000 ),
	"Memory alloc failure!",
}, 
{
	"ER_LDR_ABI_MEMORY_READ",
	E_FATAL | ( 0x4001 ),
	"Memory read failure!"
}, 
{
	"ER_LDR_ABI_MEMORY_WRITE",
	E_FATAL | ( 0x4002 ),
	"Memory write failure!"
}, 
{
	"ER_SYM_UPLOAD_OPEN_FILE",
	E_ERROR | ( 0x4003 ),
	"Open file error!"
}, 
{
	"ER_SYM_EXIST",
	E_ERROR | ( 0x4004 ),
	"The symbol exists!"
}, 
{
	"ER_SYM_NOT_EXIST",
	E_ERROR | ( 0x4005 ),
	"The symbol does not exist!"
}, 
{
	"ER_SYM_CREATE_SYM",
	E_ERROR | ( 0x4006 ),
	"Create symbol failure!"
}, 
{
	"ER_SYM_DELETE_SYM",
	E_ERROR | ( 0x4007 ),
	"Delete symbol failure!",
}, 
{
	"ER_SYM_FILE_READ",
	E_ERROR | ( 0x4008 ),
	"Symbol file read error!",
}, 
{
	"ER_SYM_NO_SYM",
	E_WARNING | ( 0x4009 ),
	"no user defined symbol!",
}, 
{
	"ER_SYM_STRUCT",
	E_ERROR | ( 0x400A ),
	"Symbol struct error!",
}, 
{
	"ER_SYM_NOT_SYM_FILE",
	E_ERROR | ( 0x400B ),
	"Not a symbol file!",
}, 
{
	"ER_SYM_FILE_READ2",
	E_ERROR | ( 0x400C ),
	"symbol file read error!",
}, 
{
	"ER_LDR_2500AD_NO_ONDEM",
	E_ERROR | ( 0x400D ),
	"2500AD loader have not ondemand load!",
}, 
{
	"ER_LDR_SYM_FILE_FORMAT",
	E_ERROR | ( 0x400E ),
	"Symbol file format error!",
}, 
{
	"ER_LDR_READ_FILE",
	E_ERROR | ( 0x400F ),
	"Loader read file error! Current offset in file: 0x%X"
}, 
{
	"ER_LDR_ABORT",
	E_WARNING | ( 0x4010 ),
	"User abort requested.",
}, 
{
	"ER_LDR_2500AD_SYM_ADDR",
	E_WARNING | ( 0x4011 ),
	"2500AD format symbol address is not 16 bits",
}, 
{
	"ER_LDR_SYM_TYPE",
	E_ERROR | ( 0x4012 ),
	"Symbol Type Error!",
}, 
{
	"ER_LDR_FILE_FORMAT",
	E_ERROR | ( 0x4014 ),
	"Load file format error! Current offset in file: 0x%X",
}, 
{
	"ER_LDR_FUNC_LIST",
	E_ERROR | ( 0x4015 ),
	"Function list describes error!",
},
{
	"ER_LDR_TYPE",
	E_ERROR | ( 0x4016 ),
	"Error type! Current offset in file: 0x%X",
}, 
{
	"ER_LDR_NOT_RL51",
	E_ERROR | ( 0x4017 ),
	"Loading file is not generated by RL51!",
}, 
{
	"ER_LDR_RELOC_SYM",
	E_ERROR | ( 0x4018 ),
	"It is a relocatable symbol!",
}, 
{
	"ER_LDR_SCOPE",
	E_ERROR | ( 0x4019 ),
	"scope error! Current offset in file: 0x%X",
}, 
{
	"ER_LDR_MODULE_FORMAT",
	E_ERROR | ( 0x401A ),
	"Module format error !",
}, 
{
	"ER_LDR_MODNAME_NOT_MATCH",
	E_ERROR | ( 0x401B ),
	"Module name can not be matched!",
}, 
{
	"ER_LDR_BLOCK_INFO",
	E_ERROR | ( 0x401C ),
	"Block information error!",
}, 
{
	"ER_LDR_FUNCNAME_NOT_MATCH",
	E_ERROR | ( 0x401D ),
	"Function name can not be matched!",
}, 
{
	"ER_LDR_RELOC_ADDR",
	E_ERROR | ( 0x401E ),
	"A relocation address is meeting!",
},
{
	"ER_LDR_OMF51_FORMAT",
	E_ERROR | ( 0x401F ),
	"Omf51 format error !",
},
{
	"ER_LDR_DOWNLOAD_MEM",
	E_FATAL | ( 0X4020 ), 
	"Download file to memory failure !",
},
{
	"ER_LDR_LOAD_MODULE",
	E_ERROR | ( 0x4021 ),
	"Load module error!",
}, 
{
	"ER_LDR_MOD_INFO_LOADED",
	E_WARNING | ( 0x4022 ),
	"module information have been loaded!",
}, 
{
	"ER_LDR_ARRAY_HIGH_BOUND",
	E_ERROR | ( 0x4023 ),
	"Array high bound error !",
}, 
{
	"ER_LDR_UBROF_FORMAT",
	E_ERROR | ( 0x4024 ),
	"Ubrof format error ! Current offset in file: 0x%X",
}, 
{
	"ER_LDR_SYM_SERVER",
	E_SEVERE | ( 0x4025 ),
	"Symbol Server Failure !",
}, 
{
	"ER_LDR_DOWNLOAD_FILE",
	E_ERROR | ( 0x4026 ),
	"Not MSC51 Series CPU download file!",
},
{
	"ER_LDR_UNKNOWN",
	E_ERROR | ( 0x4050 ),
	"Loader Unknown error!"
},
{
	"ER_LDR_NO_SYM",
	E_ERROR | ( 0x4052 ),
	"Symbol infomation have not be loaded!"
},
{
	"ER_LDR_DIFF_ONDEM_FILE",
	E_ERROR | ( 0x4053 ),
	"Load file is not same as OnDemand load file!"
},
{
	"ER_LDR_NO_MODULE",
	E_ERROR | ( 0x4054 ),
	"No such module!"
},
{
	"ER_LDR_OPENFILE_ERROR",
	E_ERROR | ( 0x4055 ),
	"Download file can not be opened!"
},
{
	"ER_LDR_UNKNOWN_FORMAT",
	E_ERROR | ( 0x4056 ),
	"Load file format has not been supported !"
},
{
	"ER_LDR_BANKSIZE",
	E_ERROR | ( 0x4058 ),
	"Bank number you specified has not been supported!"
},
{
	"ER_LDR_BANKPORT",
	E_ERROR | ( 0x4059 ),
	"Port you specified has not been supported by CPU!"
},
{
	"ER_LDR_BANKCTRL",
	E_ERROR | ( 0x405a ),
	"Control signal you specified is not correct!"
},
{
	"ER_LDR_ICE_BANKINIT",
	E_ERROR | ( 0x405B ),
	"Information of initializing bank you specified is not compatible with configure of hardware!"
},

{
	"ER_LDR_NOTSETTING_BANKINFO",
	E_ERROR | ( 0x405c ),
	"Not setting information of bank in the EPSLD52F.INI !"
},
{
	"ER_CODE_NOT_IN_CODESEG",
	E_ERROR | ( 0x405d ),
	"Download code not in code segment!"
},
{
	"ER_LDR_LOW_ROOT_BANK",
	E_ERROR | ( 0x405E ),
	"Range of common bank should be set larger."
},
{
	"ER_LDR_OUTOF_BANKNUM",
	E_ERROR | ( 0x405F ),
	"Only number of bank lower than %d can be supportted by hardware!"
},
{
	"ER_LDR_RESET_ROOT_BANK",
	E_ERROR | ( 0x4060 ),
	"Start address of your execution code should be larger than top of common bank!"
},
{
	"ER_LDR_CHECK_BANK_SWITCH",
	E_ERROR | ( 0x4061 ),
	"Information of bank switching is included in your loader file!"
},
{
	"ER_SEL_BANK",
	E_ERROR | ( 0x4062 ),
	"Error found when bank is selected!"
},
{
	"ER_LDR_FILE_BANK",
	E_ERROR | ( 0x4063 ),
	"This file contained bank information. Please remove option located to bank area when you load this file!"
},
{
	"ER_JED_STARTFLAG",
	E_ERROR | ( 0x4800 ),
	"Not found start flag in jed file."
},
{
	"ER_JED_QFFLAG",
	E_ERROR | ( 0x4801 ),
	"Not found QF flag in jed file."
},
{
	"ER_JED_ERRQFFLAG",
	E_ERROR | ( 0x4802 ),
	"Invalid QF flag in jed file."
},
{
	"ER_SEG_UNKNOWN",
	( ER_SEG_BASE+ 0),
	"UNKNOWN"
},
{
	"ER_SEG_CODE",
	( ER_SEG_BASE+ 1),
	"CODE"
},
{
	"ER_SEG_XDATA",
	( ER_SEG_BASE+ 2),
	"XDATA"
},
{
	"ER_SEG_DATA",
	( ER_SEG_BASE+ 3),
	"DATA"
},
{
	"ER_SEG_SFR",
	( ER_SEG_BASE+ 4),
	"SFR"
},
{
	"ER_SEG_BIT",
	( ER_SEG_BASE+ 5),
	"BIT"
},
{
	"ER_ICE_OK",
	E_FATAL | ( ER_ICE_OK+0 ) ,
	" ICE ok!",
},
{
	"ER_ICE_FAIL_STEP",
	E_FATAL | ( ER_ICE_OK+1 ),
	" Target cannot step!",
},
{
	"ER_ICE_FAIL_MEM_WRITE",
	E_FATAL | ( ER_ICE_OK+2 ),
	" Memory write failure!",
},
{
	"ER_ICE_FAIL_MAP_INCLUDE",
	E_FATAL | ( ER_ICE_OK+3 ),
	" Map status not included!",
},
{
	"ER_ICE_FAIL_MAP_BOUNDARY",
	E_FATAL | ( ER_ICE_OK+4 ),
	" Map address boundary error!",
},
{
	"ER_ICE_NOT_FOUND",
	E_FATAL | ( ER_ICE_OK+5 ),
	" Can not find any more!",
},
{
	"ER_ICE_FOUND",
	E_FATAL | ( ER_ICE_OK+6 ),
	" Find!",
},
{
	"ER_ICE_TIME_OUT",
	E_FATAL | ( ER_ICE_OK+7 ),
	" Communication failure!",
},
{
	"ER_ICE_PARA_ERROR",
	E_FATAL | ( ER_ICE_OK+8 ),
	" Sended parameters Error!",
},
{
	"ER_ICE_EP_RUNNING",
	E_FATAL | ( ER_ICE_OK+0x10 ),
	" Emulator processor is running!",
},
{
	"ER_ICE_TRACE_RUNNING",
	E_FATAL | ( ER_ICE_OK+0x11 ),
	" Emulator processor is tracing!",
},
{
	"ER_ICE_TRACE_READ_OVER",
	E_FATAL | ( ER_ICE_OK+0x12 ),
	" Reading trace buffer is over!",
},
{
	"ER_ICE_COMMAND_INVALID",
	E_FATAL | ( ER_ICE_OK+0x13 ),
	" Invalid Command!",
},
{
	"ER_ICE_BANK_INIT_ERR",
	E_FATAL | ( ER_ICE_OK+0x20  ),
	"Firmware init bank error."
},
{
	"ER_ICE_BANK_SELECT_ERR",
	E_FATAL | ( ER_ICE_OK+0x21  ),
	"Firmware select bank error(Use wrong bank)."
},
{
	"ER_ICE_BANK_GET_ERR",
	E_FATAL | ( ER_ICE_OK+0x22  ),
	"Firmware get bank error."
},
{
	"ER_ICE_OK_MEM_WRITE",
	E_FATAL | ( ER_ICE_OK+0x24  ),
	"Memory write is OK"
},
{
	"ER_ICE_FLASH_SW_ERROR",
	E_FATAL | ( ER_ICE_OK+0x40 ),
	" Flush EPROM switching error!",
},
{
	"ER_ICE_FLASH_EC_ERROR",
	E_FATAL | ( ER_ICE_OK+0x41 ),
	" Flush EPROM erasing error!",
},
{
	"ER_ICE_FLASH_PRG_ERROR",
	E_FATAL | ( ER_ICE_OK+0x42 ),
	" Flush EPROM programming error!",
},
{
	"ER_ICE_FLASH_REC_ERROR",
	E_FATAL | ( ER_ICE_OK+0x43 ),
	" Flush EPROM recording error!"
},
{
	"ER_ICE_DEFAULT_ERROR",
	E_FATAL | ( ER_ICE_OK+0x50 ),	
	"Something wrong with ICE"
},
{
	"ER_ABI_SET_REG",
	E_FATAL | ( ER_ICE_OK+0x51),
	"Set register value failure!"
},
{
	"ER_ABI_CPUSTATUS",
	E_FATAL | ( ER_ICE_OK+0x52 ),
	"Can not get CPU status"
},
{
	"ER_ABI_MEM_WRITE1",
	E_FATAL | ( ER_ICE_OK+0x53 ),
	"Memory write failure at: %c:%04X."
},

{
	"ER_EMU_INSUFFICIENT_MEMORY",
	E_SEVERE | ( ER_EMU_BASE+0 ),
	"Insufficient Memory !"
},
{
	"ER_EMU_TARGET_CPU_HALT",
	E_INFORMATIVE | ( ER_EMU_BASE+1 ),
	"Target CPU is halted."
},
{
	"ER_EMU_PROGRAM_IS_RUN",
	E_INFORMATIVE | ( ER_EMU_BASE+2 ),
	"Program is running."
},
{
	"ER_EMU_LOAD_FORMAT_ERROR",
	E_ERROR | ( ER_EMU_BASE+3 ),
	"Step load format error."
},
{
	"ER_EMU_DAD_3",
	E_ERROR | ( ER_EMU_BASE+4 ),
	"opcodes haven't any meaning"
},
{
	"ER_EMU_DAD_6",
	E_ERROR | ( ER_EMU_BASE+6 ),
	"invalid cpu mode"
},
{
	"ER_EMU_DAD_7",
	E_ERROR | ( ER_EMU_BASE+7 ),
	" too many char"
},
{
	"ER_EMU_DAD_8",
	E_ERROR | ( ER_EMU_BASE+8 ),
	"invalid convert address from byte to bit"
},
{
	"ER_EMU_DAD_9",
	E_ERROR | ( ER_EMU_BASE+9 ),
	"offset of bit is too large"
},
{
	"ER_EMU_DAD_10",
	E_ERROR | ( ER_EMU_BASE+10 ),
	"unknown offset"
},
{
	"ER_EMU_DAD_11",
	E_ERROR | ( ER_EMU_BASE+11 ),
	". used in byte which can't be addressed in bit"
},
{
	"ER_EMU_DAD_12",
	E_ERROR | ( ER_EMU_BASE+12 ),
	"wrong use of /"
},
{
	"ER_EMU_DAD_13",
	E_ERROR | ( ER_EMU_BASE+13 ),
	"no corresponding in Cmd_51"
},
{
	"ER_EMU_DAD_14",
	E_ERROR | ( ER_EMU_BASE+14 ),
	"have no string"
},
{
	"ER_EMU_DAD_15",
	E_ERROR | ( ER_EMU_BASE+15 ),
	"Relative address is not in range -128 to 127"
},
{
	"ER_EMU_DAD_16",
	E_SEVERE | ( ER_EMU_BASE+16 ),
	"DAD table error,please call vendor!"
},
{
	"ER_EMU_DAD_17",
	E_ERROR | ( ER_EMU_BASE+17 ),
	"wrong address for acall"
},
{
	"ER_EMU_DAD_18",
	E_ERROR | ( ER_EMU_BASE+18 ),
	"too many opcodes"
},
{
	"ER_EMU_DAD_19",
	E_FATAL | ( ER_EMU_BASE+19 ),
	"ICE memory reading or writing error!"
},
{
	"ER_EMU_DAD_20",
	E_ERROR | ( ER_EMU_BASE+20 ),
	"having wrong address comparing to address type"
},
{
	"ER_EMU_DAD_99",
	E_ERROR | ( ER_EMU_BASE+21 ),
	"only one byte is needed!"
},
{
	"ER_EMU_DAD_DEFAULT",
	E_ERROR | ( ER_EMU_BASE+22 ),
	"can not get the correct figure! "
},
{
	"ER_EMU_DAD_SRC_2",
	E_ERROR | ( ER_EMU_BASE+23 ),
	"too many instructions!"
},
{
	"ER_EMU_DAD_SRC_3",
	E_ERROR | ( ER_EMU_BASE+24 ),
	"invalid cpu module!"
},
{
	"ER_EMU_DAD_SRC_6",
	E_ERROR | ( ER_EMU_BASE+25 ),
	"input code length is zero!"
},
{
	"ER_EMU_DAD_SRC_7",
	E_ERROR | ( ER_EMU_BASE+26 ),
	"wrong address !"
},
{
	"ER_EMU_DAD_SRC_105",
	E_FATAL | ( ER_EMU_BASE+27 ),
	"memory reading error!"
},
{
	"ER_EMU_DAD_SRC_DEFAULT",
	E_ERROR | ( ER_EMU_BASE+28 ),
	"DAD error!"
},
{
	"ER_GOFLY_ERR_MSG",
	E_INFORMATIVE | ( ER_EMU_BASE+29 ),
	"EP is running. Please halt CPU first!"	
},	
{
	"ER_DAD_ADDR_LARGE",
	E_ERROR | ( ER_DAD_BASE+ 0 ),
	"Address is larger than maximum code memory address."
},
{
	"ER_DAD_ADDR_LITTLE",
	E_ERROR | ( ER_DAD_BASE+ 1 ),
	"Address is less than minimum code memory address."
},
{
	"ER_DAD_MEM_INVALID_LENGTH",
	E_ERROR | ( ER_DAD_BASE+ 2 ),
	"Disassemble memory length is invalid."
},
{
	"ER_DAD_MEM_INVALID_RANGE",
	E_ERROR | ( ER_DAD_BASE+ 3 ),
	"Disassemble memory range is invalid."
},
{
	"ER_DAD_ABI_GET_MEM",
	E_ERROR | ( ER_DAD_BASE+ 4 ),
	"Read memroy error."
},
{
	"ER_DAD_CPU",
	E_ERROR | ( ER_DAD_BASE+ 5 ),
	"This cpu type is not supported."
},
{
	"ERI_DAD_OP_ADDR_BOUND",
	E_INFORMATIVE | ( ER_DAD_BASE+ 6 ),
	"Address operand is not in current page."
},
{
	"ER_DAD_OP_ADDR_LIMIT",
	E_ERROR | ( ER_DAD_BASE+ 7 ),
	"Address operand must be in lower 255 bytes of the page."
},
{
	"ER_DAD_OP_ADDR_LARGE",
	E_ERROR | ( ER_DAD_BASE+ 8 ),
	"Address operand is too big."
},
{
	"ER_DAD_OP_ADDR_ERROR",
	E_ERROR | ( ER_DAD_BASE+ 9 ),
	"Address operand error."
},
{
	"ER_DAD_OP_DATA_LARGE",
	E_ERROR | ( ER_DAD_BASE+ 10 ),
	"Data operand is too big."
},
{
	"ER_DAD_OP_DATA_ERROR",
	E_ERROR | ( ER_DAD_BASE+ 11 ),
	"Data operand error."
},
{
	"ERI_DAD_OP_REG_BOUND",
	E_INFORMATIVE | ( ER_DAD_BASE+ 12 ),
	"Register operand is not in current bank."
},
{
	"ERI_DAD_OP_ADDR_REG_BOUND",
	E_INFORMATIVE | (ER_DAD_BASE+ 13 ),
	"Address operand is not in current page, register operand is not in current bank."
},
{
	"ER_DAD_OP_REG_ERROR",
	E_ERROR | ( ER_DAD_BASE+ 14 ),
	"Register operand error."   
},
{
	"ER_DAD_OP_BOUND_ERROR",
	E_ERROR | (ER_DAD_BASE+ 15 ),
	"operand is large or little."
},
{
	"ER_DAD_OP_PARA_ERROR",
	E_ERROR | (ER_DAD_BASE+ 16 ),
	"operand is invalid."
},
{
	"ER_DAD_OP_LACK",
	E_ERROR | (ER_DAD_BASE+ 17 ),
	"Need more operand."
},
{
	"ER_DAD_OP_REDUNDANT",
	E_ERROR | (ER_DAD_BASE+ 18 ),
	"Redundant characters are input."    
},
{
	"ER_DAD_OP_INTERNAL_ERROR",
	E_ERROR | (ER_DAD_BASE+ 19 ),
	"DAD internal error."
},
{
	"ER_DAD_INSTRUCT_ERROR",
	E_ERROR | (ER_DAD_BASE+ 20 ),
	"No such assemble instruction." 
},
{
	"ER_DAD_NO_INPUT",
	E_ERROR | (ER_DAD_BASE+ 21 ),
	"No input."
},
{
	"ER_DAD_NO_DAD_TABLE",
	E_ERROR | (ER_DAD_BASE+ 22 ),
	"DAD table is not loaded."
},
{
	"ER_DAD_NO_SFR_TABLE",
	E_ERROR | (ER_DAD_BASE+ 23 ),
	"Special function register table is not loaded."
},
{
	"ER_DAD_LOAD_DA_TABLE",
	E_ERROR | (ER_DAD_BASE+ 24 ),
	"Load DAD instruction table error"
},
{
	"ER_DAD_LOAD_SFR_TABLE",
	E_ERROR | (ER_DAD_BASE+ 25 ),
	"Load DAD special function register table error"
},
{
	"ER_PRE_SEL_REG",
	E_ERROR | ( ER_PRE_BASE+0 ),
	"Must select one register at least!"
},
{
	"ER_PRE_REG_VALUE",
	E_ERROR | ( ER_PRE_BASE+ 1),
	"Invalid register value"
},
{
	"ER_PRE_REG_NOT_EXIST",
	E_ERROR | ( ER_PRE_BASE+2 ),
	"This register does not exist."
},
{
	"ER_PRE_REG_VALUE_OVERFLOW",
	E_ERROR | ( ER_PRE_BASE+3 ),
	"Register Value overflow."
},
{
	"ER_PRE_CPU_SETTING",
	E_ERROR | ( ER_PRE_BASE+4 ),
	"CPU Module setting error, now it is using the default one."
},
{
	"ER_PRE_INVALID_INPUT",
	E_ERROR | ( ER_PRE_BASE+5 ),
	"Your input is not valid!"
},
{
	"ER_PRE_VALUE_TOO_LARGE",
	E_ERROR | ( ER_PRE_BASE+6 ),
	"The value is too large!"
},
{
	"ER_PRE_CPU_NOT_SUPPORT",
	E_ERROR | ( ER_PRE_BASE+7 ),
	"Not Support this CPU! Please contact your provider."
},
{
	"ER_PRE_CPU_NO_INFO",
	E_ERROR | ( ER_PRE_BASE+8 ),
	"No Information for this CPU! Please contact your provider."
},
{
	"ER_PRE_NO_LIBRARY",
	E_ERROR | ( ER_PRE_BASE+9 ),
	"Can not do this test without custom control library!  Please install muscroll.dll"
},
{
	"ER_PRE_PROGRAM_SWITCH",
	E_FATAL | ( ER_PRE_BASE+10 ),
	"Program switched Error !"
},
{
	"ER_PRE_PROGRAM_ERASE",
	E_FATAL | ( ER_PRE_BASE+11 ),
	"Program Erase Error !"
},
{
	"ER_PRE_COMMUNICATION",
	E_FATAL | ( ER_PRE_BASE+12 ),
	"Communication Failue"
},
{
	"ER_PRE_NO_COMPATIBLE_FILE",
	E_ERROR | ( ER_PRE_BASE+13 ),
	"No Compatible file exists. Please install the file in current directory"
},
{
	"ER_PRE_DOWNLOAD",
	E_FATAL | ( ER_PRE_BASE+14 ),
	"DownLoad Error!"
},

{
	"ER_MEMDLG_LENGTH",
	E_ERROR | (ER_MEM_BASE +0 ),
	"Length may not include area define" 
},
{
	"ER_MEMDLG_INPUT",
	E_ERROR | (ER_MEM_BASE +1 ),
	"Input error"
},
{
	"ER_MEMDLG_COPYOVER",
	E_ERROR | (ER_MEM_BASE +2 ),
	"Copy range over flow"
},
{
	"ER_MAPDLG_OPENFILE",
	E_ERROR | (ER_MEM_BASE +3 ),
	"Open map file error"
},
{
	"ER_MAPDLG_ADROVER",
	E_ERROR | (ER_MEM_BASE +4 ),
	"Address over range"
},
{
	"ER_MEM_TEST_OK",
	E_INFORMATIVE | (ER_MEM_BASE + 10 ),
	"Memory test completed - no failure found."
},
{
	"ER_MEM_TEST_ERROR",
	E_ERROR | (ER_MEM_BASE + 11 ),
	"Memory test terminated - failure at %c:%04X."
},
{
	"ER_MEMDLG_ERRSPACE",
	E_ERROR | (ER_MEM_BASE + 12 ),
	"Memory space spedified is not same!"
},
{
	"ER_ADDR_FORMAT",
	E_ERROR | (ER_ADDR_BASE +0 ),
	"The address format is error."
},
{
	"ER_ADDR_INVALID",
	E_ERROR | (ER_ADDR_BASE +1 ),
	"The address include invalid char."
},
{
	"ER_ADDR_OUTRANGE",
	E_ERROR | (ER_ADDR_BASE +2 ),
	"The address is out of range."
},
{
	"ER_ADDR_SYMBOL",
	E_ERROR | (ER_ADDR_BASE +3 ),
	"The symbol is not exist."
},
{
	"ER_ADDR_COMPARE",
	E_ERROR | (ER_ADDR_BASE +4 ),
	"Invalid address range."
},
{
	"ER_ADDR_OVERFLOW",
	E_ERROR | (ER_ADDR_BASE +5 ),
	"The address is overflow."
},
{
	"ER_ADDR_EMPTY",
	E_ERROR | (ER_ADDR_BASE +6 ),
	"The address string is empty."
},
{
	"ER_ADDR_DEFAULT",
	E_ERROR | (ER_ADDR_BASE +7 ),
	"The address is error."
},
{
	"ER_ADDR_BANKERROR",
	E_ERROR | (ER_ADDR_BASE +8 ),
	"The address bank is error."
},
{
	"ER_ADDR_NOBANK",
	E_ERROR | (ER_ADDR_BASE +9 ),
	"The FW not support bank switch."
},
{
	"ER_TRCGRP_ADDR1_ERR",
	E_ERROR | ( ER_TRC_BASE+0 ),
	"Start Addr Input Error"
}, 
{
	"ER_TRCGRP_ADDR2_ERR",
	E_ERROR | ( ER_TRC_BASE+1 ),
	"End Addr Input Error"
}, 
{
	"ER_TRCGRP_ADDR_ORDER",
	E_ERROR | ( ER_TRC_BASE+2 ),
	"End Addr must great than Start Addr"
}, 
{
	"ER_TRCGRP_ADDR1_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+3 ),
	"Start Addr Out of Program Ram Range"
}, 
{
	"ER_TRCGRP_ADDR2_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+4 ),
	"End Addr Out of Program Ram Range"
}, 
{
	"ER_TRCGRP_ADDR_TOOMUCH",
	E_ERROR | ( ER_TRC_BASE+5 ),
	"Addr Number not in range 1 to 10"
}, 
{
	"ER_TRCGRPF_ADDR_ERR",
	E_ERROR | ( ER_TRC_BASE+6 ),
	"Addr%d Input Error"
}, 
{
	"ER_TRCGRPF_ADDR_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+7 ),
	"Addr%d Out of Program Ram Range"
}, 
{
	"ER_TRCGRP_DATA1_NOWILD",
	E_ERROR | ( ER_TRC_BASE+8 ),
	"You should use Multiple mode"
}, 
{
	"ER_TRCGRP_DATA1_ERR",
	E_ERROR | ( ER_TRC_BASE+9 ),
	"Start Data input Error"
}, 
{
	"ER_TRCGRP_DATA2_ERR",
	E_ERROR | ( ER_TRC_BASE+10 ),
	"End Data Input Error"
}, 
{
	"ER_TRCGRP_DATA1_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+11 ),
	"Start Data not in range 0 to 0xFFFF"
}, 
{
	"ER_TRCGRP_DATA2_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+12 ),
	"End Data not in range 0 to 0xFFFF"
}, 
{
	"ER_TRCGRP_DATA_ORDER",
	E_ERROR | ( ER_TRC_BASE+13 ),
	"End Data must great than Start Data"
}, 
{
	"ER_TRCGRP_COUNT_ERR",
	E_ERROR | ( ER_TRC_BASE+14 ),
	"Count Input Error"
}, 
{
	"ER_TRCGRP_NONEINPUT",
	E_ERROR | ( ER_TRC_BASE+15 ),
	"You Must Input Something!"
//	"Error: You Must Input Something!"
},
{
	"ER_TRCGRPF_EV_SETERROR",
	E_ERROR | ( ER_TRC_BASE+16 ),
	"Event %d Set Error!"
},
{
	"ER_TRCGRPF_LV_SETERROR",
	E_ERROR | ( ER_TRC_BASE+17 ),
	"Level %d Set Error!"
},
{
	"ER_TRCGRP_TRIGGER_SETERROR",
	E_ERROR | ( ER_TRC_BASE+18 ),
	"Trigger Set Error!"
},
{
	"ER_TRCGRP_QUALIFY_SETERROR",
	E_ERROR | ( ER_TRC_BASE+19 ),
	"Qualify Set Error!"
},
{
	"ER_TRCGRP_ADDR_INVALIDCHAR",
	E_ERROR | ( ER_TRC_BASE+20 ),
	"Address include invalid char"
},
{
	"ER_TRCSVR_LOADSRC",
	E_ERROR | ( ER_TRC_BASE+21 ),
	"Please load source first."
},
{
	"ER_TRCSVR_INITTRACEERR",
	E_ERROR | ( ER_TRC_BASE+22 ),
	"Trace init failure!"
},
{
	"ER_TRCSVR_INITTIMERERR",
	E_ERROR | ( ER_TRC_BASE+23 ),
	"Timer init failure!"
},
{
	"ER_TRCSVR_GETERROR1",
	E_ERROR | ( ER_TRC_BASE+24 ),
	"Unable get trace and timer info from FW"
},
{
	"ER_TRCSVR_GETETIMEERR",
	E_ERROR | ( ER_TRC_BASE+25 ),
	"Cannot get time from FW!"
},
{
	"ER_FW_ISOLD",
	E_ERROR | ( ER_TRC_BASE+26 ),
	"Firmware version is too old"
},
{
	"ER_TRCGRP_DATA_ERR",
	E_ERROR | ( ER_TRC_BASE+27 ),
	"Data Input Error"
}, 
{
	"ER_TRCGRP_ADDR_ERR",
	E_ERROR | ( ER_TRC_BASE+28 ),
	"Addr Input Error"
}, 
{
	"ER_TRCGRP_DATA_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+29 ),
	"Data not in range 0 to 0xFFFF"
}, 
{
	"ER_TRCGRP_ADDR_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+30 ),
	"Addr Out of Program Ram Range"
}, 
{
	"ER_TRCGRP_COUNT_OUTRANGE",
	E_ERROR | ( ER_TRC_BASE+31 ),
	"Count Out of Range"
}, 
{
	"ER_SPA_BASE",
	E_INFORMATIVE | ( ER_SPA_BASE + 0),
	"SPA command is OK."
}, 
{
	"ER_SPA_DEBUG",
	E_INFORMATIVE | ( ER_SPA_BASE + 1),
	"SPA is in debug mode."
}, 
{
	"ER_SPA_EMPTY",
	E_ERROR | ( ER_SPA_BASE + 2),
	"Input empty."
}, 
{
	"ER_SPA_NO_DELIMIT",
	E_ERROR | ( ER_SPA_BASE + 3),
	"The module range setting is invalid."
}, 
{
	"ER_SPA_INPUT",
	E_ERROR | ( ER_SPA_BASE + 4),
	"Invalid input."
}, 
{
	"ER_SPA_EXIST",
	E_ERROR | ( ER_SPA_BASE + 5),
	"The same module range setting exists."
}, 
{
	"ER_SPA_FILE",
	E_ERROR | ( ER_SPA_BASE + 6),
	"Cannot open the data file."
}, 
{
	"ER_SPA_MEMORY",
	E_ERROR | ( ER_SPA_BASE + 7),
	"Insufficient memory."
}, 
{
	"ER_SPA_RANGE",
	E_ERROR | ( ER_SPA_BASE + 8),
	"Module range is invalid."
}, 
{
	"ER_SPA_TIMER",
	E_ERROR | ( ER_SPA_BASE + 9),
	"System timer setting is invalid."
}, 
{
	"ER_SPA_ABI",
	E_ERROR | ( ER_SPA_BASE + 10),
	"Wait a moment, please."
}, 
{
	"ER_SPA_NO_COVERAGE",
	E_ERROR | ( ER_SPA_BASE + 11),
	"No coverage information about the current setting."
},
 
{
	"ER_TST_BASE",
	E_ERROR | ( ER_TST_BASE + 0  ),
	"No Error"
},
{
	"ER_TST_LOG_EXIST",
	E_ERROR | ( ER_TST_BASE +  1 ),
	"Log file existed already."
},
{
	"ER_TST_LOG_UNOPEN",
	E_ERROR | ( ER_TST_BASE +  2 ),
	"No Log file opened."
},
{
	"ER_TST_OPEN_ERROR",
	E_ERROR | ( ER_TST_BASE +  3 ),
	"File open error."
},
{
	"ER_TST_CLOSE_ERROR",
	E_ERROR | ( ER_TST_BASE +  4 ),
	"File close error."
},
{
	"ER_TST_READ_ERROR",
	E_ERROR | ( ER_TST_BASE +  5 ),
	"File read error."
},
{
	"ER_TST_WRITE_ERROR",
	E_ERROR | ( ER_TST_BASE +  6 ),
	"File write error."
},
{
	"ER_TST_FILE_END",
	E_INFORMATIVE | ( ER_TST_BASE +  7 ),
	"End of Include file."
},
{
	"ER_TST_LONG_LINE",
	E_ERROR | ( ER_TST_BASE +  8 ),
	"More than 255 characters in one line."
},
{
	"ER_TST_NOT_INNER",
	E_ERROR | ( ER_TST_BASE +  9 ),
	"Not an Include inner command."
},
{
	"ER_TST_INNER_ERROR",
	E_ERROR | ( ER_TST_BASE +  10 ),
	"Include sub-command error."
},
{
	"ER_TST_INNER_SYNTAX",
	E_ERROR | ( ER_TST_BASE +  11 ),
	"Include sub-command error: Syntax error."
},
{
	"ER_TST_INNER_COUNT",
	E_ERROR | ( ER_TST_BASE +  12 ),
	"Include sub-command error: Invalid COUNT."
},
{
	"ER_TST_INNER_LABEL",
	E_ERROR | ( ER_TST_BASE +  13 ),
	"Include sub-command error: Invalid LABEL."
},
{
	"ER_TST_INNER_GOTO",
	E_ERROR | ( ER_TST_BASE +  14 ),
	"Include sub-command error: LABEL cannot matched."
},
{
	"ER_TST_INNER_LOOP",
	E_ERROR | ( ER_TST_BASE +  15 ),
	"Include sub-command error: More than 256 LOOP nested."
},
{
	"ER_TST_INNER_LOOPEND",
	E_ERROR | ( ER_TST_BASE +  16 ),
	"Include sub-command error: Invalid LOOPEND."
},
{
	"ER_TST_INNER_IF",
	E_ERROR | ( ER_TST_BASE +  17 ),
	"Include sub-command error: IF,IF_NOT & ELSE statement cannot nest."
},
{
	"ER_TST_INNER_ELSE",
	E_ERROR | ( ER_TST_BASE +  18 ),
	"Include sub-command error: ELSE without IF or IF_NOT statement."
},
{
	"ER_TST_INNER_BEGIN",
	E_ERROR | ( ER_TST_BASE +  19 ),
	"Include sub-command error: No expected {."
},
{
	"ER_TST_INNER_END",
	E_ERROR | ( ER_TST_BASE +  20 ),
	"Include sub-command error: No expected }."
},
{
	"ER_TST_INNER_MATCH",
	E_ERROR | ( ER_TST_BASE +  21 ),
	"Include sub-command error: { and } unmatched."
},
{
	"ER_TST_INNER_ESC",
	E_ERROR | ( ER_TST_BASE +  22 ),
	"Abort by user."
},
{
	"ER_TST_DELETE_MACRO_ERROR",
	E_ERROR | ( ER_TST_BASE +  23 ),
	"The macro is not exist."
},
{
	"ER_TST_MACRO_FILE_END",
	E_INFORMATIVE | ( ER_TST_BASE +  24 ),
	"End of Macro file."
},
{
	"ER_TST_NOT_MACRO_INNER",
	E_ERROR | ( ER_TST_BASE +  25 ),
	"Not a Macro inner command."
},
{
	"ER_TST_INNER_MACRO_ERROR",
	E_ERROR | ( ER_TST_BASE +  26 ),
	"Macro sub-command error."
},
{
	"ER_TST_INNER_MACRO_SYNTAX",
	E_ERROR | ( ER_TST_BASE +  27 ),
	"Macro sub-command error: Syntax error."
},
{
	"ER_TST_INNER_MACRO_IF",
	E_ERROR | ( ER_TST_BASE +  28 ),
	"Macro sub-command error: IF,IF_NOT & ELSE statement cannot nest."
},
{
	"ER_TST_INNER_MACRO_ELSE",
	E_ERROR | ( ER_TST_BASE +  29 ),
	"Macro sub-command error: ELSE without IF or IF_NOT statement."
},
{
	"ER_TST_INNER_MACRO_BEGIN",
	E_ERROR | ( ER_TST_BASE +  30 ),
	"Macro sub-command error: No expected {."
},
{
	"ER_TST_INNER_MACRO_END",
	E_ERROR | ( ER_TST_BASE +  31 ),
	"Macro sub-command error: No expected }."
},
{
	"ER_TST_INNER_MACRO_MATCH",
	E_ERROR | ( ER_TST_BASE +  32 ),
	"Macro sub-command error: { and } unmatched.",
},
{
	"ER_TST_INNER_MACRO_ESC",
	E_ERROR | ( ER_TST_BASE +  33 ),
	"Abort by user."
},
{
	"ER_TST_INNER_MACRO_COUNT",
	E_ERROR | ( ER_TST_BASE +  34 ),
	"Macro sub-command error: Invalid COUNT."
},
{
	"ER_TST_INNER_MACRO_LABEL",
	E_ERROR | ( ER_TST_BASE +  35 ),
	"Macro sub-command error: Invalid LABEL."
},
{
	"ER_TST_INNER_MACRO_GOTO",
	E_ERROR | ( ER_TST_BASE +  36 ),
	"Macro sub-command error: LABEL cannot matched."
},
{
	"ER_TST_INNER_MACRO_LOOP",
	E_ERROR | ( ER_TST_BASE +  37 ),
	"Macro sub-command error: More than 256 LOOP nested."
},
{
	"ER_TST_INNER_MACRO_LOOPEND",
	E_ERROR | ( ER_TST_BASE +  38 ),
	"Macro sub-command error: Invalid LOOPEND."
},
{
	"ER_SYN_BASE",
	E_ERROR | ( ER_SYN_BASE + 0 ),
	"No Error"
},
{
	"ER_SYN_NO_SUCH_COMMAND",
	E_ERROR | ( ER_SYN_BASE + 3 ),
	"No such command."
},
{
	"ER_SYN_SYNTAX_ERROR",
	E_ERROR | ( ER_SYN_BASE + 4 ),
	"Syntax error."
},
{
	"ER_SYN_ADDR_OUT_OF_RANGE",
	E_ERROR | ( ER_SYN_BASE + 5 ),
	"The address is out of range."
},
{
	"ER_SYN_LEN_OUT_OF_RANGE",
	E_ERROR | ( ER_SYN_BASE + 6 ),
	"The length is out of range."
},
{
	"ER_SYN_LEN_ERROR",
	E_ERROR | ( ER_SYN_BASE + 7 ),
	"The length is invalid."
},
{
	"ER_SYN_ADDR_ERROR",
	E_ERROR | ( ER_SYN_BASE + 8 ),
	"The address includes invalid char."
},
{
	"ER_SYN_ADDR_TYPE_ERROR",
	E_ERROR | ( ER_SYN_BASE + 9 ),
	"The address type is error."
},
{
	"ER_SYN_ADDR_MAP_ERROR",
	E_ERROR | ( ER_SYN_BASE + 10 ),
	"Map address boundary error."
},
{
	"ER_SYN_MAP_ATTR_ERROR",
	E_ERROR | ( ER_SYN_BASE + 11 ),
	"The map attribute is error."
},
{
	"ER_SYN_REG_ERROR",
	E_ERROR | ( ER_SYN_BASE + 12 ),
	"The register name is invalid."
},
{
	"ER_SYN_DATA_OUT_OF_RANGE",
	E_ERROR | ( ER_SYN_BASE + 13 ),
	"The data is out of range."
},
{
	"ER_SYN_DATA_ERROR",
	E_ERROR | ( ER_SYN_BASE + 14 ),
	"The data is invalid."
},
{
	"ER_SYN_FILE_NAME_ERROR",
	E_ERROR | ( ER_SYN_BASE + 15 ),
	"The file name is invalid."
},
{
	"ER_SYN_MODULE_NAME_ERROR",
	E_ERROR | ( ER_SYN_BASE + 16 ),
	"The module name is invalid."
},
{
	"ER_SYN_VARIABLE_NAME_ERROR",
	E_ERROR | ( ER_SYN_BASE + 17 ),
	"The variable name is invalid."
},
{
	"ER_SYN_SYMBOL_NAME_ERROR",
	E_ERROR | ( ER_SYN_BASE + 18 ),
	"The symbol name is invalid."
},
{
	"ER_SYN_COUNT_ERROR",
	E_ERROR | ( ER_SYN_BASE + 19 ),
	"The count is invalid."
},
{
	"ER_SYN_COUNT_OUT_OF_RANGE",
	E_ERROR | ( ER_SYN_BASE + 20 ),
	"The count is out of range."
},
{
	"ER_SYN_PORT_ERROR",
	E_ERROR | ( ER_SYN_BASE + 21 ),
	"The port is invalid."
},
{
	"ER_SYN_ADDR_FORMATERROR",
	E_ERROR | ( ER_SYN_BASE + 22 ),
	"The address format is error."
},
{
	"ER_SYN_ADDR_NOSYMBOL",
	E_ERROR | ( ER_SYN_BASE + 23 ),
	"The symbol doesn't exist."
},
{
	"ER_SYN_ADDR_COMPERROR",
	E_ERROR | ( ER_SYN_BASE + 24 ),
	"The second address is less than first."
},
{
	"ER_SYN_ADDR_OVERFLOW",
	E_ERROR | ( ER_SYN_BASE + 25 ),
	"The address text string is overflow."
},
{
	"ER_SYN_ADDR_EMPTY",
	E_ERROR | ( ER_SYN_BASE + 26 ),
	"The address text string is empty."
},
{
	"ER_SYN_STATUS_ERROR",
	E_ERROR | ( ER_SYN_BASE + 27 ),
	"The status is error."
},
{
	"ER_SYN_ADDR_SFR_RANGE",
	E_ERROR | ( ER_SYN_BASE + 28 ),
	"The address bank is error."
},

{
	"ER_SYN_COMMAND_NOT_FIND",
	E_ERROR | ( ER_SYN_BASE + 50 ),
	"old command not find"
},
{
	"ER_SYN_NOT_HAVE_ALIAS",
	E_ERROR | ( ER_SYN_BASE + 51 ),
	"@ or $ command cannot have alias"
},
{
	"ER_SYN_ALIAS_LEN_20",
	E_ERROR | ( ER_SYN_BASE + 52 ),
	"alias name must less than 20 characters"
},
{
	"ER_SYN_ALIAS_DIFFERENT",
	E_ERROR | ( ER_SYN_BASE + 53 ),
	"alias name must be different from basic command name"
},
{
	"ER_SYN_ALIAS_EXIST",
	E_ERROR | ( ER_SYN_BASE + 54 ),
	"alias name is already exist"
},

{
	"ER_ID_SYM_NOT_EXIST",
	E_ERROR | ( ER_SYM_BASE + 0 ),
	"This symbol does not exist."
},
{
	"ER_ID_SYM_ADDR_TO_SYM",
	E_ERROR | ( ER_SYM_BASE + 1 ),
	"This address can not query symbol."
},
{
	"ER_ID_STK_BASE",
	E_ERROR | ( ER_STK_BASE ),
	"OK"
},
{
	"ER_ID_STK_BASE1",
	E_ERROR | ( ER_STK_BASE + 1 ),
	"Insufficient memory."
},
{
	"ER_ID_STK_BASE2",
	E_ERROR | ( ER_STK_BASE + 2 ),
	"Cannot load bitmap for the variable window."
},
{
	"ER_ID_STK_BASE3",
	E_ERROR | ( ER_STK_BASE + 3 ),
	"Invalid trace back level."
},  
{
	"ER_ID_STK_BASE4",
	E_ERROR | ( ER_STK_BASE + 4 ),
	"Error status."
},
{
	"ER_ID_VAR_BASE",
	E_ERROR | ( ER_VAR_BASE ),
	"OK"
},
{
	"ER_ID_VAR_BASE1",
	E_ERROR | ( ER_VAR_BASE + 1 ),
	"Insufficient memory."
},
{
	"ER_ID_VAR_BASE2",
	E_ERROR | ( ER_VAR_BASE + 2 ),
	"Cannot load bitmap for the Variable window."
},
{
	"ER_ID_VAR_BASE3",
	E_ERROR | ( ER_VAR_BASE + 3 ),
	"Error status."
},
{
	"ER_ID_EXP_INIT_ERR",
	E_ERROR | ( ER_VAR_BASE + 4 ),
	"C Expression initialize error."
},
{
	"ER_ID_EXP_SYNTAX_ERR",
	E_ERROR | ( ER_VAR_BASE + 5 ),
	"C Expression syntax error."
},
{
	"ER_ID_EXP_CALC_ERR",
	E_ERROR | ( ER_VAR_BASE + 6 ),
	"C Expression calculate error."
},
{
	"ER_ID_EXP_SHELL_SYNTAX_ERR",
	E_ERROR | ( ER_VAR_BASE + 8 ),
	"syntax error."
},
{
	"ER_ID_EXP_SET_PC",
	E_ERROR | ( ER_VAR_BASE + 9 ),
	"$PC can not be set value."
},
{
	"ER_EXP_OK",
	E_ERROR | ( ER_VAR_BASE + 10 ),	
	"no error"
},
{
	"ER_EXP_OK1",
	E_ERROR | ( ER_VAR_BASE + 11 ),	
	"Memory Alloc Failure."
},
{
	"ER_EXP_OK2" ,
	E_ERROR | ( ER_VAR_BASE + 12 ),	
	"Expression is empty."
},
{
	"ER_EXP_OK3",
	E_ERROR | ( ER_VAR_BASE + 13 ),	
	"Input parameters Error."
},
{
	"ER_EXP_OK4",
	E_ERROR | ( ER_VAR_BASE + 14 ),	
	"Token is Empty."
},
{
	"ER_EXP_OK5",
	E_ERROR | ( ER_VAR_BASE + 15 ),	
	"Not find required token."
},
{
	"ER_EXP_OK6" ,
	E_ERROR | ( ER_VAR_BASE + 16 ),	
	"invalid token."
},
{
	"ER_EXP_OK7",
	E_ERROR | ( ER_VAR_BASE + 17 ),	
	"invalid symbol token."
},
{
	"ER_EXP_OK8",
	E_ERROR | ( ER_VAR_BASE + 18 ),	
	"C expression syntax error."
},
{
	"ER_EXP_OK9",
	E_ERROR | ( ER_VAR_BASE + 19 ),	
	"stack operate error !"
},
{
	"ER_EXP_OK10",
	E_ERROR | ( ER_VAR_BASE + 20 ),	
	"c expression calculate run time error!"
},
{
	"ER_EXP_OK11",
	E_ERROR | ( ER_VAR_BASE + 21 ),	
	"operand type error"
},
{
	"ER_EXP_OK12",
	E_ERROR | ( ER_VAR_BASE + 22 ),	
	"convert operand failure "
},
{
	"ER_EXP_OK13",
	E_ERROR | ( ER_VAR_BASE + 23 ),	
	"division by 0"
},
{
	"ER_EXP_OK14",
	E_ERROR | ( ER_VAR_BASE + 24 ),	
	"Read Memory Failure -- Please check communication!"
},
{
	"ER_EXP_OK15",
	E_ERROR | ( ER_VAR_BASE + 25 ),	
	"Write Memory Failure -- Please check communication!"
},
{
	"ER_EXP_OK16",
	E_ERROR | ( ER_VAR_BASE + 26 ),	
	"array size overflow."
},

/* - STOP - DO NOT ADD ANY ERROR CODE TO THIS FILE
**
** If you remove any error code form this file please put the error number
** in the list below so that the next person can reuse it.
**
** REUSABLE ERRORCODE:
**
**
*/

/***************************** EOF *****************************************/
