home *** CD-ROM | disk | FTP | other *** search
/ CD Shareware Magazine 1996 December / CD_shareware_12-96.iso / DOS / Programa / CCDL122.ZIP / LIBS / INTERP / SOURCE / CFS.C next >
Encoding:
C/C++ Source or Header  |  1995-10-25  |  9.7 KB  |  501 lines
  1. /************************ cfs Character File Stream *************************/
  2. #include <stdio.h>
  3. #include <fcntl.h>
  4. #include <sys\types.h>
  5. #include <sys\stat.h>
  6. #include "cfs.h"
  7.  
  8. /************************** READ STREAM FUNCTIONS ***************************/
  9.  
  10. /* Initialize Character Stream Data Structure for Read */
  11. void cfs_Rini
  12.  (
  13.   CFS *Crec,
  14.   uq msk,
  15.   sd phi
  16.  )
  17.  {
  18.   Crec->fp = 0;
  19.   Crec->curch = DefChar;
  20.   Crec->def = DefChar;
  21.   Crec->msk = msk;
  22.   Crec->tot = 0;
  23.   Crec->size = 0;
  24.   Crec->mode = 0;
  25.   Crec->cnt = 0;
  26.   Crec->clm = 0;
  27.   Crec->mag = 0;
  28.   Crec->phi = phi;
  29.   Crec->len = sizeof(Crec->buf);
  30.   Crec->ix = sizeof(Crec->buf);
  31.  }
  32.  
  33. /* Open File for Read */
  34. er cfs_Ropen(CFS *Crec,char *name,uq msk)
  35.  {
  36.   er st=0;
  37.  
  38.   cfs_Rini(Crec,msk,0);
  39.   Crec->fp = fopen(name,"rb");
  40.   if (Crec->fp)
  41.    {
  42.     Crec->mode = FileMode;
  43.     st = 1;
  44.    }
  45.   return(st);
  46.  }
  47.  
  48. /* Open CFS for Memory Read */
  49. er cfs_Rmem(CFS *Crec,us *adr,uq msk,sd phi)
  50.  {
  51.   er st=0;
  52.  
  53.   cfs_Rini(Crec,msk,phi);
  54.   (us *)Crec->fp = adr;
  55.   if (Crec->fp)
  56.    {
  57.     Crec->mode = MemMode;
  58.     st = 1;
  59.    }
  60.   return(st);
  61.  }
  62.  
  63. /* Close for Read */
  64. void cfs_Rclose(CFS *Crec)
  65.  {
  66.   if (Crec->mode == FileMode && Crec->fp)
  67.    {
  68.     fclose(Crec->fp);
  69.     Crec->fp = 0;
  70.    }
  71.  }
  72.  
  73. /* Read a Byte */
  74. er cfs_Rbyte
  75.  (
  76.   CFS *Crec,
  77.   us *byt
  78.  )
  79.  {
  80.   er st=0;
  81.   us *src;
  82.   us *dst;
  83.  
  84.   if (Crec->ix >= Crec->len)
  85.    {
  86.     if (Crec->mode == FileMode)
  87.       Crec->len=fread(Crec->buf,1,sizeof(Crec->buf),Crec->fp);
  88.     else
  89.      {
  90.       Crec->len = 0;
  91.       src = (us *)Crec->fp;
  92.       dst = Crec->buf;
  93.       while (*src && Crec->len < sizeof(Crec->buf))
  94.        {
  95.         *dst++ = *src++;
  96.         Crec->len += 1;
  97.        }
  98.       (us *)Crec->fp = src;
  99.      }
  100.  
  101.     Crec->ix = 0;
  102.    }
  103.   if (Crec->ix < Crec->len)
  104.    {
  105.     *byt = Crec->buf[Crec->ix];
  106.     Crec->size += 1;
  107.     Crec->ix += 1;
  108.     st = 1;
  109.    }
  110.  
  111.   return(st);
  112.  }
  113.  
  114. /* Read a Character */
  115. er cfs_Rchar
  116.  (
  117.   CFS *Crec,
  118.   uq *val
  119.  )
  120.  {
  121.   er st;
  122.   us cont=1;
  123.   us byt;
  124.   us grp;
  125.   us rep;
  126.   us tmp;
  127.  
  128.   while (cont)
  129.    {
  130.     /* Any Left from Repeat? */
  131.     if (Crec->cnt)
  132.      {
  133.       *val = Crec->curch & Crec->msk;
  134.       Crec->cnt -= 1;
  135.       Crec->clm += 1;
  136.       cont = 0;
  137.      }
  138.     else
  139.      {
  140.       rep = 0;
  141.       st = cfs_Rbyte(Crec,&byt);
  142.       if (!st) return(0);
  143.  
  144.       /* Special */
  145.       if (byt & 0x80)
  146.        {
  147.         grp = byt & 0x70;
  148.  
  149.         /* Repeat */
  150.         if (grp == 0x00)
  151.          {
  152.           if (!Crec->mag) Crec->cnt = 2;
  153.           Crec->cnt += ((byt & 0x0F) << Crec->mag);
  154.           Crec->mag += 4;
  155.           rep = 1;
  156.          }
  157.  
  158.         /* New Bank */
  159.         else if (grp == 0x10)
  160.          {
  161.           Crec->curch &= 0xFFFFF87F;
  162.           Crec->curch |= ((uq)(byt & 0x0F)) << 7;
  163.          }
  164.  
  165.         /* New Attributes */
  166.         else if ((grp & 0x60) == 0x20)
  167.          {
  168.           Crec->curch &= 0xFFFF07FF;
  169.           Crec->curch |= ((uq)(byt & 0x1F)) << 11;
  170.          }
  171.  
  172.         /* New Foreground Color */
  173.         else if (grp == 0x40)
  174.          {
  175.           Crec->curch &= 0xFFF0FFFF;
  176.           Crec->curch |= ((uq)(byt & 0x0F)) << 16;
  177.          }
  178.  
  179.         /* New Background Color */
  180.         else if (grp == 0x50)
  181.          {
  182.           Crec->curch &= 0xFF0FFFFF;
  183.           Crec->curch |= ((uq)(byt & 0x0F)) << 20;
  184.          }
  185.  
  186.         /* New Style Code */
  187.         else if (grp == 0x60)
  188.          {
  189.           Crec->curch &= 0xF0FFFFFF;
  190.           Crec->curch |= ((uq)(byt & 0x0F)) << 24;
  191.          }
  192.  
  193.         /* New Size Code */
  194.         else if (grp == 0x70)
  195.          {
  196.           Crec->curch &= 0x0FFFFFFF;
  197.           Crec->curch |= ((uq)(byt & 0x0F)) << 28;
  198.          }
  199.        }
  200.  
  201.       /* Displayable */
  202.       else if (byt & 0x60)
  203.        {
  204.         Crec->curch &= 0xFFFFFF80;
  205.         Crec->curch |= byt;
  206.         Crec->cnt = 1;
  207.        }
  208.  
  209.       /* Terminator? */
  210.       else
  211.        {
  212.         switch (byt)
  213.          {
  214.           case 10: /* New Paragraph Left Justified */
  215.           case 20: /* New Paragraph Right Justified */
  216.           case 21: /* New Paragraph Center Justified */
  217.           case 22: /* New Paragraph Fully Justified */
  218.             Crec->clm = 0;
  219.           case 15: /* Stationary Terminator */
  220.             Crec->curch = Crec->def;
  221.           case 11: /* New Line */
  222.           case 12: /* Hard Form Feed */
  223.           case 14: /* Soft Form Feed */
  224.             *val = byt;
  225.             cont = 0;
  226.             break;
  227.           case 30:
  228.             Crec->phi = 0;
  229.             break;
  230.           case 31:
  231.             Crec->phi = 1;
  232.             break;
  233.           case 9:  /* Tab */
  234.             tmp = Crec->clm;
  235.             while (1)
  236.              {
  237.               tmp += 1;
  238.               Crec->cnt += 1;
  239.               if (!(tmp & 0x07)) break;
  240.              }
  241.             Crec->curch &= 0xFFFFFF80;
  242.             Crec->curch |= ' ';
  243.             break;
  244.          }
  245.        }
  246.  
  247.       if (!rep) Crec->mag = 0;
  248.      }
  249.    }
  250.   Crec->tot += 1;
  251.   return(1);
  252.  }
  253.  
  254. /************************* WRITE STREAM FUNCTIONS ***************************/
  255.  
  256. /* Initialize Character Stream Data Structure for Write */
  257. void cfs_Wini
  258.  (
  259.   CFS *Crec,
  260.   uq msk,
  261.   sd phi
  262.  )
  263.  {
  264.   Crec->fp = 0;
  265.   Crec->curch = DefChar;
  266.   Crec->def = DefChar;
  267.   Crec->msk = msk;
  268.   Crec->tot = 0;
  269.   Crec->size = 0;
  270.   Crec->mode = 0;
  271.   Crec->cnt = 0;
  272.   Crec->clm = 0;
  273.   Crec->mag = 0;
  274.   Crec->phi = phi;
  275.   Crec->len = sizeof(Crec->buf);
  276.   Crec->ix = 0;
  277.  }
  278.  
  279. /* Write a Byte */
  280. void cfs_Wbyte
  281.  (
  282.   CFS *Crec,
  283.   us byt
  284.  )
  285.  {
  286.   us *src;
  287.   us *dst;
  288.   sd ix=0;
  289.  
  290.   Crec->buf[Crec->ix] = byt;
  291.   Crec->size += 1;
  292.   Crec->ix += 1;
  293.   if (Crec->ix >= Crec->len)
  294.    {
  295.     if (Crec->mode == FileMode)
  296.       fwrite(Crec->buf,1,Crec->ix,Crec->fp);
  297.     else if (Crec->mode == MemMode)
  298.      {
  299.       src = Crec->buf;
  300.       dst = (us *)Crec->fp;
  301.       while (ix < Crec->len)
  302.        {
  303.         *dst++ = *src++;
  304.         ix += 1;
  305.        }
  306.       (us *)Crec->fp = dst;
  307.      }
  308.     Crec->ix = 0;
  309.    }
  310.  }
  311.  
  312. /* Open File for Write */
  313. er cfs_Wopen(CFS *Crec,char *name,uq msk,sd phi)
  314.  {
  315.   er st=0;
  316.  
  317.   cfs_Wini(Crec,msk,phi);
  318.   Crec->fp = fopen(name,"wb");
  319.   if (Crec->fp)
  320.    {
  321.     Crec->mode = FileMode;
  322.     if (Crec->phi) cfs_Wbyte(Crec,31);
  323.     st = 1;
  324.    }
  325.   return(st);
  326.  }
  327.  
  328. /* Open CFS for Memory Write */
  329. er cfs_Wmem(CFS *Crec,us *adr,uq msk,sd phi)
  330.  {
  331.   er st=0;
  332.  
  333.   cfs_Wini(Crec,msk,phi);
  334.   (us *)Crec->fp = adr;
  335.   if (Crec->fp)
  336.    {
  337.     Crec->mode = MemMode;
  338.     st = 1;
  339.    }
  340.   return(st);
  341.  }
  342.  
  343. /* Open CFS for Memory Write for Size Computation Only: No Actual Writes */
  344. er cfs_Smem(CFS *Crec,uq msk,sd phi)
  345.  {
  346.   er st=0;
  347.  
  348.   cfs_Wini(Crec,msk,phi);
  349.   Crec->mode = ScanMode;
  350.   st = 1;
  351.   return(st);
  352.  }
  353.  
  354. /* Close for Write */
  355. void cfs_Wclose(CFS *Crec)
  356.  {
  357.   if (Crec->mode == FileMode && Crec->fp)
  358.    {
  359.     cfs_Wflush(Crec);
  360.     if (Crec->ix)
  361.      {
  362.       fwrite(Crec->buf,1,Crec->ix,Crec->fp);
  363.       Crec->ix = 0;
  364.      }
  365.     fclose(Crec->fp);
  366.     Crec->fp = 0;
  367.    }
  368.  }
  369.  
  370. /* Flush Output */
  371. void cfs_Wflush(CFS *Crec)
  372.  {
  373.  
  374.   if (!Crec->phi || Crec->cnt == 1)
  375.    {
  376.     while (Crec->cnt)
  377.      {
  378.       cfs_Wbyte(Crec,Crec->curch & 0x7F);
  379.       Crec->cnt -= 1;
  380.      }
  381.    }
  382.   else if (Crec->cnt)
  383.    {
  384.     Crec->cnt -= 2;
  385.     while (1)
  386.      {
  387.       cfs_Wbyte(Crec,0x80 | (Crec->cnt & 0x0F));
  388.       Crec->cnt >>= 4;
  389.       if (!Crec->cnt) break;
  390.      }
  391.    }
  392.  }
  393.  
  394. /* Write Character */
  395. void cfs_Wchar
  396.  (
  397.   CFS *Crec,
  398.   uq val
  399.  )
  400.  {
  401.   uq tmp;
  402.   us byt;
  403.  
  404.   /* Displayable Character */
  405.   if (0x00000060 & val)
  406.    {
  407.     val = (val & Crec->msk) | (Crec->def & ~Crec->msk);
  408.  
  409.     /* Flush if Necesssary */
  410.     if (!Crec->phi)
  411.      {
  412.       Crec->curch = val;
  413.       Crec->cnt += 1;
  414.       cfs_Wflush(Crec);
  415.      }
  416.     else if (Crec->curch == val)
  417.       Crec->cnt += 1;
  418.     else
  419.      {
  420.       cfs_Wflush(Crec);
  421.  
  422.       /* New Size Code */
  423.       if ((val ^ Crec->curch) & 0xF0000000)
  424.        {
  425.         tmp = val & 0xF0000000;
  426.         byt = 0xF0 | (tmp >> 28);
  427.         cfs_Wbyte(Crec,byt);
  428.        }
  429.  
  430.       /* New Style Code */
  431.       if ((val ^ Crec->curch) & 0x0F000000)
  432.        {
  433.         tmp = val & 0x0F000000;
  434.         byt = 0xE0 | (tmp >> 24);
  435.         cfs_Wbyte(Crec,byt);
  436.        }
  437.  
  438.       /* New Background Color Code */
  439.       if ((val ^ Crec->curch) & 0x00F00000)
  440.        {
  441.         tmp = val & 0x00F00000;
  442.         byt = 0xD0 | (tmp >> 20);
  443.         cfs_Wbyte(Crec,byt);
  444.        }
  445.  
  446.       /* New Foreground Color Code */
  447.       if ((val ^ Crec->curch) & 0x000F0000)
  448.        {
  449.         tmp = val & 0x000F0000;
  450.         byt = 0xC0 | (tmp >> 16);
  451.         cfs_Wbyte(Crec,byt);
  452.        }
  453.  
  454.       /* New Attributes Code */
  455.       if ((val ^ Crec->curch) & 0x0000F800)
  456.        {
  457.         tmp = val & 0x0000F800;
  458.         byt = 0xA0 | (tmp >> 11);
  459.         cfs_Wbyte(Crec,byt);
  460.        }
  461.  
  462.       /* New Bank Code */
  463.       if ((val ^ Crec->curch) & 0x00000780)
  464.        {
  465.         tmp = val & 0x00000780;
  466.         byt = 0x90 | (tmp >> 7);
  467.         cfs_Wbyte(Crec,byt);
  468.        }
  469.  
  470.       /* Send Displayable Code */
  471.       byt = val & 0x0000007F;
  472.       cfs_Wbyte(Crec,byt);
  473.  
  474.       /* Update Current Character */
  475.       Crec->curch = val;
  476.      }
  477.    }
  478.  
  479.   /* End of Paragraph Terminators */
  480.   else if (val == 10 || val == 15 || val == 20 || val == 21 || val == 22)
  481.    {
  482.     cfs_Wflush(Crec);
  483.     if (Crec->phi)
  484.       cfs_Wbyte(Crec,val);
  485.     else
  486.      {
  487.       if (Crec->mode == FileMode) cfs_Wbyte(Crec,13);
  488.       cfs_Wbyte(Crec,10);
  489.      }
  490.     Crec->curch = Crec->def;
  491.    }
  492.  
  493.   /* Other Terminators */
  494.   else if (val == 11 || val == 12 || val == 13 || val == 14)
  495.    {
  496.     cfs_Wflush(Crec);
  497.     cfs_Wbyte(Crec,val);
  498.    }
  499.   Crec->tot += 1;
  500.  }
  501.