home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 2: PC / frozenfish_august_1995.bin / bbs / d03xx / d0342.lha / Softfont / portolan_cli.c < prev    next >
C/C++ Source or Header  |  1990-04-15  |  12KB  |  402 lines
  1. /*************************************************************** 
  2.  *  convert.c     portrait font to landscape  HP LaserJet II format 
  3.  *    Compiled under Lattice C Compiler vers 5.04 
  4.  *
  5.  * Call: convert(portrait[file],landscape[file])
  6.  *
  7.  *  by Tom Lynch, 
  8.  *  version 4 April 90
  9.  ***************************************************************/
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include <math.h>
  15. #include <exec/types.h>
  16. #include <libraries/dos.h>
  17.  
  18. #define MAX 200    /* byte X byte array for individual character image */
  19. extern long DOSBase;
  20.  
  21. FILE *fp,*fl;
  22.  
  23. int filepos = 0; /* position in file being read  (32 bits in AMIGA */
  24. int filend = 0; /* file end flag  */
  25. int debug;
  26. unsigned int n = 0;    /* value counter */
  27.  
  28. unsigned char c;        /* character read from portrait font file */
  29.  
  30. unsigned char rdchar();     /* define function to return char */
  31. unsigned char skip();         /* define function to return char */
  32. unsigned char change();     /* define function to return char */
  33. unsigned int measureto();
  34. unsigned int _measureto();
  35. char bitmap();          /* read, rotate, and measure length of image in bytes */
  36. unsigned char base2[10][1];            /* temporary storage for binary string */
  37. unsigned char _read();
  38.  
  39. TEXT file_name[34];
  40. TEXT dir_name[67];
  41. TEXT portrait[67];
  42. TEXT landscape[67];
  43. TEXT slash[10] = "/";
  44. int  SLASH = '\057'; /* decimal 42, forward slash (UNIX, AMIGA) */
  45.  
  46. char *LAND  = ".land";
  47. char *temp;
  48.  
  49. unsigned char far map[MAX][MAX][1];    /* 'far' is REQUIRED for large arrays */
  50.  
  51. void main(argc, argv)
  52. int argc;
  53. char *argv[];
  54. {
  55.  
  56.     extern convert();            
  57.     int error;
  58.  
  59.     if (argc > 1)    {
  60.        if (argc == 3)    {
  61.         if (error = convert(argv[1],argv[2]) != 0) { /*  process the request */
  62.             printf("Failure to process font\n");
  63.             printf("\nError message: %d\n ",error); 
  64.             switch(error)    {
  65.                 case '4':
  66.                     printf("Failure to open portrait font file\n");
  67.                     break;
  68.                 case '5':
  69.                     printf("Landscape file exists; rename.\n");
  70.                     break;
  71.                 case '6':
  72.                     printf("Not font file?? First char should be 'escape'\n");
  73.                     break;
  74.                 default:
  75.                     break;    }
  76.             exit(0); 
  77.             }
  78.         printf("\nFont converted: %s --> %s\n",argv[1],argv[2]);
  79.         exit(0);
  80.     }
  81.     else {
  82.         printf("\nArgument ERROR. Correct form is:");
  83.         printf("\n'path'PORTOLAN  PORTRAIT LANDSCAPE\n\n");
  84.         exit(0);    }
  85.     }
  86. }
  87.  
  88.  
  89. convert(p,l)    /* CLI format: PORTOLAN font.port(old) font.land(new) */
  90. char *p;
  91. char *l;
  92. {
  93.     extern unsigned char c;        /* reference externals */
  94.     extern FILE *fp, *fl; 
  95.     extern unsigned int n;
  96.     extern unsigned char rdchar();
  97.     extern unsigned char skip();
  98.     extern unsigned char change();
  99.     extern char bitmap();
  100.     extern unsigned int measureto();
  101.     extern unsigned int _measureto();    
  102.     extern unsigned char _read();
  103.     extern unsigned char base2[][];
  104.     unsigned char descriptor[20][1];
  105.     unsigned int LeftOffset;
  106.     unsigned int TopOffset;
  107.     unsigned int width, h_dots_p;
  108.     unsigned int height, w_bytes_p;
  109.     int size;
  110.     unsigned int w_dots;     /* landscape width in dots equal to height */
  111.     unsigned int w_bytes;    /* integral number of bytes */
  112.     unsigned int h_dots;    /* landscape height equal to portrait */
  113.     unsigned int h_bytes;
  114.     int a,h,i;
  115.     char *res = "01234567890";
  116.     
  117.     DOSBase = OpenLibrary("dos.library",0);
  118.        
  119.     if ((fp = fopen(p,"r")) == NULL)    {
  120.              return(4); 
  121.          }
  122.            if ((fl = fopen(l,"w")) == NULL)    {
  123.              return(5); 
  124.          }
  125.          
  126. /* files ready, convert portrait file to landscape */
  127.  
  128.     rdchar();      /* look for initial escape character */
  129.     if (c != (char)'\033') return(6);
  130.            skip(2);      /* esc, ')', and 's' of font descriptor */
  131.            measureto ('W');  /* read index 'n' that points to next esc */
  132.            skip(12);      /* skip to orientation byte */
  133.     change(0,1);      /* change from port(0) to land(1) */
  134.     skip(n-13);      /* skip to end of font descriptor */
  135.     rdchar();      /* read first byte (esc) of charater descriptor */
  136.     while (filend == 0) {    /* test for end of charaters in font */
  137.         skip (2);    /* '*' and 'c' of char descriptor */
  138.         measureto('E');    /* read charater number */
  139.         skip(3);    /* bypass esc, '(', 's' */
  140.         
  141.     /* store char descriptor; must measure length to correct old length 
  142.           then write new descriptor      */
  143.         _measureto('W');    /* read char descriptor length */
  144.         size = n - 16;        /* bitmap size */
  145.         descriptor[0][1] = 'W';
  146.         _read(); descriptor[1][1] = c;    /* Format byte = 4 */
  147.         _read(); descriptor[2][1] = c;     /* no continuation byte = 0 */
  148.         _read(); descriptor[3][1] = c;    /* descriptor size = 14 */
  149.         _read(); descriptor[4][1] = c;    /* class, format of data = 1 */
  150.         _read(); descriptor[5][1] = '\001';    /* Orientation 1 = land */
  151.         _read(); descriptor[6][1] = c;    /* reserved by HP = 0 */
  152.  
  153.     /* left offset (portrait) = */        
  154.         _read(); descriptor[7][1] = c;    /* left offset (P) hi byte */
  155.         _read(); descriptor[8][1] = c;    /* left offset (P) lo byte */
  156.  
  157.     /* top offset (port) = */
  158.         _read(); descriptor[9][1] = c;    /* top offset (P) hi byte */
  159.         _read(); descriptor[10][1] = c;    /* top offset (P) lo byte */
  160.  
  161.     /* portrait width is read into landscape height descriptor bits */
  162.         _read(); descriptor[13][1] = c;    /* char width land hi */
  163.         _read(); descriptor[14][1] = c;    /* char width land hi */
  164.         
  165. /* land */    height = 256 * descriptor[13][1] + descriptor[14][1]; /* dots */
  166.         h_dots = height;            /* landscape height pixels */
  167.         h_bytes = height/8; if(height % 8) h_bytes += 1; /* bytes */
  168.         w_bytes_p = h_bytes;
  169.  
  170.     /* portrait height is read into landscape width descriptor bits */
  171.         _read(); descriptor[11][1] = c;    /* char height land */
  172.         _read(); descriptor[12][1] = c;    /* char height land */
  173.  
  174. /* land */    width = 256 * descriptor[11][1] + descriptor[12][1]; /* dots */
  175.         w_dots = width;
  176.         h_dots_p = width;
  177.         w_bytes = width/8; if(width % 8) w_bytes += 1; /* bytes */
  178.         
  179.         _read(); descriptor[15][1] = c;    /* Delta X   hi byte */
  180.         _read(); descriptor[16][1] = c;    /* Delta X   lo byte */
  181.         
  182.     /* top offset (land) = left offset(P) + char width(P) - 1 + byte offset,  16 bit hex */
  183.         TopOffset = 256 * descriptor[7][1] + descriptor[8][1] +        
  184.             256 * descriptor[13][1] + descriptor[14][1] - 1;
  185.             
  186.     /* left offset (landscape) = 0xFFFF - top offset(P) 16 bit hex */
  187.         LeftOffset = 65535 - (256 * descriptor[9][1] + descriptor[10][1]);        
  188.  
  189.         descriptor[7][1] = (unsigned char) (LeftOffset / 256);    /* hi byte */
  190.         descriptor[8][1] = (unsigned char) (LeftOffset % 256);    /* lo byte */
  191.  
  192.         descriptor[9][1] = (unsigned char) TopOffset / 256;    /* hi byte */
  193.         descriptor[10][1] = (unsigned char) TopOffset % 256;    /* lo byte */
  194.  
  195.     /* estimate of bit image size after rotation 8/
  196.      /* landscape bit_image size = width[bytes] * height[dot-rows] */
  197.          n = w_bytes * h_dots + 16;     /* bytes for descriptor and bit image */
  198.         h = stci_d(res,n);        /* convert to decimal string */
  199.         a = 1; if(n>9) a = 2; if(n>99) a = 3; if(a>999) a = 4;
  200.  
  201.     /* write char size to landscape file, ascii format */
  202.         for(i=0; i<a; i++) {    /* truncate escape byte with 'i<a' */
  203.             h = fputc(res[i],fl);
  204.         }
  205.  
  206.     /* write descriptor string to landscape file */
  207.         for(i=0; i<=16; i++) {
  208.             h = fputc(descriptor[i][1],fl);
  209.         }
  210.         
  211.     /* read image, rotate, and write bitmap to landscape file */
  212.         bitmap(w_bytes, h_bytes, h_dots, h_dots_p, w_bytes_p);
  213.  
  214.         rdchar();    
  215.     } /* 'while' loop */
  216.         printf("Font %s created\n",l);
  217.         c = fcloseall();    /* if filend = 0, success */
  218.         return 0;
  219. } /* main() */
  220.  
  221.  
  222. /* read bit image of font character and store in map[height(L)][width(L)][1] array */
  223. char bitmap(w_bytes, h_bytes, h_dots, h_dots_p, w_bytes_p)
  224.     unsigned w_bytes;
  225.     unsigned h_bytes;
  226.     unsigned h_dots;
  227.     unsigned h_dots_p;
  228.     unsigned w_bytes_p;
  229. {
  230.     extern unsigned char c;
  231.     extern FILE *fp,*fl;
  232.     unsigned int a,b;
  233.     unsigned char ZERO = '\000';
  234.     int i,j,k,m,p,q;
  235.     
  236.     /* clear only necessary byte pad work space to zero 
  237.         in preparation for reading character data.
  238.         This is along bottom of portrait character */
  239.     for(i=h_dots_p; i<=h_dots_p+8; i++) {    
  240.         for(j=0; j<=w_bytes_p +1; j++) {
  241.             map[j][i][1] = ZERO;
  242.         }
  243.     }
  244.     /* read portrait format pixel data into workspace */
  245.     for(i=1; i<=h_dots_p; i++) {    /* rows in font image */
  246.         for(j=1; j<=w_bytes_p; j++) {
  247.             _read();
  248.             map[j][i][1] = c;    /* map[w_field(P)][dot-row height(P)] */
  249.         } /* column fields */
  250.     } /* rows down image starting with index of one 1*/
  251.  
  252.     /* write rotated pixel data to landscape file 
  253.        This routine forms bytes of rotated image along the
  254.        landscape image width axis. The excess byte padding
  255.        in the origonal portrait image is stripped off; i.e. 
  256.        the pixel data is taken from h_dots, not h_bytes.
  257.        h_dots is equal to portrait image width in dots. */
  258.  
  259.         for(p=h_dots; p>=1; p--) {    
  260.            i = p / 8; /* points to byte, contingent to mod below */
  261.            q = p % 8; /* points to bit as computed in switch below */
  262.            switch(q) {
  263.             case 0:        /* points to next lower byte, bit = LSB */
  264.                 k = 1;    /* k = value of bit position of  */
  265.                 break;    /*   byte used to mask correct bit */
  266.             case 1:        /* points to next higher byte, msb */
  267.                 i += 1;
  268.                 k = 128;  /* first bit is MSB in HP format */
  269.                 break;
  270.             case 2:        
  271.                 i += 1;
  272.                 k = 64;
  273.                 break;
  274.             case 3:
  275.                 i += 1;
  276.                 k = 32;
  277.                 break;
  278.             case 4:
  279.                 i += 1;
  280.                 k = 16;
  281.                 break;
  282.             case 5:
  283.                 i += 1;
  284.                 k = 8;
  285.                 break;
  286.             case 6:
  287.                 i += 1;
  288.                 k = 4;
  289.                 break;
  290.             case 7:
  291.                 i += 1;
  292.                 k = 2;
  293.                 break;
  294.             }        /* there is no possible default */
  295.               for(j=0; j<w_bytes; j++) {
  296.                  c = 0;        /* c is used to form byte for landscape */
  297.              for(m=0,a=128; m<=7; m++,a/=2) { 
  298.                 b = (unsigned int) map[i][j*8+m][1]; 
  299.                 c += a*((k & b)>0);    /* calculate byte value */
  300.                         /* extract bit from portrait and 
  301.                        assign value 'a' for bit */
  302.              } /* bit of pixel data along old port height */
  303.              n = fputc(c,fl);     /* put computed byte 
  304.                             into landscape file */
  305.               } /* j = byte along width (old portrait height) */
  306.             /* k = bit pixel data value used in bitwise mask */
  307.         } /* i = byte along height (old portrait width) from max */
  308.     return NULL;
  309. }
  310.  
  311. unsigned char rdchar () {    /* read byte store in char 'c' */
  312.     extern unsigned char c;
  313.     extern FILE *fp, *fl; 
  314.     int r;
  315.     filepos++;
  316.     c = fgetc(fp);
  317.     if ((filend = feof(fp)) != 0)     return 0; 
  318.     r = fputc(c,fl);
  319.      return   c;
  320. }
  321.  
  322. unsigned char _read() {    /* read byte store in char 'c' */
  323.     extern unsigned char c;
  324.     extern FILE *fp; 
  325.     filepos++;
  326.     c = fgetc(fp);
  327.     if ((filend = feof(fp)) != 0)     return 0; 
  328.      return   c;
  329.  
  330. }
  331.  
  332. unsigned char skip(int n)      {    /* skip 'n' bytes in file */
  333.     extern unsigned char c;
  334.     extern FILE *fp, *fl; 
  335.     int x, r;
  336.     for (x = 0; x < n; ++x)
  337.         { 
  338.         filepos++;
  339.         c = fgetc(fp);
  340.         if ((filend = feof(fp)) != 0) return 0; 
  341.         r = fputc(c,fl);
  342.     }
  343.     return c;
  344. } 
  345.        
  346. unsigned char change(int prev, int new) /* change byte  */
  347.        {
  348.     extern unsigned char c;
  349.     extern FILE *fp, *fl; 
  350.     int r;
  351.     filepos++;
  352.     c = fgetc(fp);
  353.     if (c == prev) r = fputc(new,fl);
  354.     else  r = fputc(new,fl);
  355.     return c;
  356. } 
  357.  
  358. unsigned int measureto (char test)    /* calculate ascii format number (base 10) */
  359.        {
  360.     unsigned char rdchar();
  361.     extern unsigned char c;
  362.     rdchar();
  363.     n = (c - '0');        /* convert from ASCII to integer */
  364.     rdchar();            /* good for 1 to 5 character number */
  365.     if (c == test) return n;
  366.     n = n*10 + (c - '0');
  367.     rdchar();
  368.     if (c == test) return n;
  369.     n = n*10 + (c - '0');
  370.     rdchar();
  371.     if (c == test) return n;
  372.     n = n*10 + (c - '0');
  373.     rdchar();
  374.     if (c == test) return n;
  375.     n = n*10 + (c - '0');
  376.     rdchar();            /* this will read 'test' character */
  377.     return n;            /* with 5 character ascii number   */
  378. }
  379.  
  380. unsigned int _measureto (char test)    /* calculate ascii format number (base 10) */
  381.        {
  382.     unsigned char _read();
  383.     extern unsigned char c;
  384.     _read();
  385.     n = (c - '0');        /* convert from ASCII to integer */
  386.     _read();        /* good for 1 to 5 character number */
  387.     if (c == test) return n;
  388.     n = n*10 + (c - '0');
  389.     _read();
  390.     if (c == test) return n;
  391.     n = n*10 + (c - '0');
  392.     _read();
  393.     if (c == test) return n;
  394.     n = n*10 + (c - '0');
  395.     _read();
  396.     if (c == test) return n;
  397.     n = n*10 + (c - '0');
  398.     _read();            /* this will read 'test' character */
  399.     return n;            /* with 4 character ascii number   */
  400. }
  401.  
  402.