home *** CD-ROM | disk | FTP | other *** search
/ FreeWare Collection 2 / FreeSoftwareCollection2pd199x-jp.img / prnout / src / font.c < prev    next >
Text File  |  1990-06-14  |  6KB  |  273 lines
  1. #include    <stdio.h>
  2. #include    <stdlib.h>
  3. #include    "defs.h"
  4.  
  5. #define HASH    16
  6. #define MAX     64
  7.  
  8. typedef struct _LRU {
  9.     UNSIG   code;
  10.     struct _LRU *next;
  11.     UCHAR   font[72];
  12. } LRU;
  13.  
  14.        char    *fnt_dir=NULL;
  15. static FILE    *kan_fp=NULL,*ank_fp=NULL;
  16. static int    ank_cnt=0;
  17. static char    *kanfile[]={
  18.             "\\KYOU\\KYOU24.FNT",
  19.             "\\MINN\\MINN24.FNT",
  20.             "\\MARU\\MARU24.FNT",
  21.             "\\GOTH\\GOTH24.FNT" };
  22. static char    *ankfile[]={
  23.             "\\KYOU\\KYOU24HK.FNT",
  24.             "\\MINN\\MINN24HK.FNT",
  25.                     "\\MARU\\MARU24HK.FNT",
  26.                     "\\GOTH\\GOTH24HK.FNT" };
  27. static LRU    *top[HASH];
  28. static LRU    *lru_buf=NULL;
  29.  
  30. void    helf_cnv(font)
  31. register UCHAR   *font;
  32. {
  33.     int     i;
  34.     register UCHAR   *p;
  35.  
  36.     p = font;
  37.     for ( i = 0 ; i < 12 ; i++ ) {
  38.         *(font++) = *p | *(p+3); p++;
  39.         *(font++) = *p | *(p+3); p++;
  40.         *(font++) = *p | *(p+3); p++;
  41.         p += 3;
  42.     }
  43. }
  44. UCHAR    *read_font(code,font)
  45. UNSIG   code;
  46. UCHAR   *font;
  47. {
  48.     UNSIG    cd;
  49.     int      i,j,n,k,c;
  50.     long     l;
  51.     register UCHAR   *p;
  52.     register UCHAR   *s;
  53.     UCHAR   tmp[72];
  54.     static UCHAR mska[]={ 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01 };
  55.     static UCHAR msko[]={ 0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80 };
  56.  
  57.     if ( code & 0xFF00 ) {
  58.         i = (code >> 8) - 0x21;
  59.         j = (code & 0xff) - 0x21;
  60.         l = (i * 94L + j) * 74L + 16L;
  61.         fseek(kan_fp,l,0);
  62.         fread(&cd,1,2,kan_fp);
  63.         fread(tmp,1,72,kan_fp);
  64.     } else if ( code == '{' ) {
  65.         if ( (font = read_font(0x2150,font)) != NULL )
  66.             helf_cnv(font);
  67.         return font;
  68.     } else if ( code == '}' ) {
  69.         if ( (font = read_font(0x2151,font)) != NULL )
  70.             helf_cnv(font);
  71.         return font;
  72.     } else {
  73.         l = code * 74L;
  74.         fseek(ank_fp,l,0);
  75.         fread(&cd,1,2,ank_fp);
  76.         fread(tmp,1,72,ank_fp);
  77.     }
  78.     cd = (cd >> 8) | (cd << 8);
  79.     if ( code != cd )
  80.     return NULL;
  81.  
  82.     s = font;
  83.     for ( i = 0 ; i < 3 ; i++ ) {
  84.         for ( n = 0 ; n < 8 ; n++ ) {
  85.             p = &tmp[i];
  86.             for ( j = 0 ; j < 3 ; j++ ) {
  87.                 for ( c = k = 0 ; k < 8 ; k++ ) {
  88.                     if ( *p & mska[n] )
  89.                         c |= (typ_flg == PC98 ? msko[k]:mska[k]);
  90.                     p += 3;
  91.                 }
  92.                 *(s++) = c;
  93.             }
  94.         PRB_out();
  95.         }
  96.     }
  97.     return font;
  98. }
  99. UCHAR   *get_font(code)
  100. UNSIG   code;
  101. {
  102.     int     hs;
  103.     LRU     *p,*s;
  104.  
  105.     hs = code & (HASH-1);   /* code % hash */
  106.     s = p = top[hs];
  107.     while ( p->code != code ) {
  108.         if ( p->next == NULL ) {
  109.             p->code = code;
  110.             p->next = top[hs];
  111.             top[hs] = p;
  112.             s->next = NULL;
  113.             return read_font(code,p->font);
  114.         }
  115.         s = p;
  116.         p = p->next;
  117.     }
  118.     if ( s != p ) {
  119.     s->next = p->next;
  120.     p->next = top[hs];
  121.     top[hs] = p;
  122.     }
  123.     return p->font;
  124. }
  125. void    fnt_spc(n)
  126. int     n;
  127. {
  128.     char    tmp[20];
  129.  
  130.     if ( n <= 0 )
  131.         return;
  132.     switch(typ_flg) {
  133.         case FUJITU:
  134.         sprintf(tmp,"\x1bQ%d W",n);
  135.         prn_line_out(tmp);
  136.             break;
  137.         case ESCP:
  138.             PRB_byte("\x1b\x2a\x27",3);
  139.             PRB_chr(n & 0xFF);
  140.             PRB_chr(n >> 8);
  141.             break;
  142.         case PC98:
  143.         sprintf(tmp,"\x1bJ%04d",n);
  144.         prn_line_out(tmp);
  145.             break;
  146.     }
  147.     while ( n-- > 0 )
  148.         PRB_byte("\x00\x00\x00",3);
  149. }
  150. void    fnt_kan(code)
  151. UNSIG   code;
  152. {
  153.     int     i;
  154.     UCHAR   *font;
  155.  
  156.     if ( (font = get_font(code)) == NULL ) {
  157.         switch(typ_flg) {
  158.             case FUJITU: prn_line_out("\x1b$B"); break;
  159.             case ESCP:   prn_line_out("\x1c\x12"); break;
  160.         }
  161.         PRB_chr((UCHAR)(code >> 8));
  162.         PRB_chr((UCHAR)code);
  163.         return;
  164.     }
  165.     i = yousi[paper].spc / 2;
  166.     fnt_spc(i);
  167.     switch(typ_flg) {
  168.         case FUJITU:
  169.         prn_line_out("\x1bQ24 W");
  170.             break;
  171.         case ESCP:
  172.             PRB_byte("\x1b\x2a\x27\x18\x00",5);
  173.             break;
  174.         case PC98:
  175.         prn_line_out("\x1bJ0024");
  176.             break;
  177.     }
  178.     PRB_byte(font,72);
  179.     fnt_spc(yousi[paper].spc - i);
  180. }
  181. void    fnt_ank(code)
  182. UNSIG   code;
  183. {
  184.     int     i;
  185.     UCHAR   *font;
  186.  
  187.     if ( code < ' ' ) {
  188.         if ( code == '\n' ) {
  189.             ank_cnt = 0;
  190.             PRB_chr('\x0D');
  191.         }
  192.         PRB_chr(code);
  193.         return;
  194.     }
  195.     if ( (font = get_font(code & 0xFF)) == NULL ) {
  196.         PRB_chr('\x07');
  197.         return;
  198.     }
  199.     i = yousi[paper].spc / 2;
  200.     fnt_spc(i/2);
  201.     if ( yousi[paper].spc & 1 ) {
  202.         if ( ank_cnt & 1 )
  203.             fnt_spc(1);
  204.         ank_cnt++;
  205.     }
  206.     switch(typ_flg) {
  207.         case FUJITU:
  208.         prn_line_out("\x1bQ12 W");
  209.             break;
  210.         case ESCP:
  211.             PRB_byte("\x1b\x2a\x27\x0C\x00",5);
  212.             break;
  213.         case PC98:
  214.         prn_line_out("\x1bJ0012");
  215.             break;
  216.     }
  217.     PRB_byte(font,36);
  218.     fnt_spc(i-(i/2));
  219. }
  220. int    lru_init()
  221. {
  222.     int     i,j;
  223.     LRU        *p;
  224.  
  225.     if ( (lru_buf = (LRU *)malloc(sizeof(LRU) * HASH * MAX)) == NULL )
  226.     return ERR;
  227.     p = lru_buf;
  228.     for ( j = 0 ; j < HASH ; j++ ) {
  229.     top[j] = p;
  230.         for ( i = 0 ; i < (MAX-1) ; i++ ) {
  231.             p->code = 0xFFFF;
  232.             p->next = p + 1;
  233.         p++;
  234.         }
  235.         p->code = 0xFFFF;
  236.     p->next = NULL;
  237.     p++;
  238.     }
  239.     return FALSE;
  240. }
  241. int     fnt_init()
  242. {
  243.     char    *p;
  244.     char    tmp[128];
  245.  
  246.     if ( fnt_dir == NULL ) {
  247.         if ( (p = getenv("FNTDIR")) == NULL )
  248.             p = "Q:\\FJ\\FNT";
  249.     fnt_dir = p;
  250.     }
  251.     strcpy(tmp,fnt_dir); strcat(tmp,kanfile[fnt_flg]);
  252.     if ( (kan_fp = fopen(tmp,"rb")) == NULL )
  253.         return ERR;
  254.     strcpy(tmp,fnt_dir); strcat(tmp,ankfile[fnt_flg]);
  255.     if ( (ank_fp = fopen(tmp,"rb")) == NULL ) {
  256.         fclose(kan_fp);
  257.         return ERR;
  258.     }
  259.     if ( lru_init() != FALSE ) {
  260.         fclose(kan_fp);
  261.     fclose(ank_fp);
  262.         return ERR;
  263.     }
  264.     ank_cnt = 0;
  265.     return FALSE;
  266. }
  267. void    fnt_close()
  268. {
  269.     fclose(kan_fp);
  270.     fclose(ank_fp);
  271.     free(lru_buf);
  272. }
  273.