T168_111\appl\Parser\Tspl:第34~37

最新推荐文章于 2024-06-18 15:53:57 发布

qq_33772147

最新推荐文章于 2024-06-18 15:53:57 发布

阅读量605

点赞数 9

文章标签：算法

本文链接：https://blog.csdn.net/qq_33772147/article/details/136967822

版权

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

#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

#include <stdlib.h>
#include <ctype.h>
#include <string.h>

#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;

/*-----------------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$",
};

/*-----------------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 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 ZERO:
                               sTempPtr -= 1;
                               return 0;   /* syntax error */

/*-----------------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 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 */

   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 (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 */

       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

/* None */

#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

/* None */

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

qq_33772147

关注

9
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
T168_111\appl\Parser\Tspl:第34~37

然后，将pExp转换为BYTE类型的指针，并调用expMain函数，对表达式进行解析和计算。参数作用：函数接受两个参数：_eTokenEndMode Mode表示表达式的结束模式，DOUBLE *pNumber是一个指向DOUBLE类型的指针，用于存储获取到的数值。接下来，通过调用GetExpToken函数，将Mode和Token作为参数，获取表达式的标记并存储到Token数组中。最后，将计算得到的结果dRetVal赋值给pNumber指针所指向的内存，并返回TRUE，表示获取数值成功。
复制链接

扫一扫