TsplUtil.c 、、、、、、、、、、、、、、、、、、、、
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPLUTIL_C
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include "Common.h"
#include "XCore.h"
#include "Expr.h"
#include "Error.h"
#include "VarMgr.h"
#include "TsplFunc.h"
#include "TsplUtil.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(TSPL)
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
/******************************************************************************
*
* Function:
*
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
STATIC BOOL CheckUnit(CHAR *pToken, CONST CHAR *pUnit)
{
INT TokLen = strlen(pToken);
INT UnitLen = strlen(pUnit);
INT Sch;
while (TokLen && CheckChar(*(pToken + TokLen - 1), " \t"))
TokLen -= 1;
if (TokLen > UnitLen && memcmp(pToken + TokLen - UnitLen, pUnit, UnitLen) == 0)
{
for (Sch = TokLen - UnitLen; --Sch && isdigit(*(pToken + Sch)););
if (isdigit(*(pToken + Sch)) || CheckChar(*(pToken + Sch), " \t+-\x2a/<>=()\""))
{
*(pToken + TokLen - UnitLen) = '\0';
return TRUE;
}
}
return FALSE;
}
//
BOOL GetExpToken(_eTokenEndMode Mode, CHAR *pToken, INT Limit)
{
CHAR TempBuf[5];
CHAR Temp;
CHAR EndChar;
INT BraceNumber;
INT Len;
RemoveSpace();
Len = 0;
while (Len < Limit - 1)
{
Len += GetToken(pToken + Len, &EndChar, " \t\"\r\n\x0c\x1a,;(", Limit - Len);
if (EndChar == '(')
{
BraceNumber = 1;
if (Len < Limit - 1)
*(pToken + Len++) = EndChar;
while (Len < Limit - 1)
{
Len += GetToken(pToken + Len, &EndChar, "\"\r\n()", Limit - Len);
if (EndChar == '(')
{
BraceNumber += 1;
if (Len < Limit - 1)
*(pToken + Len++) = EndChar;
}
else if (EndChar == ')')
{
BraceNumber -= 1;
if (Len < Limit - 1)
*(pToken + Len++)= EndChar;
if (BraceNumber == 0)
break;
}
else if (EndChar == '"')
{
if (Len < Limit - 1)
*(pToken + Len++)= EndChar;
while (Len < Limit - 1)
{
Len += GetToken(pToken + Len, &EndChar, "\"\r\n", Limit - Len);
if (EndChar == '"')
{
if (Len < Limit - 1)
*(pToken + Len++)= EndChar;
Temp = NextByte();
BackByte(Temp);
strncpy(TempBuf, pToken + Len - 3 , 3);
TempBuf[3] = Temp;
if (strncmp(TempBuf, "\\[\"]", 4))
break;
}
else
{
BackByte(EndChar);
return FALSE;
}
}
}
else
{
BackByte(EndChar);
return FALSE;
}
}
}
if (EndChar == '"')
{
if (Len < Limit - 1)
*(pToken + Len++) = EndChar;
while (Len < Limit - 1)
{
Len += GetToken(pToken + Len, &EndChar, "\"\r\n", Limit - Len);
if (EndChar == '"')
{
if (Len < Limit - 1)
*(pToken + Len++) = EndChar;
Temp = NextByte();
BackByte(Temp);
strncpy(TempBuf, pToken + Len - 3 , 3);
TempBuf[3] = Temp;
if (strncmp(TempBuf, "\\[\"]", 4))
{
if (Mode == STRING_END)
return TRUE;
break;
}
}
else if (Limit < LONG_STR_LEN)
{
BackByte(EndChar);
return FALSE;
}
else if (Len < Limit - 1)
*(pToken + Len++) = EndChar;
}
}
else if (CheckChar(EndChar, " \t"))
{
if (Mode == SPACE_END || Mode == BACK_WITH_SPACE)
break;
if (Len < Limit - 1)
*(pToken + Len++) = EndChar;
}
else if (CheckChar(EndChar, "\r\n\x0c\x1a,;"))
break;
}
if (Len == 0)
{
BackByte(EndChar);
return FALSE;
}
if (!CheckTokenEnd(Mode, EndChar))
return FALSE;
// remove last space
while (CheckChar(*(pToken + Len - 1), " \t") && Len)
*(pToken + (--Len)) = '\0';
return TRUE;
}
///
BOOL GetExpSize(_eTokenEndMode Mode, DOUBLE *pSize)
{
CHAR Token[STRING_LEN];
BYTE *pExp;
FLOAT Unit;
if (!GetExpToken(Mode, Token, sizeof(Token)))
return FALSE;
Unit = TPH_DPI;
if (CheckUnit(Token, "mm"))
Unit = MM_DOT;
else if (CheckUnit(Token, "dot"))
Unit = (FLOAT)1;
pExp = (BYTE *)Token;
expMain(&pExp);
if (wErrorword != NO_ERROR || bExpKind != DOUBLE_TYPE)
return FALSE;
*pSize = dRetVal * Unit;
return TRUE;
}
//
/*这是一个函数,名为GetExpNumber。该函数用于获取表达式的数值,并将结果存储到指定的内存中。它会先获取表达式的标记,然后调用expMain函数进行计算,最后将结果赋值给指定的指针
参数作用:函数接受两个参数:_eTokenEndMode Mode表示表达式的结束模式,DOUBLE *pNumber是一个指向DOUBLE类型的指针,用于存储获取到的数值。
首先,函数声明了一个字符数组Token,用于存储获取到的表达式标记。然后,定义了一个BYTE类型的指针pExp,用于指向Token数组。
接下来,通过调用GetExpToken函数,将Mode和Token作为参数,获取表达式的标记并存储到Token数组中。如果获取失败,则返回FALSE。
然后,将pExp转换为BYTE类型的指针,并调用expMain函数,对表达式进行解析和计算。如果出现错误或者表达式的类型不是DOUBLE_TYPE(双精度浮点数),则返回FALSE。
最后,将计算得到的结果dRetVal赋值给pNumber指针所指向的内存,并返回TRUE,表示获取数值成功。
*/
//
BOOL GetExpNumber(_eTokenEndMode Mode, DOUBLE *pNumber)
{
CHAR Token[STRING_LEN];
BYTE *pExp;
if (!GetExpToken(Mode, Token, sizeof(Token)))
return FALSE;
pExp = (BYTE *)Token;
expMain(&pExp);
if (wErrorword != NO_ERROR || bExpKind != DOUBLE_TYPE)
return FALSE;
*pNumber = dRetVal;
return TRUE;
}
//
BOOL GetExpString(_eTokenEndMode Mode, CHAR *pString, INT Limit)
{
CHAR Token[STRING_LEN];
BYTE *pExp;
*pString = '\0';
if (!GetExpToken(Mode, Token, sizeof(Token)))
return FALSE;
pExp = (BYTE *)Token;
expMain(&pExp);
if (wErrorword != NO_ERROR || bExpKind != STRING_TYPE)
return FALSE;
if (strlen((CHAR *)szRetStr) >= Limit)
return FALSE;
strncpy(pString, (CHAR *)szRetStr, Limit);
return TRUE;
}
INT GetExpParam(_eTokenEndMode Mode, _ExpParam *Param, CHAR *Token, INT Limit)
{
BYTE *pExp;
if (!GetExpToken(Mode, Token, Limit))
return EXP_PARAM_ERROR;
pExp = (BYTE *)Token;
expMain(&pExp);
if (wErrorword != NO_ERROR)
return EXP_PARAM_ERROR;
if (bExpKind == DOUBLE_TYPE)
{
Param->Number = dRetVal;
return EXP_PARAM_NUMBER;
}
if (bExpKind == STRING_TYPE)
{
Param->String = (CHAR *)szRetStr;
Param->Counter = bCounterUse;
return EXP_PARAM_STRING;
}
return EXP_PARAM_ERROR;
}
BOOL GetOptParam(_eTokenEndMode Mode, CHAR *Keyword, CHAR *Parament, DOUBLE *pNumber)
{
CHAR data;
RemoveSpace();
data = NextByte();
if (CheckChar(data, Keyword))
{
*Parament = data;
return GetExpNumber(Mode, pNumber);
}
// if doesn't match
else
{
BackByte(data);
return FALSE;
}
}
BOOL GetFileDevice(_eFileDevice *device)
{
CHAR data;
RemoveSpace();
data = NextByte();
if (data == 'F')
{
*device = FLASH_DEVICE;
RemoveSpace();
data = NextByte();
if (!CheckTokenEnd(COMMA_END, data))
return FALSE;
}
else if (data == 'E')
{
*device = CARD_DEVICE;
RemoveSpace();
data = NextByte();
if (!CheckTokenEnd(COMMA_END, data))
return FALSE;
}
else
{
*device = DRAM_DEVICE;
BackByte(data);
}
return TRUE;
}
BOOL SetEquation(INT Type, BYTE *pToken, VOID *Content)
{
BYTE *pExp = (BYTE *)Content;
BYTE *pString = (BYTE *)Content;
DOUBLE Value = *(DOUBLE *)Content;
WORD VarID;
if (Type == EQU_EXPRESSION)
{
expMain(&pExp);
if (wErrorword != NO_ERROR)
return FALSE;
if (bExpKind == STRING_TYPE)
Type = EQU_STRING;
pString = szRetStr;
Value = dRetVal;
}
if (VarID = CheckGlobalVariable(pToken))
{
if (Type == EQU_STRING)
SetGlobalVariable(VarID, atof((CHAR *)pString));
else
SetGlobalVariable(VarID, Value);
return TRUE;
}
switch (CheckVariableType(pToken))
{
case FLOAT_TYPE:
if ((VarID = CheckFloatVariable(pToken)) == 0 &&
(VarID = AddFloatVariable(pToken)) == 0)
return FALSE;
if (Type == EQU_STRING)
return FALSE;
SetFloatVariable(VarID, (FLOAT)Value);
break;
case INTEGER_TYPE:
if ((VarID = CheckIntegerVariable(pToken)) == 0 &&
(VarID = AddIntegerVariable(pToken)) == 0)
return FALSE;
if (Type == EQU_STRING)
return FALSE;
SetIntegerVariable(VarID, (LONG)Value);
break;
case STRING_TYPE:
if ((VarID = CheckStringVariable(pToken)) == 0 &&
(VarID = AddStringVariable(pToken)) == 0)
return FALSE;
if (Type != EQU_STRING)
return FALSE;
SetStringVariable(VarID, pString);
break;
case DOUBLE_TYPE:
if ((VarID = CheckDoubleVariable(pToken)) == 0 &&
(VarID = AddDoubleVariable(pToken)) == 0)
return FALSE;
if (Type == EQU_STRING)
return FALSE;
SetDoubleVariable(VarID, Value);
break;
}
return TRUE;
}
#endif
TsplUtil.h 、、、、、、、、、、、、、、、、、、、、、、
#ifndef TSPLUTIL_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define TSPLUTIL_H
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include "..\ParserUtil.h"
#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */
/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/
#define EXP_PARAM_ERROR 0
#define EXP_PARAM_STRING 1
#define EXP_PARAM_NUMBER 2
#define EQU_EXPRESSION 0
#define EQU_STRING 1
#define EQU_NUMBER 2
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
typedef struct
{
DOUBLE Number;
CHAR *String;
BOOL Counter;
} _ExpParam;
/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/
#ifdef TSPLUTIL_C
#define EXTERN
#else
#define EXTERN extern
#endif
/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
BOOL GetExpToken(_eTokenEndMode, CHAR *, INT);
BOOL GetExpSize(_eTokenEndMode, DOUBLE *);
BOOL GetExpNumber(_eTokenEndMode, DOUBLE *);
BOOL GetExpString(_eTokenEndMode, CHAR *, INT);
INT GetExpParam(_eTokenEndMode, _ExpParam *, CHAR *, INT);
BOOL GetOptParam(_eTokenEndMode, CHAR *, CHAR *, DOUBLE *);
BOOL GetFileDevice(_eFileDevice *);
BOOL SetEquation(INT, BYTE *, VOID *);
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
VarMgr.c /
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define VARMGR_C
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#include "Common.h"
#include "XNutOS.h"
#include "XRTC.h"
#include "XLED.h"
#include "XKey.h"
#include "XGPIO.h"
#include "XPrtEng.h"
#include "XAppVer.h"
#include "XVarBank.h"
#include "XFileSys.h"
#include "XFunction.h"
#include "..\ParserUtil.h"
#include "expr.h"
#include "exputil.h"
#include "VarMgr.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
#if defined(TSPL)
/*-----------------09-07-98 09:37-------------------
define variable total
--------------------------------------------------*/
#define KEEP_COUNTER_MAX 10
#define COUNTER_MAX 51
#if defined(AT91SAM9260)
#define STRING_MAX 200
#else
#define STRING_MAX 50
#endif
#define VAR_MAX 200
#define DOUBLE_MAX 100
#define GLOBAL_MAX (sizeof(GlobalName) / sizeof(BYTE *))
#define CONST_STRING_MAX (sizeof(ConstStringName) / sizeof(BYTE *))
#define GLOBAL_STRING_MAX (sizeof(GlobalStringName) / sizeof(BYTE *))
/*-----------------09-07-98 13:33-------------------
define string format
--------------------------------------------------*/
#define VAR_NAME 15
#define STR_STACK 50
/******************************************************************************
* *
* L O C A L T Y P E D E F S *
* *
******************************************************************************/
/*-----------------09-08-98 12:00-------------------
name:
StringFormat
description:
define structure for string format
name : is string name
data : is string data
style :
0: no use
1: string variable
2: String Array Start
3: String Array Data
--------------------------------------------------*/
typedef struct
{
BYTE style;
BYTE name[VAR_NAME];
BYTE data[STRING_LEN];
}_StringFormat;
/*-----------------09-08-98 12:03-------------------
name:
VariableFormat
description:
define structure to variable
name for variable name
data for float data or long data
style for flaot or long or no use
style:
0: no use
1: long integer
2: float
3: Long Integer Array Start
4: Long Array Parameter
5: Float Array Start
6: Float Array Parameter
--------------------------------------------------*/
typedef struct
{
BYTE style;
BYTE name[VAR_NAME];
union
{
LONG long_data;
FLOAT float_data;
} data;
}_VariableFormat;
/*-----------------09-08-98 12:03-------------------
name:
DoubleFormat
description:
define structure to double
name for double name
data for double data
style for double or no use
style:
0: no use
1: double
2: double Array Start
3: double Array Parameter
--------------------------------------------------*/
typedef struct
{
BYTE style;
BYTE name[VAR_NAME];
DOUBLE data;
}_DoubleFormat;
/*--------------------------------------------------
name:
CounterFormat
description:
define structure to counter
step for counter step
data for counter data
--------------------------------------------------*/
typedef struct
{
INT step;
BYTE data[STRING_LEN];
}_CounterFormat;
/******************************************************************************
* *
* L O C A L F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
/******************************************************************************
* *
* L O C A L I N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
/*-----------------10-15-98 16:18-------------------
global variable
--------------------------------------------------*/
STATIC CONST BYTE *GlobalName[]=
{
"NOW",
"YEAR",
"MONTH",
"DATE",
"HOUR",
"MINUTE",
"SECOND",
"DAY",
"WEEK",
"LABEL",
"KEY1",
"KEY2",
"KEY3",
"KEY4",
"KEY5",
"KEY6",
"LED1",
"LED2",
"LED3",
"PEEL",
"GPI1",
"GPI2",
"GPI3",
"GPI4",
"GPO1",
"GPO2",
"GPO3",
"GPO4",
"GPO5",
"GPO6",
"GPO7",
};
STATIC CONST BYTE *ConstStringName[] =
{
"_MODEL$",
"_SERIAL$",
"_VERSION$",
};
STATIC CONST BYTE *GlobalStringName[] =
{
"HUGE$",
};
/******************************************************************************
* *
* L O C A L U N I T I A L I Z E D D A T A D E F I N I T I O N S *
* *
******************************************************************************/
/*-----------------10-15-98 16:18-------------------
global variable
--------------------------------------------------*/
STATIC _VariableFormat VariableTable[VAR_MAX];
STATIC _DoubleFormat DoubleTable[DOUBLE_MAX];
#if defined(__HITACHI__)
#pragma section HeapArea
#endif
STATIC _StringFormat StringTable[STRING_MAX];
STATIC _CounterFormat CounterTable[COUNTER_MAX];
#if defined(__HITACHI__)
#pragma section
#endif
STATIC BYTE GlobalStringBuffer[GLOBAL_STRING_MAX][HUGE_LEN];
STATIC BYTE sTempString[STR_STACK][VAR_NAME]; // use to temp
STATIC BYTE sTempPtr;
STATIC _PrintRecord *pVarRec;
STATIC _PrintCfg *pVarCfg;
/*-----------------09-07-98 14:07-------------------
function:
InitialGlobalVar
description:
input:
none
output:
none
--------------------------------------------------*/
VOID InitialGlobalVar(VOID)
{
ClearAllString();
ClearAllVar();
ClearAllDouble();
ClearAllCounter();
sTempPtr = 0;
pVarRec = GrabPrintRecord();
pVarCfg = GrabPrintConfig();
}
/*-----------------09-07-98 14:07-------------------
function:
ClearAllString
description:
clear sting table all variable
input:
none
output:
none
--------------------------------------------------*/
VOID ClearAllString(VOID)
{
INT i;
for (i = 0; i < STRING_MAX; i++)
{
StringTable[i].name[0] = '\0';
StringTable[i].style = 0;
}
}
/*-----------------09-07-98 14:10-------------------
function:
ClearAllVar
description:
clear variable table all variable
input:
none
output:
none
--------------------------------------------------*/
VOID ClearAllVar(VOID)
{
INT i;
for (i = 0; i < VAR_MAX; i++)
{
VariableTable[i].name[0] = '\0';
VariableTable[i].style = 0;
}
}
/*-----------------09-07-98 14:10-------------------
function:
ClearAllDouble
description:
clear double table all variable
input:
none
output:
none
--------------------------------------------------*/
VOID ClearAllDouble(VOID)
{
INT i;
for (i = 0; i < DOUBLE_MAX; i++)
{
DoubleTable[i].name[0] = '\0';
DoubleTable[i].style = 0;
}
}
/*-----------------09-07-98 14:10-------------------
function:
ClearAllCounter
description:
clear counter table all variable
input:
none
output:
none
--------------------------------------------------*/
VOID ClearAllCounter(VOID)
{
INT i;
for (i = 0; i < COUNTER_MAX; i++)
{
CounterTable[i].step = 0;
CounterTable[i].data[0] = '\0';
}
}
/*-----------------09-07-98 14:12-------------------
function:
CheckStringVariable
description:
check variable is exist
input:
string name
output:
string number
0:string is no exist
--------------------------------------------------*/
WORD CheckStringVariable(BYTE *pToken)
{
INT base, index;
// check counter string
base = STRING_MAX + GLOBAL_STRING_MAX + CONST_STRING_MAX;
if ((index = CheckCounterVariable(pToken)) != (-1))
return (base + index + 1);
// check constant string
base -= CONST_STRING_MAX;
for (index = 0 ; index < CONST_STRING_MAX; index++)
{
if (strcmp((CHAR *)pToken, (CHAR *)ConstStringName[index]) == 0)
return (base + index + 1);
}
// check global string
base -= GLOBAL_STRING_MAX;
for (index = 0 ; index < GLOBAL_STRING_MAX; index++)
{
if (strcmp((CHAR *)pToken, (CHAR *)GlobalStringName[index]) == 0)
return (base + index + 1);
}
// check variable string
base -= STRING_MAX;
for (index = 0; index < STRING_MAX; index++) /* check string for 0 to STRING_MAX */
{
if (StringTable[index].style == 1) /* if string variable */
{
if (strcmp((CHAR *)pToken, (CHAR *)StringTable[index].name) == 0)
return (base + index + 1);
}
}
return 0;
}
/*-----------------09-07-98 14:12-------------------
function:
CheckFloatVariable
description:
check Float variable is exist
input:
Float name
output:
Float Variable number
0:Float Variable is no exist
--------------------------------------------------*/
WORD CheckFloatVariable(BYTE *pToken)
{
INT i;
for (i = 0; i < VAR_MAX; i++)
{
if (VariableTable[i].style == 2)
{
if (strcmp((CHAR *)pToken, (CHAR *)VariableTable[i].name) == 0)
return (i + 1);
}
}
return 0; /* no equal float */
}
/*-----------------09-07-98 14:12-------------------
function:
CheckIntegerVariable
description:
check Integer variable is exist
input:
Integer name
output:
Integer Variable number
0:Integer Variable is no exist
--------------------------------------------------*/
WORD CheckIntegerVariable(BYTE *pToken)
{
INT i;
for (i = 0; i < VAR_MAX; i++)
{
if (VariableTable[i].style == 1)
{
if (strcmp((CHAR *)pToken, (CHAR *)VariableTable[i].name) == 0)
return (i + 1);
}
}
return 0;
}
/*-----------------09-07-98 14:12-------------------
function:
CheckDoubleVariable
description:
check Double variable is exist
input:
Double name
output:
Double Variable number
0:Double Variable is no exist
--------------------------------------------------*/
WORD CheckDoubleVariable(BYTE *pToken)
{
INT i;
for (i = 0; i < DOUBLE_MAX; i++)
{
if (DoubleTable[i].style == 1)
{
if (strcmp((CHAR *)pToken, (CHAR *)DoubleTable[i].name) == 0)
return (i + 1);
}
}
return 0;
}
/*-----------------09-08-98 14:09-------------------
function:
AddStringVariable
description:
Add String variable to String Table
input:
string name
output:
String Variable number
0:Add String Variable is false
--------------------------------------------------*/
WORD AddStringVariable(BYTE *pToken)
{
INT i;
if (*pToken == '@')
return 0;
for (i = 0; i < STRING_MAX; i++)
{
if (StringTable[i].style == 0)
{
strcpy((CHAR *)StringTable[i].name, (CHAR *)pToken);
StringTable[i].style = 1;
StringTable[i].data[0] = '\0';
return (i + 1);
}
}
return 0;
}
/*-----------------09-08-98 14:09-------------------
function:
AddFloatVariable
description:
Add Float variable to Variable Table
input:
Float name
output:
Float Variable number
0:Add Float Variable is false
--------------------------------------------------*/
WORD AddFloatVariable(BYTE *pToken)
{
INT i;
for (i = 0; i < VAR_MAX; i++)
{
if (VariableTable[i].style == 0)
{
strcpy((CHAR *)VariableTable[i].name, (CHAR *)pToken);
VariableTable[i].style = 2;
VariableTable[i].data.float_data = 0;
return (i + 1);
}
}
return 0;
}
/*-----------------09-08-98 14:09-------------------
function:
AddIntegerVariable
description:
Add Integer variable to Variable Table
input:
Integer name
output:
Integer Variable number
0:Add Integer Variable is false
--------------------------------------------------*/
WORD AddIntegerVariable(BYTE *pToken)
{
INT i;
for (i = 0; i < VAR_MAX; i++)
{
if (VariableTable[i].style == 0)
{
strcpy((CHAR *)VariableTable[i].name, (CHAR *)pToken);
VariableTable[i].style = 1;
VariableTable[i].data.long_data = 0;
return (i + 1);
}
}
return 0;
}
/*-----------------09-08-98 14:09-------------------
function:
AddDoubleVariable
description:
Add Double variable to Variable Table
input:
Double name
output:
Double Variable number
0:Add Double Variable is false
--------------------------------------------------*/
WORD AddDoubleVariable(BYTE *pToken)
{
INT i;
for (i = 0; i < DOUBLE_MAX; i++)
{
if (DoubleTable[i].style == 0)
{
strcpy((CHAR *)DoubleTable[i].name, (CHAR *)pToken);
DoubleTable[i].style = 1;
DoubleTable[i].data = 0;
return (i + 1);
}
}
return 0;
}
/*-----------------09-08-98 14:09-------------------
function:
SetStringVariable
description:
Set String variable to String Table
input:
VariableID:String number
pString:String data
output:
1:Set String Variable is succeed
0:Set String Variable is false
--------------------------------------------------*/
BYTE SetStringVariable(WORD VariableID, BYTE *pString)
{
// set counter string
if (VariableID > STRING_MAX + GLOBAL_STRING_MAX + CONST_STRING_MAX)
{
VariableID -= STRING_MAX + GLOBAL_STRING_MAX + CONST_STRING_MAX;
return SetCounterVariable(VariableID - 1, pString);
}
// constant string only read
else if (VariableID > STRING_MAX + GLOBAL_STRING_MAX)
{
VariableID -= STRING_MAX + GLOBAL_STRING_MAX;
return FALSE;
}
// set global string
else if (VariableID > STRING_MAX)
{
VariableID -= STRING_MAX;
strncpy((CHAR *)GlobalStringBuffer[VariableID - 1], (CHAR *)pString, HUGE_LEN);
GlobalStringBuffer[VariableID - 1][HUGE_LEN - 1] = '\0';
return TRUE;
}
// set variable string
else if (VariableID > 0)
{
strncpy((CHAR *)StringTable[VariableID - 1].data, (CHAR *)pString, STRING_LEN);
StringTable[VariableID - 1].data[STRING_LEN - 1] = '\0';
return TRUE;
}
return FALSE;
}
/*-----------------09-08-98 14:09-------------------
function:
SetFloatVariable
description:
Set Float variable to Variable Table
input:
VariableID: Float number
FloatValue: Float Value
output:
1:Set Float Variable is succeed
0:Set Float Variable is false
--------------------------------------------------*/
BYTE SetFloatVariable(WORD VariableID, FLOAT FloatValue)
{
if (VariableID > VAR_MAX || VariableID <= 0)
return FALSE;
VariableTable[VariableID - 1].data.float_data = FloatValue;
return TRUE;
}
/*-----------------09-08-98 14:09-------------------
function:
SetIntegerVariable
description:
Set Integer variable to Variable Table
input:
VariableID: Integer number
FloatValue: Integer Value
output:
1:Set Integer Variable is succeed
0:Set Integer Variable is false
--------------------------------------------------*/
BYTE SetIntegerVariable (WORD VariableID, LONG IntegerValue)
{
if (VariableID > VAR_MAX || VariableID <= 0)
return FALSE;
VariableTable[VariableID - 1].data.long_data = IntegerValue;
return TRUE;
}
/*-----------------09-08-98 14:09-------------------
function:
SetDoubleVariable
description:
Set Double variable to Double Table
input:
VariableID: double number
DoubleValue: double Value
output:
1:Set Double Variable is succeed
0:Set Double Variable is false
--------------------------------------------------*/
BYTE SetDoubleVariable(WORD VariableID, DOUBLE DoubleValue)
{
if (VariableID > DOUBLE_MAX || VariableID <= 0)
return FALSE;
DoubleTable[VariableID - 1].data = DoubleValue;
return TRUE;
}
/*-----------------09-08-98 14:09-------------------
function:
GetStringVariable
description:
Get String variable from String Table
input:
VariableID:String number
pString:String data
output:
1:Get String Variable is succeed
0:Get String Variable is false
--------------------------------------------------*/
BYTE GetStringVariable(WORD VariableID, BYTE *pString)
{
// get counter string
if (VariableID > STRING_MAX + GLOBAL_STRING_MAX + CONST_STRING_MAX)
{
VariableID -= STRING_MAX + GLOBAL_STRING_MAX + CONST_STRING_MAX;
return GetCounterVariable(VariableID - 1, pString);
}
// get constant string
else if (VariableID > STRING_MAX + GLOBAL_STRING_MAX)
{
VariableID -= STRING_MAX + GLOBAL_STRING_MAX;
switch (VariableID)
{
case CON_MODEL:
strcpy((CHAR *)pString, (CHAR *)ModelName);
return TRUE;
case CON_SERIAL:
strcpy((CHAR *)pString, (CHAR *)pVarRec->SerialNumberName);
return TRUE;
case CON_VERSION:
strcpy((CHAR *)pString, (CHAR *)VerName);
return TRUE;
}
}
// set global string
else if (VariableID > STRING_MAX)
{
VariableID -= STRING_MAX;
strcpy((CHAR *)pString, (CHAR *)GlobalStringBuffer[VariableID - 1]);
return TRUE;
}
// get variable string
else if (VariableID > 0)
{
strcpy((CHAR *)pString, (CHAR *)StringTable[VariableID - 1].data);
return TRUE;
}
*pString = ZERO;
return FALSE;
}
/*-----------------09-08-98 14:09-------------------
function:
GetFloatVariable
description:
Get Float variable from Variable Table
input:
VariableID: Float number
output:
float data
--------------------------------------------------*/
FLOAT GetFloatVariable(WORD VariableID)
{
if (VariableID > VAR_MAX || VariableID <= 0)
return 0;
return VariableTable[VariableID - 1].data.float_data;
}
/*-----------------09-08-98 14:09-------------------
function:
GetIntegerVariable
description:
Get Integer variable from Variable Table
input:
VariableID: Integer number
output:
Integer data
--------------------------------------------------*/
LONG GetIntegerVariable(WORD VariableID)
{
if (VariableID > VAR_MAX || VariableID <= 0)
return 0;
return VariableTable[VariableID - 1].data.long_data;
}
/*-----------------09-08-98 14:09-------------------
function:
GetDoubleVariable
description:
Get Double variable from Double Table
input:
VariableID: Double number
output:
double data
--------------------------------------------------*/
DOUBLE GetDoubleVariable(WORD VariableID)
{
if (VariableID > DOUBLE_MAX || VariableID <= 0)
return 0;
return DoubleTable[VariableID - 1].data;
}
/*-----------------09-09-98 11:51-------------------
function:
CheckStringDimension
description:
Check String Dimension is Exist
input:
String Dimension Name
output:
Dimension Number
0:string is no exist
--------------------------------------------------*/
WORD CheckStringDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 0; /* dimension index */
BYTE flg = 0; /* '(' total */
BYTE bData, status; /* return status */
bData = 1;
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get string dimension name token */
j = strlen((CHAR *)sTempString[sTempPtr]);
for (i = 0; i < STRING_MAX; i++) /* check string for 0 to STRING_MAX */
{
if (StringTable[i].style == 2) /* if string dimension start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)StringTable[i].name); /* compare string with string table */
if (status == 0) /* if equal */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
bData = (BYTE)dRetVal;
*psToken -=1;
j++; /* increace string table point */
if (status > *(StringTable[i].name + j)) /* if input > dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (1) /* util ')' or ',' to get parameter */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
switch (*sTempString[sTempPtr])
{
case '(': /* '(' increace flg */
flg++;
continue;
case ')': /* ')' decreace flg */
if (flg == 0) /* if parameter end */
{
status = 1;
break;
}
flg--; /* decreace flg */
continue;
case ',':
if (flg == 0) /* next parameter */
{
status = 2;
break;
}
continue; /* ',' in () */
case ZERO:
sTempPtr -= 1;
return 0; /* syntax error */
default:
continue; /* other data */
}
break;
}
if (status == 2) /* next parameter */
{
status = 1;
while (*(StringTable[i].name + j + status) != 0)
{
bData = bData * (*(StringTable[i].name + j + status));
status++;
}
k = k + bData;
continue;
}
if (status == 1) /* parameter end */
{
k = k + bData + 1;
if (*(StringTable[i].name + j + 1) != ZERO) /* if parameter < dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
break; /* check string dimension is ok */
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
sTempPtr -= 1;
return (i + k); /* string number */
}
}
}
sTempPtr -= 1;
return 0; /* no equal string dimension */
}
/*-----------------09-09-98 11:51-------------------
function:
CheckFloatDimension
description:
Check Float Dimension is Exist
input:
Float Dimension Name
output:
Dimension Number
0:float is no exist
--------------------------------------------------*/
WORD CheckFloatDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 0; /* dimension index */
BYTE flg = 0; /* '(' total */
BYTE bData, status; /* return status */
bData = 1;
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get float dimension name token */
j = strlen((CHAR *)sTempString[sTempPtr]);
for (i = 0; i < VAR_MAX; i++) /* check string for 0 to VAR_MAX */
{
if (VariableTable[i].style == 5) /* if string dimension start */
{
status = strcmp((CHAR *)sTempString[sTempPtr],(CHAR *)VariableTable[i].name); /* compare string with variable table */
if (status == 0) /* if equal */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
bData = (BYTE)dRetVal;
*psToken -= 1;
j++; /* increace string table point */
if (status >= *(VariableTable[i].name + j)) /* if input > dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (1) /* util ')' or ',' to get parameter */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
switch (*sTempString[sTempPtr])
{
case '(': /* '(' increace flg */
flg++;
continue;
case ')': /* ')' decreace flg */
if (flg == 0) /* if parameter end */
{
status = 1;
break;
}
flg--; /* decreace flg */
continue;
case ',':
if (flg == 0) /* next parameter */
{
status = 2;
break;
}
continue; /* ',' in () */
case ZERO:
sTempPtr -= 1;
return 0; /* syntax error */
default:
continue; /* other data */
}
break;
}
if (status == 2) /* next parameter */
{
status = 1;
while (*(VariableTable[i].name + j + status) != 0)
{
bData = bData * (*(VariableTable[i].name + j + status));
status++;
}
k = k + bData;
continue;
}
if (status == 1) /* parameter end */
{
k = k + bData + 1;
if (*(VariableTable[i].name + j + 1) != ZERO) /* if parameter < dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
break; /* check string dimension is ok */
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
sTempPtr -= 1;
return (i + k); /* string number */
}
}
}
sTempPtr -= 1;
return 0; /* no equal string dimension */
}
/*-----------------09-09-98 11:51-------------------
function:
CheckIntegerDimension
description:
Check Integer Dimension is Exist
input:
Integer Dimension Name
output:
Dimension Number
0:integer is no exist
--------------------------------------------------*/
WORD CheckIntegerDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 0; /* dimension index */
BYTE flg = 0; /* '(' total */
BYTE bData, status; /* return status */
bData = 1;
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get float dimension name token */
j = strlen((CHAR *)sTempString[sTempPtr]);
for (i = 0; i < VAR_MAX; i++) /* check string for 0 to VAR_MAX */
{
if (VariableTable[i].style == 3) /* if string dimension start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)VariableTable[i].name); /* compare string with variable table */
if (status == 0) /* if equal */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
bData = (BYTE)dRetVal;
*psToken -= 1;
j++; /* increace string table point */
if (status > *(VariableTable[i].name + j)) /* if input > dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (1) /* util ')' or ',' to get parameter */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
switch (*sTempString[sTempPtr])
{
case '(': /* '(' increace flg */
flg++;
continue;
case ')': /* ')' decreace flg */
if (flg == 0) /* if parameter end */
{
status = 1;
break;
}
flg--; /* decreace flg */
continue;
case ',':
if (flg == 0) /* next parameter */
{
status = 2;
break;
}
continue; /* ',' in () */
case ZERO:
sTempPtr -= 1;
return 0; /* syntax error */
default:
continue; /* other data */
}
break;
}
if (status == 2) /* next parameter */
{
status = 1;
while (*(VariableTable[i].name + j + status) != 0)
{
bData = bData * (*(VariableTable[i].name + j + status));
status++;
}
k = k + bData;
continue;
}
if (status == 1) /* parameter end */
{
k = k + bData + 1;
if (*(VariableTable[i].name + j + 1) != ZERO) /* if parameter < dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
break; /* check string dimension is ok */
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
sTempPtr -= 1;
return (i + k); /* string number */
}
}
}
sTempPtr -= 1;
return 0; /* no equal string dimension */
}
/*-----------------09-09-98 11:51-------------------
function:
CheckDoubleDimension
description:
Check Double Dimension is Exist
input:
Double Dimension Name
output:
Dimension Number
0:Double is no exist
--------------------------------------------------*/
WORD CheckDoubleDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 0; /* dimension index */
BYTE flg = 0; /* '(' total */
BYTE bData, status; /* return status */
bData = 1;
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get float dimension name token */
j = strlen((CHAR *)sTempString[sTempPtr]);
for (i = 0; i < DOUBLE_MAX; i++) /* check string for 0 to VAR_MAX */
{
if (DoubleTable[i].style == 2) /* if string dimension start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)DoubleTable[i].name); /* compare string with variable table */
if (status == 0) /* if equal */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
bData = (BYTE)dRetVal;
*psToken -= 1;
j++; /* increace string table point */
if (status > *(DoubleTable[i].name + j)) /* if input > dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (1) /* util ')' or ',' to get parameter */
{
NextToken(sTempString[sTempPtr], psToken); /* get next token */
switch (*sTempString[sTempPtr])
{
case '(': /* '(' increace flg */
flg++;
continue;
case ')': /* ')' decreace flg */
if (flg == 0) /* if parameter end */
{
status = 1;
break;
}
flg--; /* decreace flg */
continue;
case ',':
if (flg == 0) /* next parameter */
{
status = 2;
break;
}
continue; /* ',' in () */
case ZERO:
sTempPtr -= 1;
return 0; /* syntax error */
default:
continue; /* other data */
}
break;
}
if (status == 2) /* next parameter */
{
status = 1;
while (*(DoubleTable[i].name + j + status) != 0)
{
bData = bData * (*(DoubleTable[i].name + j + status));
status++;
}
k = k + bData;
continue;
}
if (status == 1) /* parameter end */
{
k = k + bData + 1;
if (*(DoubleTable[i].name + j + 1) != ZERO) /* if parameter < dimension */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
break; /* check string dimension is ok */
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
sTempPtr -= 1;
return (i + k); /* string number */
}
}
}
sTempPtr -= 1;
return 0; /* no equal string dimension */
}
/*-----------------09-10-98 08:48-------------------
function:
AddStringDimension
description:
Add String Dimension to String Table
input:
String Dimension Name
output:
Dimension Start Number
0: false
--------------------------------------------------*/
WORD AddStringDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 1; /* total parameter */
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get string dimension name token */
for (i = 0; i < STRING_MAX; i++) /* check string for 0 to STRING_MAX */
{
if (StringTable[i].style == 0) /* if sting no use */
{
strcpy((CHAR *)StringTable[i].name, (CHAR *)sTempString[sTempPtr]); /* copy name to string table */
j = strlen((CHAR *)StringTable[i].name);
break;
}
}
if (i >= STRING_MAX) /* if no space */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
*psToken -= 1;
status++; /* array 0 to number */
k = k * status; /* calculate dimension */
*(StringTable[i].name + j) = status; /* write dimension */
j++; /* next byte */
if (j >= VAR_NAME) /* if name to long */
{
sTempPtr -= 1;
return 0; /*syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] == ',' && *(sTempString[sTempPtr] + 1) == ZERO) /* if have next dimesion */
{
continue;
}
if (*sTempString[sTempPtr] == ')' && *(sTempString[sTempPtr] + 1) == ZERO) /* if string end */
{
*(StringTable[i].name + j) = ZERO; /* end */
break;
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
if (k > STRING_MAX - i) /* if total parameter > space string */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
StringTable[i].style = 2; /* string array start */
StringTable[i].data[0] = ZERO; /* clear string data */
for (j = 1; j < k; j++) /* 1 to total */
{
strcpy((CHAR *)StringTable[i+j].name, (CHAR *)StringTable[i].name); /* copy string name to taregt */
StringTable[i + j].style = 3; /* string style = array parameter */
StringTable[i + j].data[0] = ZERO; /* clear string data */
}
sTempPtr -= 1;
return (i + 1); /* array start number */
}
/*-----------------09-10-98 08:48-------------------
function:
AddFloatDimension
description:
Add Float Dimension to Var Table
input:
Float Dimension Name
output:
Dimension Start Number
0: false
--------------------------------------------------*/
WORD AddFloatDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 1; /* total parameter */
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get float dimension name token */
for (i = 0; i < VAR_MAX; i++) /* check float for 0 to VAR_MAX */
{
if (VariableTable[i].style == 0) /* if variable no use */
{
strcpy((CHAR *)VariableTable[i].name, (CHAR *)sTempString[sTempPtr]); /* copy name to variable table */
j = strlen((CHAR *)VariableTable[i].name);
break;
}
}
if (i >= VAR_MAX) /*if no space */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
*psToken -= 1;
status++; /* array 0 to number so number++ */
k = k * status; /* calculate dimension */
*(VariableTable[i].name + j) = status; /* write dimension */
j++; /* next byte */
if (j >= VAR_NAME) /* if name to long */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] == ',' && *(sTempString[sTempPtr] + 1) == ZERO) /* if have next dimesion */
{
continue;
}
if (*sTempString[sTempPtr] == ')' && *(sTempString[sTempPtr] + 1) == ZERO) /* if string end */
{
*(VariableTable[i].name + j) = ZERO; /* end */
break;
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
if (k > VAR_MAX - i) /* if total parameter > space string */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
VariableTable[i].style = 5; /* string array start */
VariableTable[i].data.float_data = 0; /* long data = 0 */
for (j = 1; j < k; j++) /* 1 to total */
{
strcpy((CHAR *)VariableTable[i + j].name, (CHAR *)VariableTable[i].name); /* copy string name to taregt */
VariableTable[i + j].style = 6; /* string style = array parameter */
VariableTable[i + j].data.float_data = 0; /* long data = 0 */
}
sTempPtr -= 1;
return (i + 1); /* array start number */
}
/*-----------------09-10-98 08:48-------------------
function:
AddIntegerDimension
description:
Add Integer Dimension to Var Table
input:
Integer Dimension Name
output:
Dimension Start Number
0: false
--------------------------------------------------*/
WORD AddIntegerDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 1; /* total parameter */
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get float dimension name token */
for (i = 0; i < VAR_MAX; i++) /* check float for 0 to VAR_MAX */
{
if (VariableTable[i].style == 0) /* if variable no use */
{
strcpy((CHAR *)VariableTable[i].name, (CHAR *)sTempString[sTempPtr]); /* copy name to variable table */
j = strlen((CHAR *)VariableTable[i].name);
break;
}
}
if (i >= VAR_MAX) /* if no space */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
*psToken -= 1;
status++; /* array 0 to number so number++ */
k = k * status; /* calculate dimension */
*(VariableTable[i].name + j) = status; /* write dimension */
j++; /* next byte */
if (j >= VAR_NAME) /* if name to long */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] == ',' && *(sTempString[sTempPtr] + 1) == ZERO) /* if have next dimesion */
{
continue;
}
if (*sTempString[sTempPtr] == ')' && *(sTempString[sTempPtr] + 1) == ZERO) /* if string end */
{
*(VariableTable[i].name + j) = ZERO; /* end */
break;
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
if (k > VAR_MAX - i) /* if total parameter > space string */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
VariableTable[i].style = 3; /* string array start */
VariableTable[i].data.long_data = 0; /* long data = 0 */
for (j = 1; j < k; j++) /* 1 to total */
{
strcpy((CHAR *)VariableTable[i+j].name, (CHAR *)VariableTable[i].name); /* copy string name to taregt */
VariableTable[i + j].style = 4; /* string style = array parameter */
VariableTable[i + j].data.long_data = 0; /* long data = 0 */
}
sTempPtr -= 1;
return (i + 1); /* array start number */
}
/*-----------------09-10-98 08:48-------------------
function:
AddDoubleDimension
description:
Add Double Dimension to Var Table
input:
Double Dimension Name
output:
Dimension Start Number
0: false
--------------------------------------------------*/
WORD AddDoubleDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0; /* string index */
WORD k = 1; /* total parameter */
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get float dimension name token */
for (i = 0; i < DOUBLE_MAX; i++) /* check float for 0 to VAR_MAX */
{
if (DoubleTable[i].style == 0) /* if variable no use */
{
strcpy((CHAR *)DoubleTable[i].name, (CHAR *)sTempString[sTempPtr]); /* copy name to variable table */
j = strlen((CHAR *)DoubleTable[i].name);
break;
}
}
if (i >= DOUBLE_MAX) /* if no space */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] != '(' && *(sTempString[sTempPtr] + 1) != ZERO) /* if syntax error */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
while (*sTempString[sTempPtr] != ')') /* util ')' to string end */
{
expMain(psToken);
status = (BYTE)dRetVal;
*psToken -= 1;
status++; /* array 0 to number so number++ */
k = k * status; /* calculate dimension */
*(DoubleTable[i].name + j) = status; /* write dimension */
j++; /* next byte */
if (j >= VAR_NAME) /* if name to long */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
NextToken(sTempString[sTempPtr], psToken); /* get next token */
if (*sTempString[sTempPtr] == ',' && *(sTempString[sTempPtr] + 1) == ZERO) /* if have next dimesion */
{
continue;
}
if (*sTempString[sTempPtr] == ')' && *(sTempString[sTempPtr] + 1) == ZERO) /* if string end */
{
*(DoubleTable[i].name + j) = ZERO; /* end */
break;
}
else
{
sTempPtr -= 1;
return 0; /* syntax error */
}
}
if ( k > DOUBLE_MAX - i) /* if total parameter > space string */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
DoubleTable[i].style = 2; /* string array start */
DoubleTable[i].data = 0; /* long data = 0 */
for (j = 1; j < k; j++) /* 1 to total */
{
strcpy((CHAR *)DoubleTable[i + j].name, (CHAR *)DoubleTable[i].name); /* copy string name to taregt */
DoubleTable[i + j].style = 3; /* string style = array parameter */
DoubleTable[i + j].data = 0; /* long data = 0 */
}
sTempPtr -= 1;
return (i + 1); /* array start number */
}
/*-----------------09-10-98 08:48-------------------
function:
SetStringDimension
description:
Add String Dimension to String Table
input:
VariableID:String number
pString:String data
output:
1:Set String Variable is succeed
0: false
--------------------------------------------------*/
BYTE SetStringDimension(WORD VariableID, BYTE *pString)
{
if (VariableID > STRING_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* set string false */
strcpy((CHAR *)StringTable[VariableID - 1].data, (CHAR *)pString); /* copy string to VariableTable[index] */
return 1; /* set string succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
SetFloatDimension
description:
Set Float Dimension to Variable Table
input:
VariableID: Float number
FloatValue: Float Value
output:
1:Set Float Dimension is succeed
0:Set Float Dimension is false
--------------------------------------------------*/
BYTE SetFloatDimension(WORD VariableID, FLOAT FloatValue)
{
if (VariableID > VAR_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* set float false*/
VariableTable[VariableID - 1].data.float_data = FloatValue; /* set float data */
return 1; /* set float succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
SetIntegerDimension
description:
Set Integer Dimension to Variable Table
input:
VariableID: Integer number
FloatValue: Integer Value
output:
1:Set Integer Dimension is succeed
0:Set Integer Dimension is false
--------------------------------------------------*/
BYTE SetIntegerDimension(WORD VariableID, LONG IntegerValue)
{
if (VariableID > VAR_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* set Integer false */
VariableTable[VariableID - 1].data.long_data = IntegerValue; /* set Integer data */
return 1; /* set Integer succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
SetDoubleDimension
description:
Set Double Dimension to Variable Table
input:
VariableID: Double number
DoubleValue: double Value
output:
1:Set Double Dimension is succeed
0:Set Double Dimension is false
--------------------------------------------------*/
BYTE SetDoubleDimension(WORD VariableID, DOUBLE DoubleValue)
{
if (VariableID > DOUBLE_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* set Integer false */
DoubleTable[VariableID - 1].data = DoubleValue; /* set Integer data */
return 1; /* set Integer succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
GetStringDimension
description:
Get String Dimension from String Table
input:
VariableID:String number
pString:String data
output:
1:Get String Dimension is succeed
0:Get String dimension is false
--------------------------------------------------*/
BYTE GetStringDimension(WORD VariableID, BYTE *pString)
{
if (VariableID > STRING_MAX || VariableID <= 0) /* if VariableID illegal */
{
*pString = ZERO; /* clear return string */
return 0; /* get string false*/
}
strcpy((CHAR *)pString, (CHAR *)StringTable[VariableID - 1].data); /* copy VariableTable[index] to pString */
return 1; /* get string succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
GetFloatDimension
description:
Get Float Dimension from Variable Table
input:
VariableID: Float number
output:
float data
--------------------------------------------------*/
FLOAT GetFloatDimension(WORD VariableID)
{
if (VariableID > VAR_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* get float false*/
return VariableTable[VariableID - 1].data.float_data; /* return float data */
}
/*-----------------09-08-98 14:09-------------------
function:
GetIntegerDimension
description:
Get Integer Dimension from Variable Table
input:
VariableID: Integer number
output:
Integer data
--------------------------------------------------*/
LONG GetIntegerDimension(WORD VariableID)
{
if (VariableID > VAR_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* get Integer false */
return VariableTable[VariableID - 1].data.long_data; /* return integer data */
}
/*-----------------09-08-98 14:09-------------------
function:
GetDoubleDimension
description:
Get Double Dimension from Variable Table
input:
VariableID: double number
output:
Double data
--------------------------------------------------*/
DOUBLE GetDoubleDimension(WORD VariableID)
{
if (VariableID > DOUBLE_MAX || VariableID <= 0) /* if VariableID illegal */
return 0; /* get Integer false */
return DoubleTable[VariableID - 1].data; /* return double data */
}
/*-----------------09-08-98 14:09-------------------
function:
ClearStringDimension
description:
Clear String Dimension from String Table
input:
String Dimension name
output:
0: is false
1: is succeed
--------------------------------------------------*/
BYTE ClearStringDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0;
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get string dimension name token */
for (i = 0; i < STRING_MAX; i++) /* check string for 0 to STRING_MAX */
{
if (StringTable[i].style == 2) /* if string array start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)StringTable[i].name); /* compare string with variable table */
if (status == 0) /* if get dimension start */
{
StringTable[i].style = 0; /* claer style */
StringTable[i].name[0] = ZERO; /* clear name */
j++; /* next string */
while (StringTable[i + j].style == 3) /* clear string dimension parameter */
{
StringTable[i + j].style = 0; /* clear style */
StringTable[i + j].name[0] = ZERO; /* clear name */
j++; /* next string */
}
break;
}
}
}
if (i >= STRING_MAX) /* if no equal */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
for (j = i; j < STRING_MAX; j++) /*sort string table */
{
if (StringTable[j].style != 0) /* if get next string */
{
strcpy((CHAR *)StringTable[i].name, (CHAR *)StringTable[j].name); /* copy name */
strcpy((CHAR *)StringTable[i].data, (CHAR *)StringTable[j].data); /* copy data */
StringTable[i].style=StringTable[j].style; /* copy style */
i++; /* next space area */
}
}
sTempPtr -= 1;
return 1; /* clear succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
ClearFloatDimension
description:
Clear Float Dimension from String Table
input:
Float Dimension name
output:
0: is false
1: is succeed
--------------------------------------------------*/
BYTE ClearFloatDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0;
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get string dimension name token */
for (i = 0; i < VAR_MAX; i++) /* check string for 0 to STRING_MAX */
{
if (VariableTable[i].style == 5) /* if string array start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)VariableTable[i].name); /* compare string with variable table */
if (status == 0) /* if get dimension start */
{
VariableTable[i].style = 0; /* claer style */
VariableTable[i].name[0] = ZERO; /* clear name */
j++; /* next float */
while (VariableTable[i + j].style == 6) /* clear float dimension parameter */
{
VariableTable[i + j].style = 0; /* clear style */
VariableTable[i + j].name[0] = ZERO; /* clear name */
j++; /* next float */
}
break;
}
}
}
if (i >= VAR_MAX) /*if no equal */
{
sTempPtr -= 1;
return 0; /*syntax error */
}
for (j = i; j < VAR_MAX; j++) /*sort variable table */
{
if (VariableTable[j].style != 0) /* if get next variable */
{
strcpy((CHAR *)VariableTable[i].name, (CHAR *)VariableTable[j].name); /* copy name */
VariableTable[i].data.float_data = VariableTable[j].data.float_data; /* copy data */
VariableTable[i].style = VariableTable[j].style; /* copy style */
i++; /* next space area */
}
}
sTempPtr -= 1;
return 1; /* clear succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
ClearIntegerDimension
description:
Clear Integer Dimension from String Table
input:
Integer Dimension name
output:
0: is false
1: is succeed
--------------------------------------------------*/
BYTE ClearIntegerDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0;
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get string dimension name token */
for (i = 0; i < VAR_MAX; i++) /* check string for 0 to STRING_MAX */
{
if (VariableTable[i].style == 3) /* if string array start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)VariableTable[i].name); /* compare string with variable table */
if (status == 0) /* if get dimension start */
{
VariableTable[i].style = 0; /* claer style */
VariableTable[i].name[0] = ZERO; /* clear name */
j++; /* next float */
while (VariableTable[i + j].style == 4) /* clear integer dimension parameter */
{
VariableTable[i + j].style = 0; /* claer style */
VariableTable[i + j].name[0] = ZERO; /* clear name */
j++; /* next float */
}
break;
}
}
}
if (i >= VAR_MAX) /* if no equal */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
for (j = i; j < VAR_MAX; j++) /* sort variable table */
{
if (VariableTable[j].style != 0) /* if get next variable */
{
strcpy((CHAR *)VariableTable[i].name, (CHAR *)VariableTable[j].name); /* copy name */
VariableTable[i].data.long_data = VariableTable[j].data.long_data; /* copy data */
VariableTable[i].style = VariableTable[j].style; /* copy style */
i++; /* next space area */
}
}
sTempPtr -= 1;
return 1; /* clear succeed */
}
/*-----------------09-08-98 14:09-------------------
function:
ClearDoubleDimension
description:
Clear Double Dimension from Double Table
input:
Double Dimension name
output:
0: is false
1: is succeed
--------------------------------------------------*/
BYTE ClearDoubleDimension(BYTE **psToken)
{
WORD i = 0; /* variable index */
WORD j = 0;
BYTE status; /* return status */
sTempPtr += 1;
NextToken(sTempString[sTempPtr], psToken); /* get string dimension name token */
for (i = 0; i < DOUBLE_MAX; i++) /* check string for 0 to DOUBLE_MAX */
{
if (DoubleTable[i].style == 2) /* if string array start */
{
status = strcmp((CHAR *)sTempString[sTempPtr], (CHAR *)DoubleTable[i].name); /* compare string with variable table */
if (status == 0) /* if get dimension start */
{
DoubleTable[i].style = 0; /* claer style */
DoubleTable[i].name[0] = ZERO; /* clear name */
j++; /* next float */
while (DoubleTable[i + j].style == 3) /* clear integer dimension parameter */
{
DoubleTable[i + j].style = 0; /* claer style */
DoubleTable[i + j].name[0] = ZERO; /* clear name */
j++; /* next float */
}
break;
}
}
}
if (i >= DOUBLE_MAX) /* if no equal */
{
sTempPtr -= 1;
return 0; /* syntax error */
}
for (j = i; j < DOUBLE_MAX; j++) /* sort variable table */
{
if (DoubleTable[j].style != 0) /* if get next variable */
{
strcpy((CHAR *)DoubleTable[i].name, (CHAR *)DoubleTable[j].name); /* copy name */
DoubleTable[i].data = DoubleTable[j].data; /* copy data */
DoubleTable[i].style = DoubleTable[j].style; /* copy style */
i++; /* next space area */
}
}
sTempPtr -= 1;
return 1; /* clear succeed */
}
/*-----------------09-07-98 14:12-------------------
function:
CheckGlobalVariable
description:
check global variable is exist
input:
global name
output:
global Variable number
0:global Variable is no exist
--------------------------------------------------*/
WORD CheckGlobalVariable(BYTE *pToken)
{
INT index;
if (*pToken == '@')
pToken += 1;
for (index = 0; index < GLOBAL_MAX; index++)
{
if (strcmp((CHAR *)pToken, (CHAR *)GlobalName[index]) == 0)
return (index + 1); /* global number */
}
return 0; /* no equal global */
}
/*-----------------09-08-98 14:09-------------------
function:
SetGlobalVariable
description:
Set global variable
input:
VariableID: global variable number
Value: global variable Value
output:
1:Set global Variable is succeed
0:Set global Variable is false
--------------------------------------------------*/
BYTE SetGlobalVariable(WORD VariableID, DOUBLE Value)
{
if (VariableID > GLOBAL_MAX || VariableID <= 0)
return FALSE;
switch (VariableID)
{
case GLO_NOW:
// not yet decided
// if (Value >= SINCE_1970)
// {
// time_t CTime = (Value - SINCE_1970) * SEC_PER_DAY;
// stime(&CTime);
// }
break;
case GLO_YEAR:
SetRTC(RTC_YEAR, (LONG)Value);
break;
case GLO_MONTH:
SetRTC(RTC_MONTH, (LONG)Value);
break;
case GLO_DATE:
SetRTC(RTC_DATE, (LONG)Value);
break;
case GLO_HOUR:
SetRTC(RTC_HOUR, (LONG)Value);
break;
case GLO_MINUTE:
SetRTC(RTC_MIN, (LONG)Value);
break;
case GLO_SECOND:
SetRTC(RTC_SEC, (LONG)Value);
break;
case GLO_DAY:
case GLO_WEEK:
SetRTC(RTC_DAY, (LONG)Value);
break;
case GLO_LABEL:
pVarRec->LabelMilage = Value;
break;
case GLO_LED1:
if (pVarCfg->LedSelect & LED1_FLAG)
{
#if defined(MONO_LED) && defined(TDP643)
if (Value != 0)
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
else
ShowLED(HID_LED_IDLE, HID_LED_OFF, HID_LED_IDLE);
#elif defined(MONO_LED)
if (Value != 0)
ShowLED(HID_LED_ON, HID_LED_IDLE, HID_LED_IDLE);
else
ShowLED(HID_LED_OFF, HID_LED_IDLE, HID_LED_IDLE);
#elif defined(POLY_LED)
if (Value != 0)
{
if (GetLED(LED2))
ShowLED(HID_LED_ORANGE);
else
ShowLED(HID_LED_GREEN);
}
else
{
if (GetLED(LED2))
ShowLED(HID_LED_RED);
else
ShowLED(HID_LED_DARK);
}
#endif
}
break;
case GLO_LED2:
if (pVarCfg->LedSelect & LED2_FLAG)
{
#if defined(MONO_LED) && defined(TDP643)
if (Value != 0)
ShowLED(HID_LED_IDLE, HID_LED_IDLE, HID_LED_ON);
else
ShowLED(HID_LED_IDLE, HID_LED_IDLE, HID_LED_OFF);
#elif defined(MONO_LED)
if (Value != 0)
ShowLED(HID_LED_IDLE, HID_LED_ON, HID_LED_IDLE);
else
ShowLED(HID_LED_IDLE, HID_LED_OFF, HID_LED_IDLE);
#elif defined(POLY_LED)
if (Value != 0)
{
if (GetLED(LED2))
ShowLED(HID_LED_ORANGE);
else
ShowLED(HID_LED_GREEN);
}
else
{
if (GetLED(LED2))
ShowLED(HID_LED_RED);
else
ShowLED(HID_LED_DARK);
}
#endif
}
break;
case GLO_LED3:
if (pVarCfg->LedSelect & LED3_FLAG)
{
#if defined(MONO_LED)
if (Value != 0)
ShowLED(HID_LED_IDLE, HID_LED_IDLE, HID_LED_ON);
else
ShowLED(HID_LED_IDLE, HID_LED_IDLE, HID_LED_OFF);
#elif defined(POLY_LED)
if (Value != 0)
{
if (GetLED(LED1))
ShowLED(HID_LED_ORANGE);
else
ShowLED(HID_LED_RED);
}
else
{
if (GetLED(LED1))
ShowLED(HID_LED_GREEN);
else
ShowLED(HID_LED_DARK);
}
#endif
}
break;
#if defined(GPIO_MODEL)
case GLO_GPO1:
if (pVarCfg->GPOutSetting[GPO_CH1].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_1, (Value != 0) ? HIGH : LOW);
break;
case GLO_GPO2:
if (pVarCfg->GPOutSetting[GPO_CH2].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_2, (Value != 0) ? HIGH : LOW);
break;
case GLO_GPO3:
if (pVarCfg->GPOutSetting[GPO_CH3].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_3, (Value != 0) ? HIGH : LOW);
break;
case GLO_GPO4:
if (pVarCfg->GPOutSetting[GPO_CH4].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_4, (Value != 0) ? HIGH : LOW);
break;
case GLO_GPO5:
if (pVarCfg->GPOutSetting[GPO_CH5].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_5, (Value != 0) ? HIGH : LOW);
break;
case GLO_GPO6:
if (pVarCfg->GPOutSetting[GPO_CH6].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_6, (Value != 0) ? HIGH : LOW);
break;
case GLO_GPO7:
if (pVarCfg->GPOutSetting[GPO_CH7].Signal == GPIO_SIGNAL_OFF)
GeneralPurposeOutput(GPIO_OUTPUT_7, (Value != 0) ? HIGH : LOW);
break;
#endif
default:
return FALSE;
}
return TRUE;
}
/*-----------------09-08-98 14:09-------------------
function:
GetGlobalVariable
description:
Get global variable from Variable Table
input:
VariableID: global variable number
output:
double data
--------------------------------------------------*/
DOUBLE GetGlobalVariable(WORD VariableID, BYTE *pString)
{
DOUBLE Value = 0;
if (VariableID > GLOBAL_MAX || VariableID <= 0)
return 0;
switch (VariableID)
{
case GLO_NOW:
Value = (DOUBLE)time(_NULL) / SEC_PER_DAY + SINCE_1970;
if (pString)
{
DATE Date = expDoubleToDate(Value);
expDateToString(pString, Date);
}
return Value;
case GLO_YEAR:
Value = GetRTC(RTC_YEAR);
#if defined(TSPL_VER_1)
Value = (LONG)Value % 100;
#endif
break;
case GLO_MONTH:
Value = GetRTC(RTC_MONTH);
break;
case GLO_DATE:
Value = GetRTC(RTC_DATE);
break;
case GLO_HOUR:
Value = GetRTC(RTC_HOUR);
break;
case GLO_MINUTE:
Value = GetRTC(RTC_MIN);
break;
case GLO_SECOND:
Value = GetRTC(RTC_SEC);
break;
case GLO_DAY:
case GLO_WEEK:
Value = GetRTC(RTC_DAY);
break;
case GLO_LABEL:
Value = pVarRec->LabelMilage;
break;
case GLO_KEY1:
#if defined(SOFT_KEY1)
if (pVarCfg->KeySetting[SOFT_KEY1].FuncID == KEY_FUNC_OFF)
Value = CheckKeyPin(SOFT_KEY1) ? 1 : 0;
#endif
break;
case GLO_KEY2:
#if defined(SOFT_KEY2)
if (pVarCfg->KeySetting[SOFT_KEY2].FuncID == KEY_FUNC_OFF)
Value = CheckKeyPin(SOFT_KEY2) ? 1 : 0;
#endif
break;
case GLO_KEY3:
#if defined(SOFT_KEY3)
if (pVarCfg->KeySetting[SOFT_KEY3].FuncID == KEY_FUNC_OFF)
Value = CheckKeyPin(SOFT_KEY3) ? 1 : 0;
#endif
break;
case GLO_KEY4:
#if defined(SOFT_KEY4)
if (pVarCfg->KeySetting[SOFT_KEY4].FuncID == KEY_FUNC_OFF)
Value = CheckKeyPin(SOFT_KEY4) ? 1 : 0;
#endif
break;
case GLO_KEY5:
#if defined(SOFT_KEY5)
if (pVarCfg->KeySetting[SOFT_KEY5].FuncID == KEY_FUNC_OFF)
Value = CheckKeyPin(SOFT_KEY5) ? 1 : 0;
#endif
break;
case GLO_KEY6:
#if defined(SOFT_KEY6)
if (pVarCfg->KeySetting[SOFT_KEY6].FuncID == KEY_FUNC_OFF)
Value = CheckKeyPin(SOFT_KEY6) ? 1 : 0;
#endif
break;
case GLO_LED1:
#if defined(TDP643)
Value = GetLED(LED2) ? 1 : 0;
#else
Value = GetLED(LED1) ? 1 : 0;
#endif
break;
case GLO_LED2:
#if defined(TDP643)
Value = GetLED(LED3) ? 1 : 0;
#else
Value = GetLED(LED2) ? 1 : 0;
#endif
break;
case GLO_LED3:
Value = GetLED(LED3) ? 1 : 0;
break;
case GLO_PEEL:
Value = IsPeelsLabelExists() ? 1 : 0;
break;
#if defined(GPIO_MODEL)
case GLO_GPI1:
Value = GeneralPurposeInput(GPIO_INPUT_1) ? 1 : 0;
break;
case GLO_GPI2:
Value = GeneralPurposeInput(GPIO_INPUT_2) ? 1 : 0;
break;
case GLO_GPI3:
Value = GeneralPurposeInput(GPIO_INPUT_3) ? 1 : 0;
break;
case GLO_GPI4:
Value = GeneralPurposeInput(GPIO_INPUT_4) ? 1 : 0;
break;
#endif
default:
return 0;
}
if (pString)
{
expDoubleToString(pString, Value);
}
NutThreadYield();
return Value;
}
/*--------------------------------------------------
function:
CheckCounterVariable
description:
check variable is exist
input:
counter name
output:
counter number
(-1):counter is no exist
--------------------------------------------------*/
INT CheckCounterVariable(BYTE *pToken)
{
INT num, i;
if (*pToken != '@')
return (-1);
for (i = 1; i < strlen((CHAR *)pToken); i++)
{
if (!isdigit(*(pToken + i)))
return (-1);
}
num = atoi((CHAR *)pToken + 1);
if (num < COUNTER_MAX + KEEP_COUNTER_MAX)
return num;
return (-1);
}
BYTE SetCounterVariable(INT num, BYTE *pString)
{
if (num < 0 || num >= COUNTER_MAX + KEEP_COUNTER_MAX)
return FALSE;
if (num >= COUNTER_MAX)
{
num -= COUNTER_MAX;
strncpy((CHAR *)pVarCfg->CounterData[num], (CHAR *)pString, 32);
pVarCfg->CounterData[num][32 - 1] = '\0';
}
else
{
strncpy((CHAR *)CounterTable[num].data, (CHAR *)pString, STRING_LEN);
CounterTable[num].data[STRING_LEN - 1] = '\0';
}
return TRUE;
}
BYTE GetCounterVariable(INT num, BYTE *pString)
{
if (num < 0 || num >= COUNTER_MAX + KEEP_COUNTER_MAX)
return FALSE;
if (num >= COUNTER_MAX)
{
num -= COUNTER_MAX;
strcpy((CHAR *)pString, (CHAR *)pVarCfg->CounterData[num]);
}
else
strcpy((CHAR *)pString, (CHAR *)CounterTable[num].data);
return TRUE;
}
BOOL SetCounterStep(INT num, INT step)
{
if (num < 0 || num >= COUNTER_MAX + KEEP_COUNTER_MAX)
return FALSE;
if (num >= COUNTER_MAX)
{
num -= COUNTER_MAX;
pVarCfg->CounterStep[num] = step;
}
else
CounterTable[num].step = step;
return TRUE;
}
INT GetCounterStep(INT num)
{
INT step = 0;
if (num < 0 || num >= COUNTER_MAX + KEEP_COUNTER_MAX)
return 0;
if (num >= COUNTER_MAX)
{
num -= COUNTER_MAX;
step = pVarCfg->CounterStep[num];
}
else
step = CounterTable[num].step;
return step;
}
#endif
VarMgr.h /
#ifndef VARMGR_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define VARMGR_H
/******************************************************************************
* *
* C O M P I L E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* U S E R D E F I N E D I N C L U D E F I L E S *
* *
******************************************************************************/
#ifdef __cplusplus
extern "C" { /* Assume C declarations for C++ */
#endif /* __cplusplus */
/******************************************************************************
* *
* G L O B A L D E F I N E S *
* *
******************************************************************************/
// Global Variable
#define GLO_NOW 1
#define GLO_YEAR 2
#define GLO_MONTH 3
#define GLO_DATE 4
#define GLO_HOUR 5
#define GLO_MINUTE 6
#define GLO_SECOND 7
#define GLO_DAY 8
#define GLO_WEEK 9
#define GLO_LABEL 10
#define GLO_KEY1 11
#define GLO_KEY2 12
#define GLO_KEY3 13
#define GLO_KEY4 14
#define GLO_KEY5 15
#define GLO_KEY6 16
#define GLO_LED1 17
#define GLO_LED2 18
#define GLO_LED3 19
#define GLO_PEEL 20
#define GLO_GPI1 21
#define GLO_GPI2 22
#define GLO_GPI3 23
#define GLO_GPI4 24
#define GLO_GPO1 25
#define GLO_GPO2 26
#define GLO_GPO3 27
#define GLO_GPO4 28
#define GLO_GPO5 29
#define GLO_GPO6 30
#define GLO_GPO7 31
// Constant String
#define CON_MODEL 1
#define CON_SERIAL 2
#define CON_VERSION 3
// Global String
#define STR_HUGE 1
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* G L O B A L V A R I A B L E S - N O I N I T I A L I Z E R S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* G L O B A L V A R I A B L E S - I N I T I A L I Z E R S *
* *
******************************************************************************/
/* None */
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
VOID InitialGlobalVar(VOID);
VOID ClearAllString(VOID);
VOID ClearAllVar(VOID);
VOID ClearAllDouble(VOID);
VOID ClearAllCounter(VOID);
WORD CheckStringVariable(BYTE *);
WORD CheckFloatVariable(BYTE *);
WORD CheckIntegerVariable(BYTE *);
WORD CheckDoubleVariable(BYTE *);
WORD AddStringVariable(BYTE *);
WORD AddFloatVariable(BYTE *);
WORD AddIntegerVariable(BYTE *);
WORD AddDoubleVariable(BYTE *);
BYTE SetStringVariable(WORD, BYTE *);
BYTE SetFloatVariable(WORD, FLOAT);
BYTE SetIntegerVariable(WORD, LONG);
BYTE SetDoubleVariable(WORD, DOUBLE);
BYTE GetStringVariable(WORD , BYTE *);
FLOAT GetFloatVariable(WORD);
LONG GetIntegerVariable(WORD);
DOUBLE GetDoubleVariable(WORD);
WORD CheckStringDimension(BYTE **);
WORD CheckFloatDimension(BYTE **);
WORD CheckIntegerDimension(BYTE **);
WORD CheckDoubleDimension(BYTE **);
WORD AddStringDimension(BYTE **);
WORD AddFloatDimension(BYTE **);
WORD AddIntegerDimension(BYTE **);
WORD AddDoubleDimension(BYTE **);
BYTE SetStringDimension(WORD , BYTE *);
BYTE SetFloatDimension(WORD ,FLOAT);
BYTE SetIntegerDimension(WORD, LONG);
BYTE SetDoubleDimension(WORD, DOUBLE);
BYTE GetStringDimension(WORD, BYTE *);
FLOAT GetFloatDimension(WORD);
LONG GetIntegerDimension(WORD);
DOUBLE GetDoubleDimension(WORD);
BYTE ClearStringDimension(BYTE **);
BYTE ClearFloatDimension(BYTE **);
BYTE ClearIntegerDimension(BYTE **);
BYTE ClearDoubleDimension(BYTE **);
WORD CheckGlobalVariable(BYTE *);
BYTE SetGlobalVariable(WORD, DOUBLE);
DOUBLE GetGlobalVariable(WORD, BYTE *);
INT CheckCounterVariable(BYTE *);
BYTE SetCounterVariable(INT, BYTE *);
BYTE GetCounterVariable(INT, BYTE *);
BOOL SetCounterStep(INT, INT);
INT GetCounterStep(INT);
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif