求将一段C++程序改写成C程序

//For Test Print

#include
#include
//#include    //for BC++45
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define PI 3.1415926
struct PointXY
{

 int x;
 int y;

};
union PrintPinType
{
 struct
 {
  char Bit0_0 :1;        //7
  char Bit0_1 :1;          //6
  char Bit0_2 :1;          //5
  char Bit0_3 :1;          //4
  char Bit0_4 :1;          //3
  char Bit0_5 :1;          //2
  char Bit0_6 :1;          //1
  char Bit0_7 :1;          //0
  char Bit1_0 :1;          //15
  char Bit1_1 :1;          //14
  char Bit1_2 :1;          //13
  char Bit1_3 :1;          //12
  char Bit1_4 :1;          //11
  char Bit1_5 :1;          //10
  char Bit1_6 :1;          //9
  char Bit1_7 :1;          //8
  char Bit2_0 :1;          //23
  char Bit2_1 :1;          //22
  char Bit2_2 :1;          //21
  char Bit2_3 :1;          //20
  char Bit2_4 :1;          //19
  char Bit2_5 :1;          //18
  char Bit2_6 :1;          //17
  char Bit2_7 :1;          //16

 }PrintPin;
 struct
 {
  char PointBB[3];
 }PrintByte;
};

class CTest
{
 public:
  CTest(){};
  ~CTest(){};
  const char *ShowReason() const { return "Exception in CTest class."; }

}; 
 PointXY CurrentXY;
 PrintPinType **Dptr;//指向PrintPinType类型的指针的指针

int MakePin(PointXY xy);
int ExplanPRintCommand(char *s,char *Dat,int &m);
PointXY Line(PointXY BegPoint,PointXY EndPoint);
PointXY LineTo(PointXY ToPoint);
int OutTextHZ(int mod,int x0,int y0,int w,char *s,int cc);
int OutText24(int x0,int y0,int w,char *s,int cc) ;
 int  Guzhang_lubo()
 {
 int t,l,m,n,Lt;
 float AA,f,*DDat[5];
 AA=15.0;//幅值
 f=50.0;//频率
 Lt=1000;         //Data size
 m=int(240/24)*6;                          // THE ROWS行
 n=240*5;                                  // THE COLUMNS

 for (t = 0; t < 5; t++)      
 { 
  if((DDat[t] = malloc float[Lt])==NULL)//new返回一个指针
  {
   cout << "DDat[] Could not allocate memory"<< endl;
  }
 } 
//-----------------------------------------------------------
//Make Print memory Dptr[m][n]
 if((Dptr = new PrintPinType*[m])==NULL)    // STEP 1: SET UP THE ROWS.
 {
  cout << "Dptr Could not allocate memory"<< endl;
 }
  for (t = 0; t < m; t++)       // STEP 2: SET UP THE COLUMNS
 { 
  if((Dptr[t] = new PrintPinType[n+1])==NULL)//每一行有多少个点
  {
   cout << "Dptr[] Could not allocate memory"<< endl;
  }
 }    
 
//Make Data
 for(l=0;l<5;l++)
 {
  for(t=0;t   DDat[l][t]=float(AA*sin(2*PI*(l+1)*f*0.0002*t));//2*pi*f*(1-6)*(0-1000)*0.02/100
 }                                                   //5个组，每个10个周期，一个周期100点采样
//Initialize Print memory
 for(l=0;l {
  for(t=0;t  {
   Dptr[l][t].PrintByte.PointBB[0]=0x00;
   Dptr[l][t].PrintByte.PointBB[1]=0x00;
   Dptr[l][t].PrintByte.PointBB[2]=0x00;
  }
 }
///*********************************************************
//打印图形到缓冲区//画出边框
 int h=m*24;//60*24
  PointXY Dot1,Dot2,LL0[5],LL1[5];
 Dot1.x=0;Dot1.y=0;     //(0,0)
 Dot2.x=0;Dot2.y=h-1;    //(0,h-1)
  Line(Dot1,Dot2);
 Dot1.x=n-1;Dot1.y=h-1;              //(n-1,h-1)
  LineTo(Dot1);
 Dot1.x=n-1;Dot1.y=0;    //(n-1,0)
  LineTo(Dot1);
 Dot1.x=0;Dot1.y=0;     //(0,0)
  LineTo(Dot1);
//n/5   
//画5条中心线**********************************************
    for(l=0;l<5;l++)
 {
       LL0[l].y=0;
       LL1[l].y=h-1;
    LL0[l].x=n/5/2+n/5*l;
       LL1[l].x=n/5/2+n/5*l;//x一样表示竖线
    Line(LL0[l],LL1[l]);
 } 
//描绘波形数据********************************************
 float ka=float(n/5.0/2.0/AA); // 确定显示的幅值(比例)，分5份，上下半轴， AA=15.0=>120;
 float kl=float(h)/Lt;   //  Lt=1000=>60*24/1000=
 for(l=0;l<5;l++)
 {
  Dot1.x=int(LL0[l].x+DDat[l][0]*ka);//水平按比例扩展
  Dot1.y=LL0[l].y;
  Dot2.x=int(LL0[l].x+DDat[l][1]*ka);
  Dot2.y=int(LL0[l].y+kl);//每次向下走KL个单位
  Line(Dot1,Dot2);
  for(t=2;t  {//确定下一个要连接的点
   Dot1.x=int(LL0[l].x+DDat[l][t]*ka);
   Dot1.y=int(LL0[l].y+kl*t);
   LineTo(Dot1);
  }
 }   
//********************************************************
//store Print Data
 char bb[30],EscStr1[30],EscStr2[30],intStr[10];
 int k;
//直接打印
 HANDLE hCom;
 DCB dcb;
 DWORD  sizestr;
   hCom = CreateFile( "COM1", GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL );
   if(hCom==(HANDLE)-1)
   {
   cout<<"打开串口失败"<   return 1;
   }
   GetCommState( hCom, &dcb );
   dcb.BaudRate = 19200;
   dcb.ByteSize = 8;
   dcb.Parity   = NOPARITY;
   dcb.StopBits = ONESTOPBIT;
   SetCommState( hCom, &dcb);
//***********************************************************
 strcpy(EscStr1,"ESC C ");
 itoa(m,intStr,10);         //把整数转换成字符串
    strcat(EscStr1+6,intStr);//拼接
 sizestr=ExplanPRintCommand("ESC @",bb,k);//该命令初始+化打印机：使打印机恢复到最初的联机状态
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC t 1",bb,k);//选择字符码表
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC 7",bb,k);//设置上限控制代码
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC R 00",bb,k);//选择国际字符子集
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC r 00",bb,k);//选择打印颜色
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC U 01",bb,k);//选择或取消单向打印
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC x 01",bb,k);//通过间距与点选择字体
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC EM 48",bb,k);//控制装纸/退纸
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("ESC 2",bb,k);//选择1/6英寸的行间距
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand(EscStr1,bb,k);//按行设置页面长度
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("CR",bb,k);//回车
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);

 sizestr=ExplanPRintCommand("CR",bb,k);//回车
 WriteFile( hCom, bb, sizestr, &sizestr, NULL);
 
 sizestr=ExplanPRintCommand("ESC J 48",bb,k);
 WriteFile( hCom, bb, sizestr, &sizestr, NULL); //执行n/216英寸的行间距

    int ll=12;
 strcpy(EscStr1,"ESC $ ");//设置绝对水平打印位置
 itoa(ll%256,intStr,10);
    strcpy(EscStr1+6,intStr);
 strcat(EscStr1+6," ");
 itoa(int(ll/256),intStr,10);
    strcat(EscStr1+6,intStr);

    strcpy(EscStr2,"ESC * m ");//设置位映射方式
 itoa(n%256,intStr,10);
    strcpy(EscStr2+8,intStr);
 strcat(EscStr2+8," ");
 itoa(int(n/256),intStr,10);
    strcat(EscStr2+8,intStr);
 for(t=0;t   {
     sizestr=ExplanPRintCommand(EscStr1,bb,k);
  WriteFile( hCom, bb, sizestr, &sizestr, NULL);
  sizestr=ExplanPRintCommand(EscStr2,bb,k);
  WriteFile( hCom, bb, sizestr, &sizestr, NULL);
  sizestr=n*sizeof(PrintPinType);
  WriteFile( hCom, Dptr[t], sizestr, &sizestr, NULL);//输出数据，图形数据
     sizestr=ExplanPRintCommand("CR",bb,k);//回车
  WriteFile( hCom, bb, sizestr, &sizestr, NULL);
  sizestr=ExplanPRintCommand("ESC J 24",bb,k);//以最小间距进行打印和进纸
  WriteFile( hCom, bb, sizestr, &sizestr, NULL);
   }
   sizestr=ExplanPRintCommand("FF",bb,k);//打印送出单页
   WriteFile( hCom, bb, sizestr, &sizestr, NULL);
   sizestr=ExplanPRintCommand("ESC @",bb,k);//初始化打印机
   WriteFile( hCom, bb, sizestr, &sizestr, NULL);

   CloseHandle(hCom);
   cout<<"Print End!!!"<

//****************************************************
 for (l = 0; l < 5; l++)      
  free[] DDat[l];
  for (t= 0; t< m; t++)
    free[] Dptr[t];                 // STEP 1: DELETE THE COLUMNS
  free[] Dptr;                      // STEP 2: DELETE THE ROWS
  return 0;
 }
 int OutTextHZ(int mod,int x0,int y0,int w,char *s,int cc)    
// 字模mod=(12:12*12,16:16*16,24:24*24),横坐标,纵坐标,字间隔,汉字字符串,旋转控制cc=(0:上,1:右,2:下,3:左)
{
 FILE *fp;
 char buffer[72];
 char str[2];
 unsigned long fpos,n;    //fpos为最终偏移动量
 register int i,j,k,m=0;
 PointXY  Dot;
 if(mod==12)
 {
  if((fp=fopen("hzk12","rb")) == NULL )
  {
   cout<< "Cann`t open hzk12 lib";
   return -1;
  }
  w+=mod;
  m=2;
  n=2L*mod;
 }
 else if(mod==16)
 {
  if((fp=fopen("hzk16","rb")) == NULL )
  {
   cout<< "Cann`t open hzk16 lib";
   return -1;
  }
  w+=mod;
  m=2;
  n=2L*mod;
 }
 else if(mod==24)
 {
  if((fp=fopen("hzk24s","rb")) == NULL )
  {
   cout<< "Cann`t open hzk24s lib";
   return -1;
  }
  w+=mod;
  m=3;
  n=3L*mod;
 }
 else
 {
  cout<< "字库选择不正确";
  return -1;
 }
    while(*s)
    {
  if(*s<0)
  {
   if(mod==24)
   {
    str[0]=(*s)-0xb0;
    str[1]=*(s+1)-0xa1;
    fpos=(str[0]*94+str[1])*n;
    fseek(fp,fpos,SEEK_SET);
    fread(buffer,n,1,fp);
    if(cc==0)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.x=x0+i;
         Dot.y=y0+8*j+k;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     x0+=w;
    }
    else if(cc==1)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.x=x0-8*j-k;
         Dot.y=y0+i;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     y0+=w;
    }
    else if(cc==2)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.x=x0-i;
         Dot.y=y0-8*j-k;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     x0-=w;
    }
    else if(cc==3)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.x=x0+8*j+k;
         Dot.y=y0-i;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     y0-=w;
    }
   }
   else
   {
    str[0]=(*s)-0xa1;
    str[1]=*(s+1)-0xa1;
    fpos=(str[0]*94+str[1])*n;
    fseek(fp,fpos,SEEK_SET);
    fread(buffer,n,1,fp);
    if(cc==0)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.x=x0+8*j+k;
         Dot.y=y0+i;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     x0+=w;
    }
    else if(cc==1)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.y=y0+8*j+k;
         Dot.x=x0-i;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     y0+=w;
    }
    else if(cc==2)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.x=x0-8*j-k;
         Dot.y=y0-i;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     x0-=w;
    }
    else if(cc==3)
    {
     for(i=0;i     {
      for(j=0;j      {
       for(k=0;k<8;k++)
       {
        if ((buffer[i*m+j]>>(7-k))&0x1)
        {
         Dot.y=y0-8*j-k;
         Dot.x=x0+i;
         MakePin(Dot);
        }
       }
      }
     }
     s+=2;
     y0-=w;
    }
   }
         }
      }
        fclose(fp);
  return 0;
}

int OutText24(int x0,int y0,int w,char *s,int cc)    
// 字模24*24,横坐标,纵坐标,字间隔,汉字字符串,旋转控制cc=(0:上,1:右,2:下,3:左)
{
 FILE *fp1,*fp2;
 char buffer[72];
 char str[2];
 unsigned long fpos,n;    //fpos为最终偏移动量
 register int i,j,k,m;
 int mod;
 PointXY  Dot;
 if((fp1=fopen("hzk16","rb")) == NULL )  //for ASCII
 {
   cout<< "Cann`t open hzk24t lib";
   return -1;
 }
 if((fp2=fopen("hzk24s","rb")) == NULL ) //for HZK
 {
   cout<< "Cann`t open hzk24s lib";
   return -1;
 }
 while(*s)
    {
  if(*s<0)
  {
   m=3;
   mod=24;
   n=3L*mod;
   str[0]=(*s)-0xb0;
   str[1]=*(s+1)-0xa1;
   fpos=(str[0]*94+str[1])*n;
   fseek(fp2,fpos,SEEK_SET);
   fread(buffer,n,1,fp2);
   if(cc==0)
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.x=x0+i; 
        Dot.y=y0+8*j+k; 
        MakePin(Dot); 
       } 
      } 
     } 
    } 
    s+=2; 
    x0+=mod+w; 
   } 
   else if(cc==1) 
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.x=x0-8*j-k; 
        Dot.y=y0+i; 
        MakePin(Dot); 
       } 
      } 
     } 
    } 
    s+=2; 
    y0+=mod+w; 
   } 
   else if(cc==2) 
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.x=x0-i; 
        Dot.y=y0-8*j-k; 
        MakePin(Dot); 
       } 
      } 
     } 
    } 
    s+=2; 
    x0-=mod+w; 
   } 
   else if(cc==3) 
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.x=x0+8*j+k; 
        Dot.y=y0-i; 
        MakePin(Dot); 
       } 
      } 
     } 
    } 
    s+=2; 
    y0-=mod+w; 
   } 
   
  }
  else if(*s>0)
  {
   m=2;
   mod=16;
   n=2L*mod;
   fpos=(2L*94+*s-0x21)*n;
   fseek(fp1,fpos,SEEK_SET);
   fread(buffer,n,1,fp1);
   if(cc==0)
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.x=x0+8*j+k; 
        Dot.y=y0+i; 
        MakePin(Dot); 
       } 
      } 
     } 
    } 
    s+=1; 
    x0+=(mod>>1)+w;  
   }
   else if(cc==1)
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.y=y0+8*j+k; 
        Dot.x=x0-i; 
        MakePin(Dot); 
       } 
      } 
     } 
    }  
    s+=1; 
    y0+=(mod>>1)+w;  
   }
   else if(cc==2)
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.x=x0-8*j-k; 
        Dot.y=y0-i; 
        MakePin(Dot); 
       } 
      } 
     } 
    }  
    s+=1; 
    x0-=(mod>>1)+w;  
   }
   else if(cc==3)
   { 
    for(i=0;i    { 
     for(j=0;j     { 
      for(k=0;k<8;k++) 
      { 
       if ((buffer[i*m+j]>>(7-k))&0x1) 
       { 
        Dot.y=y0-8*j-k; 
        Dot.x=x0+i; 
        MakePin(Dot); 
       } 
      } 
     } 
    }  
    s+=1; 
    y0-=(mod>>1)+w;  
   }
        }
 }
    fclose(fp1);   
 fclose(fp2); 
 return 0; 
}
//**************************************************************
//---------------------------------------------------------------------------
 PointXY CurrentXY;
 PrintPinType **Dptr;
 int MakePin(PointXY xy)
 {
  int i;//i应该是第几行
  i=int(xy.y/24);
  switch (xy.y%24)//应该是一行中的第几个
  {
   case 0: Dptr[xy.x].PrintPin.Bit0_7=1;break;
   case 1: Dptr[xy.x].PrintPin.Bit0_6=1;break;
   case 2: Dptr[xy.x].PrintPin.Bit0_5=1;break;
   case 3: Dptr[xy.x].PrintPin.Bit0_4=1;break;
   case 4: Dptr[xy.x].PrintPin.Bit0_3=1;break;
   case 5: Dptr[xy.x].PrintPin.Bit0_2=1;break;
   case 6: Dptr[xy.x].PrintPin.Bit0_1=1;break;
   case 7: Dptr[xy.x].PrintPin.Bit0_0=1;break;
   case 8: Dptr[xy.x].PrintPin.Bit1_7=1;break;
   case 9: Dptr[xy.x].PrintPin.Bit1_6=1;break;
   case 10: Dptr[xy.x].PrintPin.Bit1_5=1;break;
   case 11: Dptr[xy.x].PrintPin.Bit1_4=1;break;
   case 12: Dptr[xy.x].PrintPin.Bit1_3=1;break;
   case 13: Dptr[xy.x].PrintPin.Bit1_2=1;break;
   case 14: Dptr[xy.x].PrintPin.Bit1_1=1;break;
   case 15: Dptr[xy.x].PrintPin.Bit1_0=1;break;
   case 16: Dptr[xy.x].PrintPin.Bit2_7=1;break;
   case 17: Dptr[xy.x].PrintPin.Bit2_6=1;break;
   case 18: Dptr[xy.x].PrintPin.Bit2_5=1;break;
   case 19: Dptr[xy.x].PrintPin.Bit2_4=1;break;
   case 20: Dptr[xy.x].PrintPin.Bit2_3=1;break;
   case 21: Dptr[xy.x].PrintPin.Bit2_2=1;break;
   case 22: Dptr[xy.x].PrintPin.Bit2_1=1;break;
   case 23: Dptr[xy.x].PrintPin.Bit2_0=1;break;
   default: break;
  }
  return 0;
 }
int ExplanPRintCommand(char *s,char *Dat,int &m)
{
 char Bs[30],BCom[6][10];
 int i,j;
 char seps[]   = " ,tn";
 char *token;
 for(i=0;i<6;i++)
 {
  *BCom='';
  Dat=0;
 }
 strcpy(Bs,s);
 token = strtok( Bs, seps);
 j=0;
 while( token != NULL )
 {
  strcpy(BCom[j],token);
  token = strtok( NULL, seps );
  j++;
 }
 for(i=0;i {
  if(i==0)
  {
   if(!strcmp(BCom,"CR"))
   {
    Dat=0x0d;
    break;
   }
   else if(!strcmp(BCom,"FF"))
   {
    Dat=0x0c;
    break;
   }
   else if(!strcmp(BCom,"LF"))
   {
    Dat=0x0a;
    break;
   }
   else if(!strcmp(BCom,"ESC"))
   {
    Dat=0x1b;
  
   }
  }
  else if(i==1)
  {
   if(!strcmp(BCom,"@"))
   {
    Dat=0x40;
    break;
   }
   else if(!strcmp(BCom,"2"))
   {
    Dat=0x32;
    break;
   }
   else if(!strcmp(BCom,"6"))
   {
    Dat=0x36;
    break;
   }
   else if(!strcmp(BCom,"7"))
   {
    Dat=0x37;
    break;
   }
   else if(!strcmp(BCom,"t"))
   {
    Dat=0x74;

   }
   
   else if(!strcmp(BCom,"R"))
   {
    Dat=0x52;
  
   }
   else if(!strcmp(BCom,"r"))
   {
    Dat=0x72;
  
   }
   else if(!strcmp(BCom,"U"))
   {
    Dat=0x55;
  
   }
   else if(!strcmp(BCom,"x"))
   {
    Dat=0x78;
  
   }
   else if(!strcmp(BCom,"EM"))
   {
    Dat=0x19;
  
   }
   
   else if(!strcmp(BCom,"C"))
   {
    Dat=0x43;
  
   }
   else if(!strcmp(BCom,"J"))
   {
    Dat=0x4a;
  
   }
   else if(!strcmp(BCom,"$"))
   {
    Dat=0x24;
  
   }
   else if(!strcmp(BCom,"*"))
   {
    Dat=0x2a;
  
   }

  }
  else if(i==2)
  {
   if(!strcmp(BCom,"m"))
   {
    Dat=0x27;
   }
   else
   {
    Dat=atoi(BCom); 

   }
  }
  else if(i>2)
  {
   Dat=atoi(BCom);
  }

 }
 return m=j;
}
 PointXY Line(PointXY BegPoint,PointXY EndPoint)
 {
    PointXY Dot;
    float k;
    if(abs(EndPoint.x-BegPoint.x)>abs(EndPoint.y-BegPoint.y))
    {
   k=float(EndPoint.y-BegPoint.y)/(EndPoint.x-BegPoint.x);
   if(BegPoint.x   {
    for(Dot.x=BegPoint.x;Dot.x<=EndPoint.x;Dot.x++)
    {
     Dot.y=int((BegPoint.y)+k*(Dot.x-BegPoint.x));
     MakePin(Dot);
    }
   }
   else
   {
    for(Dot.x=BegPoint.x;Dot.x>=EndPoint.x;Dot.x--)
    {
     Dot.y=int((BegPoint.y)+k*(Dot.x-BegPoint.x));
     MakePin(Dot);
    }
   }
    }
    else
    {
   k=EndPoint.y==BegPoint.y?0:float(EndPoint.x-BegPoint.x)/(EndPoint.y-BegPoint.y);
   if(BegPoint.y   {
    for(Dot.y=BegPoint.y;Dot.y<=EndPoint.y;Dot.y++)
    {
     Dot.x=int((BegPoint.x)+k*(Dot.y-BegPoint.y));
     MakePin(Dot);
    }
   }
   else
   {
    for(Dot.y=BegPoint.y;Dot.y>=EndPoint.y;Dot.y--)
    {
     Dot.x=int((BegPoint.x)+k*(Dot.y-BegPoint.y));
     MakePin(Dot);
    }

   }
    }
    CurrentXY=EndPoint;
    CurrentXY.x=EndPoint.x;
    CurrentXY.y=EndPoint.y;
    return CurrentXY;
 }
 PointXY LineTo(PointXY ToPoint)
 {
    PointXY Dot;
    float k;
    if(abs(ToPoint.x-CurrentXY.x)>abs(ToPoint.y-CurrentXY.y))
    {
   k=float(ToPoint.y-CurrentXY.y)/(ToPoint.x-CurrentXY.x);
   if(CurrentXY.x<=ToPoint.x)
   {
    for(Dot.x=CurrentXY.x;Dot.x<=ToPoint.x;Dot.x++)
    {
     Dot.y=int((CurrentXY.y)+k*(Dot.x-CurrentXY.x));
     MakePin(Dot);
    }
   }
   else
   {
    for(Dot.x=CurrentXY.x;Dot.x>=ToPoint.x;Dot.x--)
    {
     Dot.y=int((CurrentXY.y)+k*(Dot.x-CurrentXY.x));
     MakePin(Dot);
    }
   }
    }
    else
    {
   k=ToPoint.y==CurrentXY.y?0:float(ToPoint.x-CurrentXY.x)/(ToPoint.y-CurrentXY.y);
   if(CurrentXY.y<=ToPoint.y)
   {
    for(Dot.y=Current