home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 600-699 / ff669.lha / Post / post17s.lzh / postinit.c < prev    next >
C/C++ Source or Header  |  1992-03-13  |  8KB  |  331 lines
  1. /* PostScript interpreter file "postinit.c" - initialiation (Amiga)
  2.  * (C) Adrian Aylward 1989, 1991
  3.  *
  4.  * This file contains the code to initialise the interpreter library and
  5.  * interpret a file or string. It is heavily Amiga dependent, and also
  6.  * Lattice dependent for the construction of file handles and the break
  7.  * and floating point error routines.
  8.  */
  9.  
  10. # include "post.h"
  11.  
  12. # include <dos.h>
  13. # include <exec/exec.h>
  14. # include <exec/execbase.h>
  15. # include <proto/dos.h>
  16. # include <proto/exec.h>
  17. # include <fcntl.h>
  18. # include <ios1.h>
  19.  
  20. # include "postlib.h"
  21.  
  22. /* Assembler routines */
  23.  
  24. extern void flushpage(int y1, int y2);
  25. extern int  callextfunc(APTR func, int *argv, int argc);
  26.  
  27. /* The version number */
  28.  
  29. char version[] = POSTVER " Copyright Adrian Aylward 1989, 1992";
  30.  
  31. /* Lattice startup */
  32.  
  33. extern struct UFB _ufbs[];
  34.  
  35. /* External data (initialised to zero) */
  36.  
  37. APTR userdata, flushfunc, copyfunc;
  38.  
  39. int flushflag, flushlev, flushy1, flushy2;
  40.  
  41. int funcmax;
  42.  
  43. APTR *functab;
  44.  
  45. /* Machine type flags */
  46.  
  47. # ifdef M68881
  48. short attnflags = AFF_68881|AFF_68020;
  49. # else
  50. short attnflags = 0;
  51. # endif
  52.  
  53. /* Call external function */
  54.  
  55. void opcallextfunc(void)
  56. {   struct object *token1, *token2, *aptr;
  57.     int argv[maxargs], argc, ires, func, i;
  58.     if (opernest < 2) error(errstackunderflow);
  59.     token2 = &operstack[opernest - 1];
  60.     token1 = token2 - 1;
  61.     if (token1->type != typeint) error(errtypecheck);
  62.     argc = token1->value.ival;
  63.     if (argc < 0) error(errrangecheck);
  64.     if (argc > maxargs) error(errlimitcheck);
  65.     if (opernest < argc + 3) error(errstackunderflow);
  66.     if (token2->type != typeint) error(errtypecheck);
  67.     func = token2->value.ival;
  68.     if (func < 0 || func >= funcmax) error(errrangecheck);
  69.     aptr = token1;
  70.     i = argc;
  71.     while (i)
  72.     {   i--;
  73.         aptr--;
  74.         switch (aptr->type)
  75.         {   case typeint:
  76.             case typereal:
  77.             case typebool:
  78.                 argv[i] = aptr->value.ival;
  79.                 break;
  80.  
  81.             case typearray:
  82.             case typestring:
  83.                 argv[i] = (int) vmvptr(aptr->value.vref);
  84.                 break;
  85.  
  86.             default:
  87.                 error(errtypecheck);
  88.         }
  89.     }
  90.     aptr--;
  91.     ires = callextfunc(functab[func], argv, argc);
  92.     if      (aptr->type == typenull)
  93.         argc++;
  94.     else if (aptr->type == typeint ||
  95.              aptr->type == typebool ||
  96.              aptr->type == typereal)
  97.         aptr->value.ival = ires;
  98.     else
  99.         error(errtypecheck);
  100.     opernest -= (argc + 2);
  101. }
  102.  
  103. /* Initialise the interpreter
  104.  *
  105.  * N.B. this routine cannot use floating point, as we don't check for the
  106.  * presence of a fpu until after we have entered it */
  107.  
  108. int initialise(struct PSparm *parm)
  109. {   memcpy((char *) &page, (char *) &parm->page, sizeof page);
  110.  
  111.     userdata = parm->userdata;
  112.     flushfunc = parm->flushfunc;
  113.     copyfunc = parm->copyfunc;
  114.  
  115.     funcmax = parm->funcmax;
  116.     functab = parm->functab;
  117.  
  118.     /* Convert the DOS filehandles to unbuffered C files */
  119.  
  120.     _ufbs[0].ufbfh = (long) parm->infh;
  121.     _ufbs[0].ufbflg |= UFB_RA|O_RAW|UFB_NC;
  122.     _ufbs[1].ufbfh = (long) parm->outfh;
  123.     _ufbs[1].ufbflg |= UFB_WA|O_RAW|UFB_NC;
  124.     _ufbs[2].ufbfh = (long) parm->errfh;
  125.     _ufbs[2].ufbflg |= UFB_WA|O_RAW|UFB_NC;
  126.     stdin->_file = 0;
  127.     stdin->_flag = _IOREAD;
  128.     stdout->_file = 1;
  129.     stdout->_flag = _IOWRT;
  130.     stderr->_file = 2;
  131.     stderr->_flag = _IOWRT;
  132.     setbuf(stdin, NULL);
  133.     setbuf(stdout, NULL);
  134.     setbuf(stderr, NULL);
  135.  
  136.     /* Copy parameters and allocate memory */
  137.  
  138.     memflen = parm->memflen;
  139.     memhlen = parm->memhlen;
  140.     memvmin = parm->memvlen;
  141.     memlmin = parm->memllen;
  142.     if (memflen == 0) memflen = defmemflen;
  143.     if (memhlen == 0) memhlen = defmemhlen;
  144.     if (memvmin == 0) memvmin = defmemvlen;
  145.     if (memlmin == 0) memlmin = defmemllen;
  146.     if (memflen < minmemflen) memflen = minmemflen;
  147.     if (memhlen < minmemhlen) memhlen = minmemhlen;
  148.     if (memvmin < minmemvlen) memvmin = minmemvlen;
  149.     if (memlmin < minmemllen) memlmin = minmemllen;
  150.     mempmin = memlmin / 3;
  151.     memlmin -= mempmin;
  152.     memllen = memplen = memilen = memxlen = memylen = 0;
  153.     memlbeg = mempbeg = memibeg = memxbeg = memybeg = NULL;
  154.     if ((memfbeg = memalloc(memflen)) == NULL ||
  155.         (memhbeg = memalloc(memhlen)) == NULL)
  156.         return 0;
  157.  
  158.     /* Set up a temporary error trap and initialise the interpreter */
  159.  
  160.     errorflag = 0;
  161.     if (setjmp(istate.errjmp) != 0)
  162.     {   fprintf(sstderr, "post: error: %s, during initialisation\n",
  163.                 errorstring);
  164.         return errornum;
  165.     }
  166.     initint(1);
  167.     if (funcmax != 0) systemop(opcallextfunc, "callextfunc");
  168.     return -1;
  169. }
  170.  
  171. /* Terminate interpreter */
  172.  
  173. void terminate(void)
  174. {   tidyint();
  175.     memfree(memfbeg, memflen); memfbeg = NULL;
  176.     memfree(memhbeg, memhlen); memhbeg = NULL;
  177.     memfree(memlbeg, memllen); memlbeg = NULL; memllen = 0;
  178.     memfree(mempbeg, memplen); mempbeg = NULL; memplen = 0;
  179.     memfree(memibeg, memilen); memibeg = NULL; memilen = 0;
  180.     memfree(memxbeg, memxlen); memxbeg = NULL; memxlen = 0;
  181.     memfree(memybeg, memylen); memybeg = NULL; memylen = 0;
  182. }
  183.  
  184. /* Interpret a string or file */
  185.  
  186. int intstring(char *string, int length, int flags)
  187. {   struct object token, saveobj;
  188.     returncode = 0;
  189.     if (length < 0) length = strlen(string);
  190.     errorflag = 0;
  191.     if (setjmp(istate.errjmp) != 0) goto err;
  192.     prompting = 0;
  193.     if (flags & PSFLAGINTER)
  194.     {   prompting = 1;
  195.         fprintf(sstdout, "%s\n", version);
  196.     }
  197.     if (flags & PSFLAGSAVE)
  198.         vmsave(&saveobj);
  199.     if (flags & PSFLAGSTRING)
  200.     {   vmparm(0, string, length);
  201.         token.type = typestring;
  202.         token.flags = flagexec;
  203.         token.length = length;
  204.         token.value.vref = vmxref(0,0);
  205.         errorflag = 2;
  206.         interpret(&token);
  207.         errorflag = 0;
  208.     }
  209.     if (flags & PSFLAGFILE)
  210.     {   vmparm(0, NULL, 0);
  211.         fileopen(&token, openread | openfont, string, length);
  212.         token.flags |= flagexec;
  213.         errorflag = 2;
  214.         interpret(&token);
  215.         errorflag = 0;
  216.         fileclose(&token);
  217.     }
  218.     if (setjmp(istate.errjmp) != 0) goto err;
  219.     execnest = 0;
  220.     if (flags & PSFLAGCLEAR)
  221.     {   dictnest = 2;
  222.         opernest = 0;
  223.     }
  224.     if (flags & PSFLAGSAVE)
  225.         vmrest(saveobj.length, saveobj.value.ival);
  226.     if (flags & PSFLAGERASE)
  227.         erasepage();
  228.     if (returncode) return errornum;
  229.     return 0;
  230.  
  231. err:
  232.     fprintf(sstderr, 
  233.             (flags & PSFLAGFILE) ?
  234.                 "post: error: %s, file %*.*s\n" :
  235.                 "post: error: %s\n",
  236.             errorstring, length, length, string);
  237.     return -1;
  238. }
  239.  
  240. /* Convert an error number to a text string */
  241.  
  242. char *errstr(int errnum)
  243. {   return (errnum > 0 && errnum <= errmax) ?
  244.         errortable[errnum] : NULL;
  245. }
  246.  
  247. /* Dummy stub routine */
  248.  
  249. void stub(void)
  250. {   return;
  251. }
  252.  
  253. /* Dummy check abort routine */
  254.  
  255. void chkabort(void)
  256. {   return;
  257. }
  258.  
  259. /* A floating point error triggers "undefinedresult". */
  260.  
  261. void CXFERR(int code)
  262. {   error(errundefinedresult);
  263. }
  264.  
  265. /* A maths error triggers "undefinedresult". */
  266.  
  267. int matherr(struct exception *x)
  268. {   error(errundefinedresult);
  269.     return 0;
  270. }
  271.  
  272. /* Signal a floating point error */
  273.  
  274. void signalfpe(void)
  275. {   error(errundefinedresult);
  276. }
  277.  
  278. /* Signal an interrupt */
  279.  
  280. void signalint(int flag)
  281. {   intsigflag = flag;
  282. }
  283.  
  284. /* Set the page flush level */
  285.  
  286. int flushlevel(int lev)
  287. {   if (lev == -1)
  288.         return flushlev++;
  289.     else
  290.     {   flushlev = lev;
  291.         if (lev == 0)
  292.             if (flushflag != 0)
  293.             {   flushflag = 0;
  294.                 if (flushy1 != flushy2) flushpage(flushy1, flushy2);
  295.             }
  296.         return lev;
  297.     }
  298. }
  299.  
  300. /* Flush the page to the screen, according to the level */
  301.  
  302. void flushlpage(int y1, int y2)
  303. {   if (flushlev == 0)
  304.     {   if (y1 != y2) flushpage(y1, y2);
  305.     }
  306.     else
  307.         if (flushflag == 0)
  308.         {   flushflag = 1;
  309.             flushy1 = y1;
  310.             flushy2 = y2;
  311.         }
  312.         else
  313.         {   if (y1 < flushy1) flushy1 = y1;
  314.             if (y2 > flushy2) flushy2 = y2;
  315.         }
  316. }
  317.  
  318. /* Allocate memory and clear it */
  319.  
  320. void *memalloc(int length)
  321. {   return AllocMem(length, MEMF_CLEAR);
  322. }
  323.  
  324. /* Free memory */
  325.  
  326. void memfree(void *beg, int length)
  327. {   if (beg) FreeMem(beg, length);
  328. }
  329.  
  330. /* End of file "postinit.c" */
  331.