Subversion Repositories filter_foundry

Rev

Rev 193 | Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.         This file is part of a common library
  3.     Copyright (C) 1990-2009 Toby Thain, toby@telegraphics.com.au
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18. */
  19.  
  20. #include <stdlib.h> // malloc
  21.  
  22. #include "dvi_driver.h"
  23.  
  24. int get2(FILE*f){ int a; a=fgetc(f); return (a<<8)|fgetc(f); }
  25. long get3(FILE*f){ int a,b; a=fgetc(f); b=fgetc(f); return (((a<<8)|b)<<8)|fgetc(f); }
  26. ulong get4(FILE*f){ int a,b,c; a=fgetc(f); b=fgetc(f); c=fgetc(f);
  27.         return (((((a<<8)|b)<<8)|c)<<8)|fgetc(f); }
  28. int get1s(FILE*f){ int a; return (a=fgetc(f))<128 ? a : a-256; }
  29. int get2s(FILE*f){ int a; a=fgetc(f); return ( (a<128 ? a : a-256) <<8)|fgetc(f); }
  30. long get3s(FILE*f){ int a,b; a=fgetc(f); b=fgetc(f);
  31.         return ((( (a<128 ? a : a-256) <<8)|b)<<8)|fgetc(f); }
  32. long get4s(FILE*f){ int a,b,c; a=fgetc(f); b=fgetc(f); c=fgetc(f);
  33.         return ((((( (a<128 ? a : a-256) <<8)|b)<<8)|c)<<8)|fgetc(f); }
  34.  
  35. #if 0
  36. vf_interpret(FILE*vf){
  37.         for(;;)
  38.                 if((op = get1(vf)) == 248) break; /* postamble */
  39.                 else switch(op){
  40.                 case 247: /* pre */
  41.                         fseek(vf,1,SEEK_CUR);
  42.                         fseek(vf,get1(vf) + 8,SEEK_CUR);
  43.                         break;
  44.                 case 242:
  45.                         pl = get4(vf);
  46.                         cc = get4(vf);
  47.                         tfm = get4(vf);
  48.                         /*...*/
  49.                 }
  50. }
  51. #endif
  52.  
  53. dvi_interpret(FILE *dvi){
  54.         unsigned char op;
  55.         int i;
  56.         long a,counts[10],*lp,p;
  57.         ulong num,den,mag,l,u;
  58.         ushort s,t;
  59.  
  60.         for(;;)
  61.                 switch(op=get1(dvi)){
  62.                 /*...*/
  63.                 case 128: dvi_set_char(get1(dvi)); break;
  64.                 case 129: dvi_set_char(get2(dvi)); break;
  65.                 case 130: dvi_set_char(get3(dvi)); break;
  66.                 case 131: dvi_set_char(get4(dvi)); break;
  67.                 case 132: a=get4s(dvi); dvi_set_rule(a,get4s(dvi)); break;
  68.                 case 133: dvi_put_char(get1(dvi)); break;
  69.                 case 134: dvi_put_char(get2(dvi)); break;
  70.                 case 135: dvi_put_char(get3(dvi)); break;
  71.                 case 136: dvi_put_char(get4(dvi)); break;
  72.                 case 137: a=get4s(dvi); dvi_put_rule(a,get4s(dvi)); break;
  73.                 case 138: break;
  74.                 case 139:
  75.                         for(i=10,lp=counts;i--;)
  76.                                 *lp++=get4s(dvi);
  77.                         if(!dvi_bop(counts,get4s(dvi)))
  78.                                 goto done;
  79.                         break;
  80.                 case 140: dvi_eop(); goto done;
  81.                 case 141: dvi_push(); break;
  82.                 case 142: dvi_pop(); break;
  83.                 case 143: dvi_right(get1s(dvi)); break;
  84.                 case 144: dvi_right(get2s(dvi)); break;
  85.                 case 145: dvi_right(get3s(dvi)); break;
  86.                 case 146: dvi_right(get4s(dvi)); break;
  87.                 case 147: dvi_w0(); break;
  88.                 case 148: dvi_w(get1s(dvi)); break;
  89.                 case 149: dvi_w(get2s(dvi)); break;
  90.                 case 150: dvi_w(get3s(dvi)); break;
  91.                 case 151: dvi_w(get4s(dvi)); break;
  92.                 case 152: dvi_x0(); break;
  93.                 case 153: dvi_x(get1s(dvi)); break;
  94.                 case 154: dvi_x(get2s(dvi)); break;
  95.                 case 155: dvi_x(get3s(dvi)); break;
  96.                 case 156: dvi_x(get4s(dvi)); break;
  97.                 case 157: dvi_down(get1s(dvi)); break;
  98.                 case 158: dvi_down(get2s(dvi)); break;
  99.                 case 159: dvi_down(get3s(dvi)); break;
  100.                 case 160: dvi_down(get4s(dvi)); break;
  101.                 case 161: dvi_y0(); break;
  102.                 case 162: dvi_y(get1s(dvi)); break;
  103.                 case 163: dvi_y(get2s(dvi)); break;
  104.                 case 164: dvi_y(get3s(dvi)); break;
  105.                 case 165: dvi_y(get4s(dvi)); break;
  106.                 case 166: dvi_z0(); break;
  107.                 case 167: dvi_z(get1s(dvi)); break;
  108.                 case 168: dvi_z(get2s(dvi)); break;
  109.                 case 169: dvi_z(get3s(dvi)); break;
  110.                 case 170: dvi_z(get4s(dvi)); break;
  111.                 /*...*/
  112.                 case 235: dvi_fnt(get1(dvi)); break;
  113.                 case 236: dvi_fnt(get2(dvi)); break;
  114.                 case 237: dvi_fnt(get3(dvi)); break;
  115.                 case 238: dvi_fnt(get4s(dvi)); break;
  116.                 case 239: dvi_xxx(get1(dvi),dvi); break;
  117.                 case 240: dvi_xxx(get2(dvi),dvi); break;
  118.                 case 241: dvi_xxx(get3(dvi),dvi); break;
  119.                 case 242: dvi_xxx(get4(dvi),dvi); break;
  120.                 case 243: dvi_fnt_def(get1(dvi),dvi); break;
  121.                 case 244: dvi_fnt_def(get2(dvi),dvi); break;
  122.                 case 245: dvi_fnt_def(get3(dvi),dvi); break;
  123.                 case 246: dvi_fnt_def(get4s(dvi),dvi); break;
  124.                 case 247:
  125.                         fseek(dvi,1,SEEK_CUR);
  126.                         num=get4(dvi);
  127.                         den=get4(dvi);
  128.                         mag=get4(dvi);
  129.                         i=get1(dvi);
  130.                         { char *buffer = malloc(i);
  131.                         fread(buffer,1,i,dvi);
  132.                         dvi_pre(num,den,mag,i,buffer);
  133.                         free(buffer);
  134.                         }
  135.                         break;
  136.                 case 248:
  137.                         p=get4s(dvi); num=get4(dvi); den=get4(dvi); mag=get4(dvi);
  138.                         l=get4(dvi); u=get4(dvi); s=get2(dvi); t=get2(dvi);
  139.                         dvi_post(p,num,den,mag,l,u,s,t);
  140.                         break;
  141.                 case 249: dvi_post_post(); goto done;
  142.                 default:
  143.                         if(op<128) dvi_set_char(op);
  144.                         else if(op<235) dvi_fnt(op-171);
  145.                 }
  146.         done: ;
  147. }
  148.