NextByte.c 。。。。。。。。。。。。。。。。。。。。。。。
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define NEXTBYTE_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 *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 "XDisplay.h"
#include "Tspl\TsplFunc.h"
#include "NextByte.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
STATIC CHAR CommNextByte(VOID);
STATIC CHAR FileNextByte(VOID);
STATIC CHAR LineNextByte(VOID);
STATIC BOOL CommCheckByte(VOID);
STATIC BOOL FileCheckByte(VOID);
STATIC BOOL LineCheckByte(VOID);
STATIC CHAR GetBackArray(VOID);
STATIC VOID StoreParsePool(CHAR);
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
STATIC _NextByte *pNextByte;
STATIC _FileHandle *NextByteHandle;
STATIC XCALLBACK EndFileFunc;
STATIC INT RunFileKey;
STATIC BOOL DirectIgnoreLF;
/******************************************************************************
*
* Function:
* InitialNextByte
*
* Description:
*
*
* Input:
* None
*
* Output:
* None.
*
******************************************************************************/
VOID InitialNextByte(VOID)
{
CommByte.Next = CommNextByte;
FileByte.Next = FileNextByte;
LineByte.Next = LineNextByte;
CommByte.Check = CommCheckByte;
FileByte.Check = FileCheckByte;
LineByte.Check = LineCheckByte;
CommByte.BackQuantity = 0;
FileByte.BackQuantity = 0;
LineByte.BackQuantity = 0;
CommByte.ParserPoolLen = 0;
FileByte.ParserPoolLen = 0;
LineByte.ParserPoolLen = 0;
CommByte.IgnoreLF = FALSE;
FileByte.IgnoreLF = FALSE;
LineByte.IgnoreLF = FALSE;
AssignNextByte(&CommByte);
NextByteHandle = _NULL;
DirectIgnoreLF = FALSE;
}
/
_FileHandle *RunFile(_eFileDevice device, CHAR *filename, INT key, XCALLBACK callback) //开机调用，Parser之后
{
if (NextByteHandle != _NULL)
return _NULL;
NextByteHandle = Fopen(device, filename, "r");
//sysprintf("ANB_6\n");
if (NextByteHandle != _NULL)
AssignNextByte(&FileByte);
RunFileKey = key;
EndFileFunc = callback;
return NextByteHandle;
}
VOID EndFile(VOID)
{
ReturnNextByte(&CommByte);
Fclose(NextByteHandle);
NextByteHandle = _NULL;
if (EndFileFunc)
EndFileFunc();
}
/指定下一字节
VOID AssignNextByte(_NextByte *next)
{
next->BackQuantity = 0;
next->ParserPoolLen = 0;
next->IgnoreLF = FALSE;
pNextByte = next;
NextByte = GetBackArray;
}
/
VOID ReturnNextByte(_NextByte *next) //返回下一字节
{
pNextByte = next;
NextByte = GetBackArray;
}
CHAR DirectNextByte(VOID)
{
CHAR data;
while (1)
{
if (GetByte((BYTE *)&data))
{
if (!DirectIgnoreLF)
break;
DirectIgnoreLF = FALSE;
if (data != LF_CHAR)
break;
}
}
return data;
}
STATIC CHAR CommNextByte(VOID)
{
CHAR data;
while (1)
{
if (GetByte((BYTE *)&data))
{
StoreParsePool(data);
if (!CommByte.IgnoreLF)
break;
CommByte.IgnoreLF = FALSE;
if (data != LF_CHAR)
break;
}
}
return data;
}
STATIC CHAR FileNextByte(VOID)
{
CHAR data;
INT c;
while (1)
{
// get data from file
if ((c = Fgetc(NextByteHandle)) == END_OF_FILE)
{
EndFile();
return NextByte();
}
data = (CHAR)(c ^ RunFileKey);
StoreParsePool(data);
if (!FileByte.IgnoreLF)
break;
FileByte.IgnoreLF = FALSE;
if (data != LF_CHAR)
break;
}
return data;
}
STATIC CHAR LineNextByte(VOID)
{
CHAR data;
while (1)
{
if (*sBasicData.LinePtr == '\0')
{
if (NextByteHandle != _NULL)
ReturnNextByte(&FileByte);
else
ReturnNextByte(&CommByte);
return NextByte();
}
data = *sBasicData.LinePtr++;
StoreParsePool(data);
if (!LineByte.IgnoreLF)
break;
LineByte.IgnoreLF = FALSE;
if (data != LF_CHAR)
break;
}
return data;
}
BOOL DirectCheckByte(VOID)
{
return CheckCommBuffer();
}
STATIC BOOL CommCheckByte(VOID)
{
return CheckCommBuffer();
}
STATIC BOOL FileCheckByte(VOID)
{
return TRUE;
}
STATIC BOOL LineCheckByte(VOID)
{
return TRUE;
}
BOOL CheckByte(VOID)
{
if (pNextByte->BackQuantity)
return TRUE;
return pNextByte->Check();
}
///
VOID BackByte(CHAR data) //
{
NextByte = GetBackArray;
if (pNextByte->BackQuantity < BACK_BYTE_TOTAL)
pNextByte->BackArray[pNextByte->BackQuantity++] = data;
if (pNextByte->ParserPoolLen)
pNextByte->ParserPoolLen -= 1;
}
有数据返回数据，没数据返回函数指针
STATIC CHAR GetBackArray(VOID) //AssignNextByte(_NextByte *next) ReturnNextByte(_NextByte *next) BackByte(CHAR data)
{
CHAR data;
if (pNextByte->BackQuantity)
{
data = pNextByte->BackArray[--pNextByte->BackQuantity];
StoreParsePool(data); //存到解析缓存区
//debug_printf("%c",data);
#ifdef DEBUG_PRNT
sysprintf("GetBackArray()_data : %d\n", data); // ch_20211209
#endif
return data;
}
NextByte = pNextByte->Next;
#ifdef DEBUG_PRNT
sysprintf("GetBackArray()_NextByte : %d\n", NextByte); // ch_20211211
#endif
return NextByte();
}
/
VOID ClearParserPool(VOID)
{
pNextByte->ParserPoolLen = 0;
}
///
STATIC VOID StoreParsePool(CHAR data)
{
if (pNextByte->ParserPoolLen < PARSE_POOL_SIZE)
pNextByte->ParserPool[pNextByte->ParserPoolLen] = data;
pNextByte->ParserPoolLen++;
}
BOOL BackParsePool(VOID)
{
if (pNextByte->ParserPoolLen > PARSE_POOL_SIZE)
return FALSE;
while (pNextByte->ParserPoolLen)
BackByte(pNextByte->ParserPool[pNextByte->ParserPoolLen - 1]);
return TRUE;
}
VOID SetDirectIgnoreLF(BOOL ignore)
{
DirectIgnoreLF = ignore;
}
VOID IgnoreFollowLF(VOID)
{
pNextByte->IgnoreLF = TRUE;
}
VOID RemoveLF(VOID)
{
CHAR data;
if (pNextByte->IgnoreLF == TRUE)
{
pNextByte->IgnoreLF = FALSE;
data = NextByte();
if (data != LF_CHAR)
BackByte(data);
}
}
NextByte.h 。。。。。。。。。。。。。。。。。。。。。。
#ifndef NEXTBYTE_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define NEXTBYTE_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 "XFileSys.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 BACK_BYTE_TOTAL 256
#define PARSE_POOL_SIZE 96
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
typedef struct
{
CHAR (*Next)(VOID);
BOOL (*Check)(VOID);
CHAR BackArray[BACK_BYTE_TOTAL];
CHAR ParserPool[PARSE_POOL_SIZE];
INT BackQuantity; // 取的数量
INT ParserPoolLen;
BOOL IgnoreLF;
}_NextByte;
/******************************************************************************
* *
* 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 NEXTBYTE_C
#define EXTERN
#else
#define EXTERN extern
#endif
EXTERN _NextByte CommByte;
EXTERN _NextByte FileByte;
EXTERN _NextByte LineByte;
EXTERN CHAR (*NextByte)(VOID);//GetBackArray
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
VOID InitialNextByte(VOID);
_FileHandle *RunFile(_eFileDevice, CHAR *, INT, XCALLBACK);
VOID EndFile(VOID);
VOID AssignNextByte(_NextByte *);
VOID ReturnNextByte(_NextByte *);
CHAR DirectNextByte(VOID);
BOOL DirectCheckByte(VOID);
BOOL CheckByte(VOID);
VOID BackByte(CHAR);
VOID ClearParserPool(VOID);
BOOL BackParsePool(VOID);
VOID SetDirectIgnoreLF(BOOL);
VOID IgnoreFollowLF(VOID);
VOID RemoveLF(VOID);
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
Parser.c 。。。。。。。。。。。。。。。。。。。。。。。。。
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define PARSER_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 *
* *
******************************************************************************/
/******************************************************************************
* *
* U S 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 <stdlib.h>
#include "Common.h"
#include "XCore.h"
#include "XText.h"
#include "XCodePage.h"
#include "XFunction.h"
#include "Dpl\Dpl.h"
#include "Zpl2\Zpl2.h"
#include "Epl2\Epl2.h"
#include "Tspl\Tspl.h"
#include "Bsc\Bsc.h"
#include "Parser.h"
#include "ParserUtil.h"
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
STATIC BOOL InitialImgBuf(WORD);
STATIC VOID CheckAutoRun(VOID);
STATIC VOID RemoveUnuseByte(VOID);
STATIC VOID RemoveInvalidByte(VOID);
STATIC BOOL ByteOrderMarkDecoding(VOID);
/******************************************************************************
* *
* 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.
*
******************************************************************************/
VOID InitialParser(VOID)
{
WORD LabelSize;
#ifdef DEBUG_PRNT
sysprintf("Enter InitialParser()...\n"); // ch_20211213
#endif
pPrintCfg = GrabPrintConfig();
pPrintRec = GrabPrintRecord();
#ifdef DEBUG_PRNT
sysprintf("pPrintCfg->GapReverse = %d\n", pPrintCfg->GapReverse); // ch_20211213
#endif
UartSetting(pPrintCfg->UartSetting);
SetGapSensorReverse(pPrintCfg->GapReverse);
LabelSize = (WORD)CalculateLabelSize(pPrintCfg);
InitialImgBuf(LabelSize);
#if defined(AGFA_TTF)
InitUFST();
#endif
InitialBsc();
#if defined(TSPL)
InitialTspl();
#endif
#if defined(EPL2)
InitialEpl2();
#endif
#if defined(ZPL2)
InitialZpl2();
#endif
#if defined(DPL)
InitialDpl();
#endif
InitialUtil();
}
extern int CheckChipId(void);
VOID Parser(VOID) //<--AppMain(VOID)
{
#ifdef DEBUG_PRNT
sysprintf("Enter Parser()...\n"); // ch_20211209
#endif
CheckAutoRun();
#if defined(EPL2)
LineMode();
#endif
if(CheckChipId() != SUCCESS){
//~{P#QiJ'0\~}
//while(1);
}
// sysprintf("check id success!!\r\n");
while (1) //刚上电执行1次，下发打印开始执行几次
{
// sysprintf("12—!!\r\n");
#if 0
RemoveUnuseByte();
if (ByteOrderMarkDecoding())
continue;
if (BscSyntaxParsing())
continue;
if(PosSyntaxParsing()){
continue;
}
#if defined(TSPL)
if (TscSyntaxParsing())
continue;
#endif
RemoveInvalidByte();
#else
RemoveUnuseByte();
if (ByteOrderMarkDecoding())
continue;
#if defined(DPL)
if (DatamaxSyntaxParsing())
continue;
#endif
#if defined(ZPL2)
if (ZebraSyntaxParsing()) //斑马指令解析
continue;
#endif
#if defined(EPL2)
if (EltronSyntaxParsing())
continue;
#endif
if (BscSyntaxParsing())
continue;
#if defined(TSPL)
if (TscSyntaxParsing()) //
continue;
#endif
RemoveInvalidByte(); //移除无效字节
#endif
}
}
//
STATIC BOOL InitialImgBuf(WORD Height)
{
// if can't get image point
sImageBuffer.iByteWidth = TPH_WIDTH_BYTE;
sImageBuffer.iWidth = TPH_WIDTH_DOT;
sImageBuffer.iHeight = Height;
sImageBuffer.iFirstLine = sImageBuffer.iHeight - 1;
sImageBuffer.iLastLine = 0;
if (!AllocImageBuffer(&sImageBuffer))
return FALSE;
ClearImageBuffer(&sImageBuffer);
return TRUE;
}
STATIC VOID CheckAutoRun(VOID)
{
if (!pPrintCfg->IgnoreAutoRun)
{
CheckAutoUpdate();
#if defined(ZPL2)
CheckAutoFmt();
#endif
#if defined(EPL2)
CheckAutoForm();
#endif
#if defined(TSPL)
CheckAutoBas();
#endif
}
pPrintCfg->IgnoreAutoRun = FALSE;
}
/
STATIC VOID RemoveUnuseByte(VOID)
{
CHAR PrefixFmt[16] = "";
CHAR Data;
#if defined(DPL)
DplPrefixRule(PrefixFmt);
#endif
#if defined(ZPL2)
Zpl2PrefixRule(PrefixFmt);
#endif
// remove unuse byte
while (1)
{
Data = NextByte();
if (Data != NUL_CHAR && !CheckChar(Data, "\r\n\t\x0c\x1a ")){
break;
}
if (CheckChar(Data, PrefixFmt))
break;
}
BackByte(Data);
}
STATIC VOID RemoveInvalidByte(VOID)
{
CHAR PrefixFmt[16] = "";
BYTE Data;
#if defined(DPL)
DplPrefixRule(PrefixFmt);
#endif
#if defined(ZPL2)
Zpl2PrefixRule(PrefixFmt);
#endif
Data = NextByte();
if (CheckChar(Data, PrefixFmt))
Data = NextByte();
while (!CheckChar(Data, "\r\n\x1a") && !CheckChar(Data, PrefixFmt))
Data = NextByte();
if (Data == '\r')
IgnoreFollowLF();
else if (CheckChar(Data, PrefixFmt))
BackByte(Data);
}
STATIC BOOL ByteOrderMarkDecoding(VOID)
{
ClearParserPool();
// The UTF-8 representation of the BOM is the byte sequence 0xEF,0xBB,0xBF
if (NextByte() == '\xEF' && NextByte() == '\xBB' && NextByte() == '\xBF')
{
#if defined(ZPL2)
Zpl2SingleCharacterSet(28);
#endif
SetCodePage("UTF-8");
return TRUE;
}
if (!BackParsePool())
return TRUE;
return FALSE;
}
Parser.h 、、、、、、、、、、、、、、、、、、、、、、、、、、、
#ifndef PARSER_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define PARSER_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 "XImgMgr.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 DENSITY_MAX 15
#define DENSITY_MIN 0
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
typedef enum
{
DEBUG_LABEL,
DEBUG_RS232,
DEBUG_OFF,
}_eDebugMode;
typedef enum
{
OUTPUT_LABEL,
OUTPUT_RS232,
}_OutputWay;
typedef struct _Report REPORT;
struct _Report
{
REPORT *next;
REPORT *prev;
_OutputWay way;
CHAR buf[64][64];
INT num;
};
/******************************************************************************
* *
* 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 PARSER_C
#define EXTERN
#else
#define EXTERN extern
#endif
EXTERN _ImgBuf sImageBuffer; // sImage data
EXTERN SHORT DensityMax;
EXTERN SHORT DensityMin;
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
//--- Parser ---//
VOID InitialParser(VOID);
VOID Parser(VOID);
//--- ParserUtil ---//
INT SpeedRange(FLOAT);
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
ParserUtil.c 、、、、、、、、、、、、、、、、、、、、、
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define PARSERUTIL_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 <ctype.h>
#include <stdio.h>
#include <stdlib.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 "XCore.h"
#include "XText.h"
#include "XProFile.h"
#include "XFileSys.h"
#include "XFunction.h"
#include "Parser.h"
#include "ParserUtil.h"
extern _CalResult* GetCalResult(VOID); // ch_20220705
/******************************************************************************
* *
* L O C A L D E F I N E S *
* *
******************************************************************************/
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
STATIC BOOL RoundCoordinateX;
VOID InitialUtil(VOID)
{
CHAR Buf[128];
FLOAT data;
InitialNextByte();
RoundCoordinateX = TRUE;
if (GetProfileString("X-COORDINATE", Buf))
{
if (strcmp("ROUND", Buf) == 0)
RoundCoordinateX = TRUE;
if (strcmp("OVER", Buf) == 0)
RoundCoordinateX = FALSE;
}
ReferenceXBase = 0;
if (GetProfileInt("X BASE REFERENCE", &data))
ReferenceXBase = (SHORT)data;
ReferenceYBase = 0;
if (GetProfileInt("Y BASE REFERENCE", &data))
ReferenceYBase = (SHORT)data;
ShiftXBase = 0;
if (GetProfileInt("SHIFT XBASE", &data))
ShiftXBase = (SHORT)data;
DensityMax = DENSITY_MAX;
if (GetProfileInt("DENSITY OF MAXIMUM", &data))
DensityMax = (SHORT)data;
DensityMin = DENSITY_MIN;
if (GetProfileInt("DENSITY OF MINIMUM", &data))
DensityMin = (SHORT)data;
}
VOID SyntaxIgnoreCommand(CHAR *input, _CmdEntry *entry, CONST _EntryLink *link, INT (*ignore)(VOID))
{
_EntryLink *EntryLink;
_CmdEntry *CmdEntry;
CHAR key, cmd[2];
INT num = 0, words = 1;
while (*input != '\0')
{
key = *input++;
switch (key)
{
case '[': // entry two words
words = 2;
break;
case ']': // exit two words
words = 1;
break;
case '#': // hex format
key = ((isdigit(*input) ? *input++ - '0' : toupper(*input++) - 'A' + 10) << 4);
key |= (isdigit(*input) ? *input++ - '0' : toupper(*input++) - 'A' + 10);
default:
cmd[num++] = key;
}
if (num == words)
{
if (num == 1)
{
// ignore first word command
if (CmdEntry = CheckSingleCommand(cmd[0], entry))
CmdEntry->func = ignore;
}
if (num == 2)
{
// ignore two words command
for (EntryLink = (_EntryLink *)link; EntryLink->keyword; EntryLink++)
{
if (*EntryLink->keyword == cmd[0])
{
if (CmdEntry = CheckSingleCommand(cmd[1], EntryLink->entry))
CmdEntry->func = ignore;
break;
}
}
}
num = 0;
}
}
}
//
_CmdEntry *CheckSingleCommand(CHAR cmd, CONST _CmdEntry *CmdEntry)
{
while (CmdEntry->keyword)
{
if (*CmdEntry->keyword == cmd)
return (_CmdEntry *)CmdEntry;
CmdEntry++;
}
return (_CmdEntry *)_NULL;
}
///
_CmdEntry *CheckStringCommand(CHAR *pToken, CONST _CmdEntry *CmdEntry)
{
while (CmdEntry->keyword)
{
if (strcmp(pToken, CmdEntry->keyword) == 0){
//sysprintf("-->check string key ok --%s\r\n",CmdEntry->keyword);
return (_CmdEntry *)CmdEntry;
}
CmdEntry++;
}
return (_CmdEntry *)_NULL;
}
BOOL CheckChar(CHAR Data, CHAR *pString)
{
while (*pString != '\0')
{
if (Data == *pString)
return TRUE;
pString += 1;
}
return FALSE;
}
BOOL CompareKeyword(CHAR Data, CHAR *Keyword, CHAR *BackData, SHORT *BackLen)
{
STATIC SHORT index = 0;
if (*(Keyword + index++) == Data)
{
*BackLen = 0;
if (*(Keyword + index) == '\0')
{
index = 0;
return TRUE;
}
}
else
{
*BackLen = index;
while (--index)
*BackData++ = *Keyword++;
*BackData = Data;
}
return FALSE;
}
CHAR *SearchLineKeyWord(CHAR *LinePtr, CHAR *KeyWord)
{
while (*LinePtr != '\0')
{
if (*LinePtr == *KeyWord)
{
if (strncmp(LinePtr, KeyWord, strlen(KeyWord) ) == 0)
return LinePtr;
}
LinePtr += 1;
}
return _NULL;
}
BOOL IsNumber(CHAR Data)
{
//If the first character is a sign character
if ((Data == '+') || (Data == '-') || (Data == '.') || isdigit(Data))
return TRUE;
else
return FALSE;
}
BOOL CheckTokenIsNumber(CHAR *pToken)
{
INT i;
for (i = 0; i < strlen(pToken); i++)
{
if (IsNumber(*(pToken + i)) == FALSE)
return FALSE;
}
return TRUE;
}
VOID RemoveSpace(VOID)
{
BYTE Data = NextByte();
while (CheckChar(Data, "\t ") || (Data == _NULL))
Data = NextByte();
BackByte(Data);
}
VOID RemoveLine(VOID)
{
BYTE Data = NextByte();
while (!CheckChar(Data, "\r\n\x1a"))
Data = NextByte();
if (Data == '\r')
IgnoreFollowLF();
}
INT GetToken(CHAR *pToken, CHAR *pEndChar, CHAR *pEndString, INT LimitLen)
{
CHAR Temp;
INT TokenLen = 0;
Temp = NextByte();
#ifdef DEBUG_PRNT
sysprintf("%c", Temp); // ch_20220107
#endif
while (!CheckChar(Temp, pEndString))
{
if (Temp != _NULL)
{
*pToken++ = Temp;
TokenLen += 1;
}
Temp = NextByte();
#ifdef DEBUG_PRNT
sysprintf("%c", Temp); // ch_20220107
#endif
if (TokenLen >= LimitLen - 1)
break;
}
*pToken = '\0';
*pEndChar = Temp;
return TokenLen;
}
BOOL CheckTokenEnd(_eTokenEndMode Mode, CHAR EndChar)
{
switch (Mode)
{
case BACK_WITH_SPACE:
case BACK_WITHOUT_SPACE:
BackByte(EndChar);
break;
case COMMA_END:
if (!CheckChar(EndChar, ",;"))
{
BackByte(EndChar);
return FALSE;
}
break;
case LINE_END:
if (!CheckChar(EndChar, "\r\n"))
{
BackByte(EndChar);
return FALSE;
}
// if first is CR
if (CheckChar(EndChar, "\r"))
IgnoreFollowLF();
break;
case SPACE_END:
if (!CheckChar(EndChar, " \t"))
{
BackByte(EndChar);
return FALSE;
}
break;
}
return TRUE;
}
SHORT XCoord(SHORT X)
{
if (pPrintCfg->Direction ^ pPrintCfg->Mirror)
X = X + pPrintCfg->ReferenceX + ReferenceXBase + pPrintCfg->ShiftDisX + ShiftXBase;
else
X = X + pPrintCfg->ReferenceX + ReferenceXBase - pPrintCfg->ShiftDisX - ShiftXBase;
#if defined(LEFT_ALIGN)
if (!(pPrintCfg->Direction ^ pPrintCfg->Mirror))
X += (TPH_WIDTH_DOT - pPrintCfg->PaperWidth);
#else
if (pPrintCfg->PaperWidth > TPH_WIDTH_DOT) { // ch_20220519
X -= (pPrintCfg->PaperWidth - TPH_WIDTH_DOT) >> 1; // ch_20220519
}
else
X += (TPH_WIDTH_DOT - pPrintCfg->PaperWidth) >> 1;
#endif
//sysprintf("X%d,", X); // ch_20220110
return X;
}
SHORT YCoord(SHORT Y)
{
_CalResult* pCalRslt = NULL; // ch_20220705
pCalRslt = GetCalResult(); // ch_20220705
Y += pPrintCfg->ReferenceY + ReferenceYBase;
//sysprintf("Y%d,", Y); // ch_20220110
// ch_20220818 : no offset.
if ((CONTINUE_MODE_T!=pCalRslt->SensorMode)&&(CONTINUE_MODE_R!=pCalRslt->SensorMode)) // ch_20220705 : when add 8, cannot print with the continuous paper.
if ((CONTINUE_MODE_T!=pCalRslt->SensorMode)&&(CONTINUE_MODE_R!=pCalRslt->SensorMode)&&
(CONTINUE_MODE_T!=pPrintCfg->SensorMode)&&(CONTINUE_MODE_R!=pPrintCfg->SensorMode)) // ch_20220721 : directly print with the continuous paper without calibrating the paper.
//if ((CONTINUE_MODE_T!=pCalRslt->SensorMode)&&(CONTINUE_MODE_R!=pCalRslt->SensorMode)&&
// (CONTINUE_MODE_T!=pPrintCfg->SensorMode)&&(CONTINUE_MODE_R!=pPrintCfg->SensorMode)&&
// (FEED_JOB!=GetPrevWorkType())) // ch_20220726 : not execute this if the previous work-type is FEED.
// Y += 1*4; // ch_20220817 : changed to (1*4) from (2*4). // ch_20220713 : add (2*4) to solve the offset to the bottom.
return Y;
}
_Coord XYCoord(_Coord Coord)
{
if (RoundCoordinateX)
{
Coord.iX = abs(Coord.iX);
Coord.iY = abs(Coord.iY);
Coord.iY += Coord.iX / pPrintCfg->PaperWidth;
Coord.iX %= pPrintCfg->PaperWidth;
}
Coord.iX = XCoord(Coord.iX);
Coord.iY = YCoord(Coord.iY);
//sysprintf("Coord.iX%d,Coord.iY%d\n", Coord.iX, Coord.iY); // ch_20220110
return Coord;
}
INT SpeedRange(FLOAT Speed)
{
INT ret;
ret = ToMotorSpeed(Speed);
if (ret > PRINT_SPEED_MAX)
ret = PRINT_SPEED_MAX;
if (ret < PRINT_SPEED_MIN)
ret = PRINT_SPEED_MIN;
return ret;
}
_BarcodeTable *CheckBarcodeTable(CHAR *pToken, CONST _BarcodeTable *psBarcodeTab)
{
while (psBarcodeTab->pBarcodeName)
{
if (strcmp(pToken, psBarcodeTab->pBarcodeName) == 0)
return (_BarcodeTable *)psBarcodeTab;
psBarcodeTab++;
}
return (_BarcodeTable *)_NULL;
}
INT NotBarcode(_BarCodeAttr *pBarcodeAttr)
{
pBarcodeAttr->TotalWidth = 0;
pBarcodeAttr->TotalHeight = 0;
return TRUE;
}
INT GetFileSize(_eFileDevice device, CHAR *filename)
{
_FileList list;
INT size = 0;
OpenList(&list, device);
while (NextFile(&list, filename))
size += list.FileSize;
return size;
}
INT GetFileTotal(_eFileDevice device, CHAR *filename)
{
_FileList list;
INT total = 0;
OpenList(&list, device);
while (NextFile(&list, filename))
total += 1;
return total;
}
_TextAttr *PutText(INT x, INT y, BYTE *font, INT xmul, INT ymul, BYTE *exp, _eLanguage lang)
{
STATIC _TextAttr text;
text.sCoord.iX = x;
text.sCoord.iY = y;
text.pFont = font;
text.iDirection = 0;
text.iRotation = 0;
text.iHoriMulti = xmul;
text.iVertMulti = xmul;
text.ExpLength = strlen((CHAR *)exp);
text.pExp = exp;
text.eLanguage = lang;
text.ePutWay = PUT_OR;
text.psImageBuffer = &sImageBuffer;
ReloadWaitTime();
OutText(&text);
return &text;
}
INT PrintLine(INT x, INT y, INT top, CHAR *font, INT h, CHAR *exp, _PrintCfg *cfg, _eLanguage lang)
{
PutText(x, y, (BYTE *)font, 1, 1, (BYTE *)exp, lang);
y = CheckPrint(y + h, top, h, cfg);
return y;
}
INT CheckPrint(INT y, INT top, INT h, _PrintCfg *cfg)
{
if (y + h > (WORD)cfg->fPaperSize)
{
// sysprintf("PB_4\n");
PrintBatch(0, 1, cfg, &sImageBuffer, TRUE, 0, 1, 0, _NULL);
while (!AllocImageBuffer(&sImageBuffer))
NutSleep(10);
ClearImageBuffer(&sImageBuffer);
return top;
}
return y;
}
REPORT *OpenReport(_OutputWay way)
{
REPORT *report = malloc(sizeof(REPORT));
if (report)
{
report->next = report;
report->prev = report;
report->way = way;
report->num = (-1);
}
return report;
}
VOID WriteReport(REPORT *report, CONST CHAR *fmt, ...)
{
va_list args;
CHAR printbuf[128];
va_start(args, fmt);
vsprintf(printbuf, fmt, args);
va_end(args);
if (report == NULL)
return;
if (report->way == OUTPUT_LABEL)
{
report = report->prev;
if (report->num < 0 || report->num >= 64)
{
REPORT *create = OpenReport(report->way);
if (create)
{
create->prev = report;
create->next = report->next;
report->next->prev = create;
report->next = create;
report = report->next;
report->num = 0;
}
}
if (report->num >= 0 && report->num < 64)
strcpy((CHAR *)report->buf[report->num++], printbuf);
}
if (report->way == OUTPUT_RS232)
SendPrintf("%s\r\n", printbuf);
}
VOID PatternReport(REPORT *report, INT length)
{
if (report == NULL)
return;
if (report->way == OUTPUT_LABEL)
{
REPORT *create = OpenReport(report->way);
if (create)
{
create->next = report;
create->prev = report->prev;
report->prev->next = create;
report->prev = create;
create->num = 0 - length;
}
}
}
VOID CloseReport(REPORT *report, _PrintCfg *cfg, INT x, INT y, INT h, CHAR *font, _eLanguage lang)
{
REPORT *pos, *tmp;
BYTE *img = sImageBuffer.pBuffer;
INT w = sImageBuffer.iByteWidth;
INT s = cfg->fPaperSize;
INT n, top = y;
if (report == NULL)
return;
if (report->way == OUTPUT_LABEL)
{
ClearImageBuffer(&sImageBuffer);
for (pos = report->prev; pos != report; pos = pos->prev)
{
while (pos->num)
{
/* Calculation of the y coordinate */
for (y = top, tmp = report->next; tmp != report; tmp = tmp->next)
if (tmp->num < 0) y += abs(tmp->num) + top;
else for (n = 0; n < tmp->num; n++, y = (y + h > s) ? top + h : y + h);
/* Draw pattern */
if (pos->num < 0)
for (pos->num = pos->num / 8 * 8; pos->num; pos->num += 8)
memset(img + (y + pos->num - top) * w, 0x88 >> abs(pos->num / 8 % 4), w * 8);
/* Output text */
else
PutText(x, y - h, (BYTE *)font, 1, 1, (BYTE *)pos->buf[--pos->num], lang);
/* Check to print */
if ((y - h) == top)
{
// sysprintf("PB_3\n");
PrintBatch(0, 1, cfg, &sImageBuffer, TRUE, 0, 1, 0, _NULL);
while (!AllocImageBuffer(&sImageBuffer))
NutSleep(10);
ClearImageBuffer(&sImageBuffer);
}
}
}
}
/* Free all occupied memory */
for (pos = report->prev, tmp = pos->prev; pos != report; pos = tmp, tmp = pos->prev)
free(pos);
free(pos);
}
// ch_20220210
VOID CloseReport4SelfTestPrint(REPORT *report, _PrintCfg *cfg, INT x, INT y, INT h, CHAR *font, _eLanguage lang)
{
REPORT *pos, *tmp;
BYTE *img = sImageBuffer.pBuffer;
INT w = sImageBuffer.iByteWidth;
INT s = cfg->fPaperSize;
FLOAT fPaperSize_bak = 0; // ch_20220210
INT n, top = y;
#ifdef DEBUG_PRNT
sysprintf("cfg->fPaperSize = %d\n", s); // ch_20220210
#endif
if (report == NULL)
return;
// ch_20220210
if ((GAP_MODE != cfg->SensorMode) && (s < 786))
{
fPaperSize_bak = cfg->fPaperSize;
cfg->fPaperSize = 800;
s = cfg->fPaperSize;
}
if (report->way == OUTPUT_LABEL)
{
ClearImageBuffer(&sImageBuffer);
for (pos = report->prev; pos != report; pos = pos->prev)
{
while (pos->num)
{
/* Calculation of the y coordinate */
for (y = top, tmp = report->next; tmp != report; tmp = tmp->next)
if (tmp->num < 0) y += abs(tmp->num) + top;
else for (n = 0; n < tmp->num; n++, y = (y + h > s) ? top + h : y + h);
/* Draw pattern */
if (pos->num < 0)
for (pos->num = pos->num / 8 * 8; pos->num; pos->num += 8)
memset(img + (y + pos->num - top) * w, 0x88 >> abs(pos->num / 8 % 4), w * 8);
/* Output text */
else
PutText(x, y - h, (BYTE *)font, 1, 1, (BYTE *)pos->buf[--pos->num], lang);
/* Check to print */
if ((y - h) == top)
{
// sysprintf("PB_2\n");
PrintBatch(0, 1, cfg, &sImageBuffer, TRUE, 0, 1, 0, _NULL);
while (!AllocImageBuffer(&sImageBuffer))
NutSleep(10);
ClearImageBuffer(&sImageBuffer);
}
}
}
}
/* Free all occupied memory */
for (pos = report->prev, tmp = pos->prev; pos != report; pos = tmp, tmp = pos->prev)
free(pos);
free(pos);
// ch_20220210
if ((GAP_MODE != cfg->SensorMode) && (s == 800))
{
cfg->fPaperSize = fPaperSize_bak;
}
}
ParserUtil.h 。。。。。。。。。。。。。。。。。。。。。。。
#ifndef PARSERUTIL_H
/******************************************************************************
* *
* M O D U L E D E F I N E *
* *
******************************************************************************/
#define PARSERUTIL_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 "XText.h"
#include "XBarcode.h"
#include "XMotor.h"
#include "XVarBank.h"
#include "NextByte.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 HUGE_LEN 16384
#define LONG_STR_LEN 4096
#define STRING_LEN 1024
#define PROMPT_LEN 256
#define EXPRESS_LEN 256
#define TOKEN_LEN 32
#define FONT_NAME_MAX 16
#define INTEGER_MAX_LEN 12
#if defined(TTP245P) || defined(TDP245P)
#define PRINT_SPEED_MAX SPEED(5)
#define PRINT_SPEED_MIN SPEED(2)
#elif defined(TTP345) || defined(TDP345)
#define PRINT_SPEED_MAX SPEED(5)
#define PRINT_SPEED_MIN SPEED(1.5)
//#elif defined(XPH500B) || defined(XP450B) || defined(XPH400B) || defined(DELUXE_2045)
//#define PRINT_SPEED_MAX SPEED(5)
//#define PRINT_SPEED_MIN SPEED(2)
#elif defined(XPH500E) ||defined(DELUXE_3044) ||defined(DELUXE_2044) ||defined(XPH400B)
#define PRINT_SPEED_MAX SPEED(4)
#define PRINT_SPEED_MIN SPEED(2)
#elif defined(XPDT427B)
#define PRINT_SPEED_MAX SPEED(5)
#define PRINT_SPEED_MIN SPEED(2)
#elif defined(XPDT108BLABEL)
#define PRINT_SPEED_MAX SPEED(5)
#define PRINT_SPEED_MIN SPEED(1)
#else
#define PRINT_SPEED_MAX SPEED(5)
#define PRINT_SPEED_MIN SPEED(2)
#endif
/******************************************************************************
* *
* S T R U C T U R E D E F I N I T I O N S *
* *
******************************************************************************/
typedef enum
{
BACK_WITH_SPACE,
BACK_WITHOUT_SPACE,
COMMA_END,
LINE_END,
SPACE_END,
STRING_END,
}_eTokenEndMode;
typedef enum
{
BARCODE_NOAMAL_FONT,
BARCODE_OCR_FONT,
}_eBarcodeFontType;
typedef struct
{
CHAR *pBarcodeName; //用于存储条形码的名称或标识符的字符串指针
BARCODEFUNC PreviewBarcode; //函数指针，指向一个函数，用于预览条形码
BARCODEFUNC OutBarcode; //函数指针，指向一个函数，用于输出条形码
SHORT Check; //一个短整型变量，可能用于标识条形码的检查值
CHAR *FontName; //用于存储字体名称的字符串指针
_eBarcodeFontType FontType; //表示条形码字体类型的枚举变量
CONST WORD *pEraseWidth; //指向常量单词宽度的指针
WORD Shift; //表示偏移量的单词变量
}_BarcodeTable;
typedef struct
{
CHAR *keyword;
INT (*func)(VOID);
}_CmdEntry;
typedef struct
{
CHAR *keyword;
_CmdEntry *entry;
}_EntryLink;
typedef struct
{
_FileHandle *UseHandle;
WORD ErrorNumber;
CHAR *LinePtr;
CHAR LineBuf[STRING_LEN];
}_BasicData;
/******************************************************************************
* *
* 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 PARSERUTIL_C
#define EXTERN
#else
#define EXTERN extern
#endif
// basic data
EXTERN _BasicData sBasicData;
EXTERN _PrintCfg *pPrintCfg; // priner config data point
EXTERN _PrintRecord *pPrintRec; // printer record
EXTERN SHORT ReferenceXBase;
EXTERN SHORT ReferenceYBase;
EXTERN SHORT ShiftXBase;
/******************************************************************************
* *
* 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 *
* *
******************************************************************************/
#ifdef PARSERUTIL_C
// first 6 is none human readable, sencond 6 is human readable
CONST WORD WidthEan13[] = { 95, 190, 285, 380, 475, 570, 103, 206, 309, 412, 515, 618 };
CONST WORD WidthEan13_2[] = { 125, 250, 375, 500, 625, 750, 133, 266, 399, 532, 665, 798 };
CONST WORD WidthEan13_5[] = { 152, 304, 456, 608, 760, 912, 160, 320, 480, 640, 800, 960 };
CONST WORD WidthEan8[] = { 68, 136, 204, 272, 340, 408, 68, 136, 204, 272, 340, 408 };
CONST WORD WidthEan8_2[] = { 97, 194, 291, 388, 485, 582, 97, 194, 291, 388, 485, 582 };
CONST WORD WidthEan8_5[] = { 124, 248, 372, 496, 620, 744, 124, 248, 372, 496, 620, 744 };
CONST WORD WidthUpca[] = { 95, 190, 285, 380, 475, 570, 111, 222, 333, 444, 555, 666 };
CONST WORD WidthUpca_2[] = { 126, 252, 378, 504, 630, 756, 134, 268, 402, 536, 670, 804 };
CONST WORD WidthUpca_5[] = { 152, 304, 456, 608, 760, 912, 160, 320, 480, 640, 800, 960 };
CONST WORD WidthUpce[] = { 50, 100, 150, 200, 250, 300, 66, 132, 198, 264, 330, 396 };
CONST WORD WidthUpce_2[] = { 81, 162, 243, 324, 405, 486, 89, 178, 267, 356, 445, 534 };
CONST WORD WidthUpce_5[] = { 108, 216, 324, 432, 540, 648, 116, 232, 348, 464, 580, 696 };
CONST _EntryLink DummyLink[] = {(CHAR *)_NULL, _NULL};
#else
EXTERN CONST WORD WidthEan13[];
EXTERN CONST WORD WidthEan13_2[];
EXTERN CONST WORD WidthEan13_5[];
EXTERN CONST WORD WidthEan8[];
EXTERN CONST WORD WidthEan8_2[];
EXTERN CONST WORD WidthEan8_5[];
EXTERN CONST WORD WidthUpca[];
EXTERN CONST WORD WidthUpca_2[];
EXTERN CONST WORD WidthUpca_5[];
EXTERN CONST WORD WidthUpce[];
EXTERN CONST WORD WidthUpce_2[];
EXTERN CONST WORD WidthUpce_5[];
EXTERN CONST _EntryLink DummyLink[];
#endif
/******************************************************************************
* *
* F U N C T I O N P R O T O T Y P E S *
* *
******************************************************************************/
VOID InitialUtil(VOID);
VOID SyntaxIgnoreCommand(CHAR *, _CmdEntry *, CONST _EntryLink *, INT (*)(VOID));
_CmdEntry *CheckSingleCommand(CHAR, CONST _CmdEntry *);
_CmdEntry *CheckStringCommand(CHAR *, CONST _CmdEntry *);
BOOL CheckChar(CHAR , CHAR *);
BOOL CompareKeyword(CHAR, CHAR *, CHAR *, SHORT *);
CHAR *SearchLineKeyWord(CHAR *, CHAR *);
BOOL IsNumber(CHAR);
BOOL CheckTokenIsNumber(CHAR *);
VOID RemoveSpace(VOID);
VOID RemoveLine(VOID);
INT GetToken(CHAR *, CHAR *, CHAR *, INT);
BOOL CheckTokenEnd(_eTokenEndMode, CHAR);
SHORT XCoord(SHORT);
SHORT YCoord(SHORT);
_Coord XYCoord(_Coord);
_BarcodeTable *CheckBarcodeTable(CHAR *, CONST _BarcodeTable *);
INT NotBarcode(_BarCodeAttr *);
INT GetFileSize(_eFileDevice, CHAR *);
INT GetFileTotal(_eFileDevice, CHAR *);
_TextAttr *PutText(INT, INT, BYTE *, INT, INT, BYTE *, _eLanguage);
INT PrintLine(INT, INT, INT, CHAR *, INT, CHAR *, _PrintCfg *, _eLanguage);
INT CheckPrint(INT, INT, INT, _PrintCfg *);
REPORT *OpenReport(_OutputWay);
VOID WriteReport(REPORT *, CONST CHAR *, ...);
VOID PatternReport(REPORT *, INT);
VOID CloseReport(REPORT *, _PrintCfg *, INT, INT, INT, CHAR *, _eLanguage);
VOID CloseReport4SelfTestPrint(REPORT *report, _PrintCfg *cfg, INT x, INT y, INT h, CHAR *font, _eLanguage lang); // ch_20220210
#undef EXTERN
#ifdef __cplusplus
} /* End of extern "C" { */
#endif /* __cplusplus */
#endif
447
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
