📄 pack.c
字号:
#include "..\sys\include.h"
#ifndef _PACK
#define _PACK
#include "pack.h"
#endif
#define FLATMARK 30
#define SOLIDMARK 30
static struct FlatPackControl_t PackControl[FLATMARK]; //平面打解包控制结构
static int FlatPackFlag[FLATMARK];
static struct tree_control_t2 tree_control1;
static struct tree_control_t2 tree_control2[SOLIDMARK];
static int SolidPackFlag[SOLIDMARK];
static int FlatResourceSelector;
static int SolidResourceSelector;
int AllocFlatResource()
{
int i,j;
for(j=0;j<FLATMARK;j++)
{
i=(j+FlatResourceSelector)%FLATMARK;
if(FlatPackFlag[i]==0)
{
FlatPackFlag[i]=1;
FlatResourceSelector=i+1;
return i;
}
}
return -1;
}
int AllocSolidResource()
{
int i,j;
for(j=0;j<SOLIDMARK;j++)
{
i=(j+SolidResourceSelector)%SOLIDMARK;
if(SolidPackFlag[i]==0)
{
SolidPackFlag[i]=1;
SolidResourceSelector=i+1;
return i;
}
}
return -1;
}
int FreeFlatResource(int pid)
{
if(pid>=0 && pid<FLATMARK)
FlatPackFlag[pid]=0;
return 0;
}
int FreeSolidResource(int pid)
{
if(pid>=0 && pid<SOLIDMARK)
SolidPackFlag[pid]=0;
return 0;
}
//***********************************
// 一次性打包函数FlatPack *
//***********************************
int InitPackSystem()
{
memset(PackControl,0,FLATMARK*sizeof(struct FlatPackControl_t));
memset(tree_control2,0,SOLIDMARK*sizeof(struct tree_control_t2));
memset(FlatPackFlag,0,FLATMARK*4);
memset(SolidPackFlag,0,SOLIDMARK*4);
FlatResourceSelector=0;
SolidResourceSelector=0;
return 0;
}
//*******************************************
// 底层函数 *
// 实现 宽度，位序，压缩 描述符 *
// flag_RS--位序,flag_pack--压缩 *
// buf->协议数据区，s->编程数据区 *
// 返回值 失败:0 成功:协议数据区宽度 *
//*******************************************
int SubPackIt(BYTE * buf,BYTE * s,int width,int flag_RS,int flag_pack)
{
int i,j,k;
//对一些特殊宽度进行处理
if(width==-1) return 0; //如由n描述符读入的宽度<=0,则返回0
else if(width==0)
width=1; //如由数字读入的宽度==0,则将宽度定为1
if (flag_pack==0) //若无压缩描述符，处理如下
{
switch(flag_RS) //根据不同的位序描述符进行处理
{
case 0: //无位序描述符
memcpy(buf,s,width);
return width;
case 1:
for (i=0,j=width-1;i<width;i++,j--) buf[i]=s[j]; // 整串反序
return width;
case 2: // 单字反序
for (i=0;i<width;i=i+2)
for (k=i,j=i+1;k<i+2;k++,j--) buf[k]=s[j];
return width;
case 3: // 双字反序
for (i=0;i<width;i=i+4)
for (k=i,j=i+3;k<i+4;k++,j--) buf[k]=s[j];
return width;
case 4: // 四字反序
for (i=0;i<width;i=i+8)
for (k=i,j=i+7;k<i+8;k++,j--) buf[k]=s[j];
return width;
default:
return width;
}
}
if(flag_pack==1) //#压缩描述符，处理如下
{
switch(flag_RS) //先进行位序描述符处理
{
case 0: //无位序描述符
memcpy(buf,s,width);
break;
case 1:
for (i=0,j=width-1;i<width;i++,j--) buf[i]=s[j]; // 整串反序
break;
case 2: // 单字反序
for (i=0;i<width;i=i+2)
for (k=i,j=i+1;k<i+2;k++,j--) buf[k]=s[j];
break;
case 3: // 双字反序
for (i=0;i<width;i=i+4)
for (k=i,j=i+3;k<i+4;k++,j--) buf[k]=s[j];
break;
case 4: // 四字反序
for (i=0;i<width;i=i+8)
for (k=i,j=i+7;k<i+8;k++,j--) buf[k]=s[j];
break;
default:
break;
}
if(width%2!=0) buf[width]=0;
for (i=0,j=0;j<width;i++,j=j+2) //再进行压缩
buf[i]=(buf[j]&0x0f)|(buf[j+1]<<4);
return (width+1)/2; //返回打入的协议字节数
}
if(flag_pack==2) //$压缩描述符，处理如下
{
switch(flag_RS) //先进行位序描述符处理
{
case 0: //无位序描述符
memcpy(buf,s,width);
break;
case 1:
for (i=0,j=width-1;i<width;i++,j--) buf[i]=s[j]; // 整串反序
break;
case 2: // 单字反序
for (i=0;i<width;i=i+2)
for (k=i,j=i+1;k<i+2;k++,j--) buf[k]=s[j];
break;
case 3: // 双字反序
for (i=0;i<width;i=i+4)
for (k=i,j=i+3;k<i+4;k++,j--) buf[k]=s[j];
break;
case 4: // 四字反序
for (i=0;i<width;i=i+8)
for (k=i,j=i+7;k<i+8;k++,j--) buf[k]=s[j];
break;
default:
break;
}
if(width%2!=0) buf[width]=0;
for (i=0,j=0;j<width;i++,j=j+2) //再进行压缩
buf[i]=(buf[j+1]&0x0f)|(buf[j]<<4);
return (width+1)/2; //返回打入的协议字节数
}
return 0;
}
//***********************************
// 实现F类描述符 *
// buf->协议数据区,p->编程数据区 *
// finish[] 记录格式串位置 *
//***********************************
int SubCommonSubFlatPack(BYTE * buf,BYTE * format,int format_len,
int p[],int finish[])
{
int i,len,width,state,flag_RS,flag_pack,ads_mode;
int offset,k,m,flag;
BYTE c;
// UDLONG j,temp;
unsigned long j,temp;
/* union
{
BYTE temp_byte;
WORD temp_word;
DWORD temp_dword;
DLONG temp_qword;
} temp_value;
*/
len=0; //为各计数变量赋处值
width=0;
flag_RS=0;
flag_pack=0;
ads_mode=0;
for (i=0;i<format_len;i++) //对格式串按给定长度进行一遍扫描
switch(c=format[i])
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
c-='0';
width=width*10+c; //计算宽度
break;
case 'n': //调整指向编程数据的指针
case 'N':
width=*p++;
if(width<=0) width=-1; //如由n描述符读入的宽度<=0
//则将宽度定为-1,否则不变
break;
case 'r': //记录位序描述符
flag_RS=1;
break;
case 'R':
flag_RS=2;
break;
case 's':
flag_RS=3;
break;
case 'S':
flag_RS=4;
break;
case '#': //记录压缩描述符
flag_pack=1;
break;
case '$':
flag_pack=2;
break;
case '&': //处理指针描述符
ads_mode=1;
break;
case 'f':
case 'F': //遇F类描述符即调用上层函数处理格式串
len+=SubPackIt(buf+len,(ads_mode==0) ? (BYTE *)p : (BYTE *)*p,
width,flag_RS,flag_pack);
p++; //P指针后移
ads_mode=0; //重置各计数变量
width=0;
flag_RS=0;
flag_pack=0;
break;
//遇比特描述符立即处理格式串用两个变量记录比特描述符的
case 'b': //大小写与宽度 state:宽度,flag:大小写
case 'B':
state=1;
flag=0;
goto l;
case 'w':
state=2;
flag=0;
goto l;
case 'd':
state=4;
flag=0;
goto l;
case 'q':
state=8;
flag=0;
goto l;
case 'W':
state=2;
flag=1;
goto l;
case 'D':
state=4;
flag=1;
goto l;
case 'Q':
state=8;
flag=1;
goto l;
default:
break;
l:
i++;
while(format[i]==' '&&format[i]!='\0') //移动指针，跳过空格
i++;
if(format[i]=='\0'||format[i]!='(') //若比特描述符为单个 直接将
{ //编程数据写入temp变量
// temp=(DLONG)(*p++);
temp=(unsigned long)(*p++);
goto l1;
}
else //否则按(...)中的描述符处理
{
offset=0; //将各变量置初值
k=0;
temp=0;
for(;format[i-1]!=')'&&i<format_len;i++) //若格式串不遇')' or 不超规定
switch (c=format[i]) //长度则继续扫描
{
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
c-='0';
offset=offset*10+c;
if(offset>64) offset=64;
break;
case ' ':
case ')':
if(offset==0) break; //跳过空格
// j=(DLONG)(*p++);
j=(unsigned long)(*p++);
j=j<<(64-offset); //将编程数据按要求移位
m=64-offset-k;
if(m>0) j=j>>m;
else j=j<<m;
temp|=j; //重置变量
k+=offset;
offset=0;
break;
default:
break;
}
} //上面一段程序已按比特描述符
//将编程数据写入temp中
l1:
if(flag) //按Mortorola格式填写数据
{
if(state==2) //2比特
{
j=temp;
j>>=8;
buf[len]=(BYTE)j; //先填高位字节
buf[len+1]=(BYTE)temp; //再填低位字节
}
else if(state==4) //4比特,填法与上类似
{
j=temp;
j>>=24;
buf[len]=(BYTE)j;
j=temp;
j>>=16;
buf[len+1]=(BYTE)j;
j=temp;
j>>=8;
buf[len+2]=(BYTE)j;
buf[len+3]=(BYTE)temp;
}
else //8比特,填法与上类似
{
j=temp;
j>>=56;
buf[len]=(BYTE)j;
j=temp;
j>>=48;
buf[len+1]=(BYTE)j;
j=temp;
j>>=40;
buf[len+2]=(BYTE)j;
j=temp;
j>>=32;
buf[len+3]=(BYTE)j;
j=temp;
j>>=24;
buf[len+4]=(BYTE)j;
j=temp;
j>>=16;
buf[len+5]=(BYTE)j;
j=temp;
j>>=8;
buf[len+6]=(BYTE)j;
buf[len+7]=(BYTE)temp;
}
}
else //按Intel格式填写数据
memcpy(&buf[len],&temp,state); //将处理好的编程数据赋给协议数据
i--;
len+=state;
break;
}
finish[0]=(int)p;
return len; //返回打入的协议数据字节数
}
//*******************************************
//调用上两函数，实现F类 V类 O类描述符 *
//返回值 成功：实际打入字节数 失败：0 *
//*******************************************
int CommonSubFlatPack(BYTE * buf,BYTE * format,int format_len,int p[],int finish[])
{
int i,len,j,k,m,count_of_VPart,count_of_OPart,Ooffset,flag,temp;
int pos_V[128];
int pos_O[128];
BYTE c;
if(*format=='L') flag=1;
else flag=0;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -