home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 5 / FreshFish_July-August1994.bin / bbs / gnu / gs-2.6.1.4-src.lha / src / amiga / gs-2.6.1.4 / iscan.c < prev    next >
C/C++ Source or Header  |  1994-01-27  |  30KB  |  1,058 lines
  1. /* Copyright (C) 1989, 1992, 1993 Aladdin Enterprises.  All rights reserved.
  2.  
  3. This file is part of Ghostscript.
  4.  
  5. Ghostscript is distributed in the hope that it will be useful, but
  6. WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
  7. to anyone for the consequences of using it or for whether it serves any
  8. particular purpose or works at all, unless he says so in writing.  Refer
  9. to the Ghostscript General Public License for full details.
  10.  
  11. Everyone is granted permission to copy, modify and redistribute
  12. Ghostscript, but only under the conditions described in the Ghostscript
  13. General Public License.  A copy of this license is supposed to have been
  14. given to you along with Ghostscript so you can know your rights and
  15. responsibilities.  It should be in a file named COPYING.  Among other
  16. things, the copyright notice and this notice must be preserved on all
  17. copies.  */
  18.  
  19. /* iscan.c */
  20. /* Token scanner for Ghostscript interpreter */
  21. #include "ghost.h"
  22. #include "ctype_.h"
  23. #include "memory_.h"
  24. #include "stream.h"
  25. #include "alloc.h"
  26. #include "dict.h"            /* for //name lookup */
  27. #include "dstack.h"            /* ditto */
  28. #include "errors.h"
  29. #include "ilevel.h"
  30. #include "iname.h"
  31. #include "iscan.h"            /* defines interface */
  32. #include "iutil.h"
  33. #include "ivmspace.h"
  34. #include "ostack.h"            /* for accumulating proc bodies */
  35. #include "packed.h"
  36. #include "store.h"
  37. #include "scanchar.h"
  38.  
  39. /* Array packing flag */
  40. ref ref_array_packing;            /* t_boolean */
  41. /* Binary object format flag. This will never be set non-zero */
  42. /* unless the binary token feature is enabled. */
  43. ref ref_binary_object_format;        /* t_integer */
  44. #define recognize_btokens()\
  45.   (ref_binary_object_format.value.intval != 0 && level2_enabled)
  46.  
  47. /* Procedure for binary tokens.  Set at initialization if Level 2 */
  48. /* features are included; only called if recognize_btokens() is true. */
  49. /* Returns 0 or scan_BOS on success, <0 on failure. */
  50. int (*scan_btoken_proc)(P3(stream *, ref *, int)) = NULL;
  51.  
  52. /* Setup procedure for ASCII85 literals.  Set at initialization if Level 2 */
  53. /* features are included. */
  54. void (*scan_ascii85_setup_proc)(P4(stream *, stream *, byte *, uint)) = NULL;
  55.  
  56. /*
  57.  * Level 2 includes some changes in the scanner:
  58.  *    - \ is always recognized in strings, regardless of the data source;
  59.  *    - << and >> are legal tokens;
  60.  *    - <~ introduces an ASCII85 encoded string (terminated by ~>);
  61.  *    - Character codes above 127 introduce binary objects.
  62.  * We explicitly enable or disable these changes here.
  63.  */
  64. #define scan_enable_level2 level2_enabled    /* from ilevel.h */
  65.  
  66. /* Forward references */
  67. private    int    scan_ascii85_string(P2(stream *, ref *)),
  68.         scan_hex_string(P2(stream *, ref *)),
  69.         scan_int(P6(const byte **, const byte *, int, int,
  70.                 long *, double *)),
  71.         scan_number(P3(const byte *, const byte *, ref *)),
  72.         scan_string(P3(stream *, int, ref *));
  73.  
  74. /* Define the character scanning table (see scanchar.h). */
  75. byte scan_char_array[258];
  76.  
  77. /* A structure for dynamically growable objects */
  78. typedef struct dynamic_area_s {
  79.     byte *base;
  80.     byte *next;
  81.     uint num_elts;
  82.     uint elt_size;
  83.     int is_dynamic;            /* false if using fixed buffer */
  84.     byte *limit;
  85. } dynamic_area;
  86. typedef dynamic_area _ss *da_ptr;
  87.  
  88. /* Begin a dynamic object. */
  89. /* dynamic_begin returns the value of alloc, which may be 0: */
  90. /* the invoker of dynamic_begin must test the value against 0. */
  91. #define dynamic_begin(pda, dnum, desize)\
  92.     ((pda)->base = (byte *)alloc((pda)->num_elts = (dnum),\
  93.                      (pda)->elt_size = (desize), "scanner"),\
  94.      (pda)->limit = (pda)->base + (dnum) * (desize),\
  95.      (pda)->is_dynamic = 1,\
  96.      (pda)->next = (pda)->base)
  97. /* Begin a dynamically allocated string in a static buffer. */
  98. #define static_begin_string(pda, count, buf)\
  99.     ((pda)->num_elts = (count),\
  100.      (pda)->elt_size = 1,\
  101.      (pda)->is_dynamic = 0,\
  102.      (pda)->limit = (buf) + (count),\
  103.      (pda)->next = (pda)->base = (buf))
  104.  
  105. /* Free a dynamic object. */
  106. private void
  107. dynamic_free(da_ptr pda)
  108. {    if ( pda->is_dynamic )
  109.         alloc_free((char *)(pda->base), pda->num_elts, pda->elt_size,
  110.                "scanner");
  111. }
  112.  
  113. /* Grow a dynamic object. */
  114. /* If the allocation fails, free the old contents, and return NULL; */
  115. /* otherwise, return the new `next' pointer. */
  116. private byte *
  117. dynamic_grow(register da_ptr pda, byte *next)
  118. {    if ( next != pda->limit ) return next;
  119.     pda->next = next;
  120.        {    uint num = pda->num_elts;
  121.         uint old_size = num * pda->elt_size;
  122.         uint pos = pda->next - pda->base;
  123.         uint new_size = (old_size < 10 ? 20 :
  124.                  old_size >= (max_uint >> 1) ? max_uint :
  125.                  old_size << 1);
  126.         uint new_num = new_size / pda->elt_size;
  127.         if ( pda->is_dynamic )
  128.            {    byte *base = alloc_grow(pda->base, num, new_num, pda->elt_size, "scanner");
  129.             if ( base == 0 )
  130.                {    dynamic_free(pda);
  131.                 return NULL;
  132.                }
  133.             pda->base = base;
  134.             pda->num_elts = new_num;
  135.             pda->limit = pda->base + new_size;
  136.            }
  137.         else
  138.            {    byte *base = pda->base;
  139.             if ( !dynamic_begin(pda, new_num, pda->elt_size) ) return NULL;
  140.             memcpy(pda->base, base, old_size);
  141.             pda->is_dynamic = 1;
  142.            }
  143.         pda->next = pda->base + pos;
  144.        }
  145.     return pda->next;
  146. }
  147.  
  148. /* Initialize the scanner. */
  149. void
  150. scan_init(void)
  151. {    /* Initialize decoder array */
  152.     register byte _ds *decoder = scan_char_decoder;
  153.     static const char _ds *stop_chars = "()<>[]{}/%";
  154.     static const char _ds *space_chars = " \f\t\n\r";
  155.     decoder[ERRC] = ctype_eof;    /* ****** FIX THIS? ****** */
  156.     decoder[EOFC] = ctype_eof;
  157.     memset(decoder, ctype_name, 256);
  158.     memset(decoder + 128, ctype_btoken, 32);
  159.        {    register const char _ds *p;
  160.         for ( p = space_chars; *p; p++ )
  161.           decoder[*p] = ctype_space;
  162.         decoder[char_NULL] = decoder[char_VT] =
  163.           decoder[char_DOS_EOF] = ctype_space;
  164.         for ( p = stop_chars; *p; p++ )
  165.           decoder[*p] = ctype_other;
  166.        }
  167.        {    register int i;
  168.         for ( i = 0; i < 10; i++ )
  169.           decoder['0' + i] = i;
  170.         for ( i = 0; i < max_radix - 10; i++ )
  171.           decoder['A' + i] = decoder['a' + i] = i + 10;
  172.        }
  173.     /* Other initialization */
  174.     make_false(&ref_array_packing);
  175.     make_int(&ref_binary_object_format, 0);
  176. }
  177.  
  178. /*
  179.  * Read a token from a stream.
  180.  * Return 1 for end-of-stream, 0 if a token was read,
  181.  * or a (negative) error code.
  182.  * If the token required a terminating character (i.e., was a name or
  183.  * number) and the next character was whitespace, read and discard
  184.  * that character: see the description of the 'token' operator on
  185.  * p. 232 of the Red Book (First Edition).
  186.  * from_string indicates reading from a string vs. a file,
  187.  * because Level 1 interpreters ignore \ escapes in the former case.
  188.  * (See the footnote on p. 23 of the Red Book.)
  189.  */
  190. int
  191. scan_token(register stream *s, int from_string, ref *pref)
  192. {    ref *myref = pref;
  193.     dynamic_area proc_da;    /* (not actually dynamic) */
  194.     int pstack = 0;        /* offset from proc_da.base */
  195.     int retcode = 0;
  196.     register int c;
  197.     s_declare_inline(s, sptr, endptr);
  198. #define sreturn(code)\
  199.   { s_end_inline(s, sptr, endptr); return_error(code); }
  200. #define sreturn_no_error(code)\
  201.   { s_end_inline(s, sptr, endptr); return(code); }
  202.     int name_type;        /* number of /'s preceding */
  203.     int max_name_ctype =
  204.         (recognize_btokens() ? ctype_name : ctype_btoken);
  205.     int try_number;
  206.     byte s1[2];
  207.     register byte _ds *decoder = scan_char_decoder;
  208.     s_begin_inline(s, sptr, endptr);
  209. top:    c = sgetc_inline(s, sptr, endptr);
  210. #ifdef DEBUG
  211. if ( gs_debug['s'] )
  212.     fprintf(gs_debug_out, (c >= 32 && c <= 126 ? "`%c'" : "`%03o'"), c);
  213. #endif
  214.     switch ( c )
  215.        {
  216.     case ' ': case '\f': case '\t': case '\n': case '\r':
  217.     case char_NULL: case char_VT: case char_DOS_EOF:
  218.         goto top;
  219.     case '[':
  220.     case ']':
  221.         s1[0] = (byte)c;
  222.         name_ref(s1, 1, myref, 1);
  223.         r_set_attrs(myref, a_executable);
  224.         break;
  225.     case '<':
  226.         if ( scan_enable_level2 )
  227.            {    c = sgetc_inline(s, sptr, endptr);
  228.             switch ( c )
  229.                {
  230.             case '<':
  231.                 sputback_inline(s, sptr, endptr);
  232.                 name_type = try_number = 0;
  233.                 goto try_funny_name;
  234.             case '~':
  235.                 s_end_inline(s, sptr, endptr);
  236.                 retcode = scan_ascii85_string(s, myref);
  237.                 goto sx;
  238.                }
  239.             if ( char_is_data(c) )
  240.                 sputback_inline(s, sptr, endptr);
  241.            }
  242.         s_end_inline(s, sptr, endptr);
  243.         retcode = scan_hex_string(s, myref);
  244. sx:        s_begin_inline(s, sptr, endptr);
  245.         break;
  246.     case '(':
  247.         s_end_inline(s, sptr, endptr);
  248.         retcode = sc