/* SPDX-FileCopyrightText: 2000-2001 Ghostgum Software Pty Ltd. All rights reserved.

  This file is part of GSview.

  This file is distributed in the hope that it will be useful, but

  WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility

  to anyone for the consequences of using it or for whether it serves any

  particular purpose or works at all, unless he says so in writing.  Refer

  to the GNU General Public License for full details.

  Everyone is granted permission to copy, modify and redistribute this

  file, but only under the conditions described in the GNU General

  Public License.  A copy of this license is supposed to have been given

  to you along with this file so you can know your rights and

  responsibilities.  It should be in a file named COPYING.  Among other

  things, the copyright notice and this notice must be preserved on all

  copies.

*/

/* $Id$ */

/* dscparse.c - DSC parser  */

/*

 * This is a DSC parser, based on the DSC 3.0 spec, 

 * with a few DSC 2.1 additions for page size.

 *

 * Current limitations:

 * %%+ may be used after any comment in the comment or trailer, 

 * but is currently only supported by

 *   %%DocumentMedia

 *

 * DSC 2.1 additions (discontinued in DSC 3.0):

 * %%DocumentPaperColors: 

 * %%DocumentPaperForms: 

 * %%DocumentPaperSizes: 

 * %%DocumentPaperWeights: 

 * %%PaperColor:   (ignored)

 * %%PaperForm:    (ignored)

 * %%PaperSize: 

 * %%PaperWeight:  (ignored)

 *

 * Other additions for defaults or page section

 % %%ViewingOrientation: xx xy yx yy

*/

#include <stdio.h>  /* for sprintf(), not file I/O */

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#define MAXSTR 256

#include "dscparse.h"

/* Macros for comparing string literals

 * For maximum speed, the length of the second macro argument is

 * computed at compile time.

 * THE SECOND MACRO ARGUMENT MUST BE A STRING LITERAL.

 */

#define COMPARE(p,str) (strncmp((const char *)(p), (str), sizeof(str)-1)==0)

#define IS_DSC(line, str) (COMPARE((line), (str)))

/* Macros for comparing the first one or two characters */

#define IS_WHITE(ch) (((ch)==' ') || ((ch)=='\t'))

#define IS_EOL(ch) (((ch)=='\r') || ((ch)=='\n'))

#define IS_WHITE_OR_EOL(ch) (IS_WHITE(ch) || IS_EOL(ch))

#define IS_BLANK(str) (IS_EOL(str[0]))

#define NOT_DSC_LINE(str) (((str)[0]!='%') || ((str)[1]!='%'))

/* Macros for document offset to start and end of line */

#define DSC_START(dsc)  ((dsc)->data_offset + (dsc)->data_index - (dsc)->line_length)

#define DSC_END(dsc)  ((dsc)->data_offset + (dsc)->data_index)

/* dsc_scan_SECTION() functions return one of 

 * CDSC_ERROR, CDSC_OK, CDSC_NOTDSC 

 * or one of the following

 */

/* The line should be passed on to the next section parser. */

#define CDSC_PROPAGATE  10

/* If document is DOS EPS and we haven't read 30 bytes, ask for more. */

#define CDSC_NEEDMORE 11

/* local prototypes */

dsc_private void * dsc_memalloc(P2(CDSC *dsc, size_t size));

dsc_private void dsc_memfree(P2(CDSC*dsc, void *ptr));

dsc_private CDSC * dsc_init2(P1(CDSC *dsc));

dsc_private void dsc_reset(P1(CDSC *dsc));

dsc_private void dsc_section_join(P3(unsigned long begin, unsigned long *pend, unsigned long **pplast));

dsc_private int dsc_read_line(P1(CDSC *dsc));

dsc_private int dsc_read_doseps(P1(CDSC *dsc));

dsc_private char * dsc_alloc_string(P3(CDSC *dsc, const char *str, int len));

dsc_private char * dsc_add_line(P3(CDSC *dsc, const char *line, unsigned int len));

dsc_private char * dsc_copy_string(P5(char *str, unsigned int slen, 

    char *line, unsigned int len, unsigned int *offset));

dsc_private GSDWORD dsc_get_dword(P1(const unsigned char *buf));

dsc_private GSWORD dsc_get_word(P1(const unsigned char *buf));

dsc_private int dsc_get_int(P3(const char *line, unsigned int len, unsigned int *offset));

dsc_private float dsc_get_real(P3(const char *line, unsigned int len, 

    unsigned int *offset));

dsc_private int dsc_stricmp(P2(const char *s, const char *t));

dsc_private void dsc_unknown(P1(CDSC *dsc)); 

dsc_private GSBOOL dsc_is_section(char *line);

dsc_private int dsc_parse_pages(P1(CDSC *dsc));

dsc_private int dsc_parse_bounding_box(P3(CDSC *dsc, CDSCBBOX** pbbox, int offset));

dsc_private int dsc_parse_float_bounding_box(P3(CDSC *dsc, CDSCFBBOX** pfbbox, int offset));

dsc_private int dsc_parse_orientation(P3(CDSC *dsc, unsigned int *porientation, 

    int offset));

dsc_private int dsc_parse_order(P1(CDSC *dsc));

dsc_private int dsc_parse_media(P2(CDSC *dsc, const CDSCMEDIA **page_media));

dsc_private int dsc_parse_document_media(P1(CDSC *dsc));

dsc_private int dsc_parse_viewing_orientation(P2(CDSC *dsc, CDSCCTM **pctm));

dsc_private int dsc_parse_page(P1(CDSC *dsc));

dsc_private void dsc_save_line(P1(CDSC *dsc));

dsc_private int dsc_scan_type(P1(CDSC *dsc));

dsc_private int dsc_scan_comments(P1(CDSC *dsc));

dsc_private int dsc_scan_preview(P1(CDSC *dsc));

dsc_private int dsc_scan_defaults(P1(CDSC *dsc));

dsc_private int dsc_scan_prolog(P1(CDSC *dsc));

dsc_private int dsc_scan_setup(P1(CDSC *dsc));

dsc_private int dsc_scan_page(P1(CDSC *dsc));

dsc_private int dsc_scan_trailer(P1(CDSC *dsc));

dsc_private int dsc_error(P4(CDSC *dsc, unsigned int explanation, 

    char *line, unsigned int line_len));

/* DSC error reporting */

dsc_private const int dsc_severity[] = {

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_BBOX */

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_EARLY_TRAILER */

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_EARLY_EOF */

    CDSC_ERROR_ERROR,   /* CDSC_MESSAGE_PAGE_IN_TRAILER */

    CDSC_ERROR_ERROR,   /* CDSC_MESSAGE_PAGE_ORDINAL */

    CDSC_ERROR_ERROR,   /* CDSC_MESSAGE_PAGES_WRONG */

    CDSC_ERROR_ERROR,   /* CDSC_MESSAGE_EPS_NO_BBOX */

    CDSC_ERROR_ERROR,   /* CDSC_MESSAGE_EPS_PAGES */

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_NO_MEDIA */

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_ATEND */

    CDSC_ERROR_INFORM,  /* CDSC_MESSAGE_DUP_COMMENT */

    CDSC_ERROR_INFORM,  /* CDSC_MESSAGE_DUP_TRAILER */

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_BEGIN_END */

    CDSC_ERROR_INFORM,  /* CDSC_MESSAGE_BAD_SECTION */

    CDSC_ERROR_INFORM,  /* CDSC_MESSAGE_LONG_LINE */

    CDSC_ERROR_WARN,  /* CDSC_MESSAGE_INCORRECT_USAGE */

    0

};

#define DSC_MAX_ERROR ((sizeof(dsc_severity) / sizeof(int))-2)

const CDSCMEDIA dsc_known_media[CDSC_KNOWN_MEDIA] = {

    /* These sizes taken from Ghostscript gs_statd.ps */

    {"11x17", 792, 1224, 0, NULL, NULL, NULL},

    {"A0", 2380, 3368, 0, NULL, NULL, NULL},

    {"A1", 1684, 2380, 0, NULL, NULL, NULL}, 

    {"A2", 1190, 1684, 0, NULL, NULL, NULL}, 

    {"A3", 842, 1190, 0, NULL, NULL, NULL},

    {"A4", 595, 842, 0, NULL, NULL, NULL},

    {"A5", 421, 595, 0, NULL, NULL, NULL},

    {"A6", 297, 421, 0, NULL, NULL, NULL}, 

    {"A7", 210, 297, 0, NULL, NULL, NULL}, 

    {"A8", 148, 210, 0, NULL, NULL, NULL}, 

    {"A9", 105, 148, 0, NULL, NULL, NULL}, 

    {"A10", 74, 105, 0, NULL, NULL, NULL}, 

    {"B0", 2836, 4008, 0, NULL, NULL, NULL}, 

    {"B1", 2004, 2836, 0, NULL, NULL, NULL}, 

    {"B2", 1418, 2004, 0, NULL, NULL, NULL}, 

    {"B3", 1002, 1418, 0, NULL, NULL, NULL}, 

    {"B4", 709, 1002, 0, NULL, NULL, NULL}, /* ISO, but not Adobe standard */

    {"B5", 501, 709, 0, NULL, NULL, NULL},  /* ISO, but not Adobe standard */

    {"B6", 354, 501, 0, NULL, NULL, NULL}, 

    {"C0", 2600, 3677, 0, NULL, NULL, NULL}, 

    {"C1", 1837, 2600, 0, NULL, NULL, NULL},  

    {"C2", 1298, 1837, 0, NULL, NULL, NULL}, 

    {"C3", 918, 1298, 0, NULL, NULL, NULL}, 

    {"C4", 649, 918, 0, NULL, NULL, NULL}, 

    {"C5", 459, 649, 0, NULL, NULL, NULL}, 

    {"C6", 323, 459, 0, NULL, NULL, NULL}, 

    {"Ledger", 1224, 792, 0, NULL, NULL, NULL},

    {"Legal", 612, 1008, 0, NULL, NULL, NULL},

    {"Letter", 612, 792, 0, NULL, NULL, NULL},

    {"Note", 612, 792, 0, NULL, NULL, NULL},

// ISO and JIS B sizes are different....

    {"jisb0", 2916, 4128, 0, NULL, NULL, NULL},

    {"jisb1", 2064, 2916, 0, NULL, NULL, NULL}, 

    {"jisb2", 1458, 2064, 0, NULL, NULL, NULL}, 

    {"jisb3", 1032, 1458, 0, NULL, NULL, NULL}, 

    {"jisb4", 729, 1032, 0, NULL, NULL, NULL}, 

    {"jisb5", 516, 729, 0, NULL, NULL, NULL}, 

    {"jisb6", 363, 516, 0, NULL, NULL, NULL}, 

// U.S. CAD standard paper sizes

    {"archE", 2592, 3456, 0, NULL, NULL, NULL}, 

    {"archD", 1728, 2592, 0, NULL, NULL, NULL}, 

    {"archC", 1296, 1728, 0, NULL, NULL, NULL}, 

    {"archB", 864, 1296, 0, NULL, NULL, NULL}, 

    {"archA", 648, 864, 0, NULL, NULL, NULL}, 

// Other paper sizes

    {"flsa", 612, 936, 0, NULL, NULL, NULL}, /* U.S. foolscap */

    {"flse", 612, 936, 0, NULL, NULL, NULL}, /* European foolscap */

    {"halfletter", 396, 612, 0, NULL, NULL, NULL}, 

    {NULL, 0, 0, 0, NULL, NULL, NULL}

};

/* parser state */

enum CDSC_SCAN_SECTION {

    scan_none = 0,

    scan_comments = 1,

    scan_pre_preview = 2,

    scan_preview = 3,

    scan_pre_defaults = 4,

    scan_defaults = 5,

    scan_pre_prolog = 6,

    scan_prolog = 7,

    scan_pre_setup = 8,

    scan_setup = 9,

    scan_pre_pages = 10,

    scan_pages = 11,

    scan_pre_trailer = 12,

    scan_trailer = 13,

    scan_eof = 14

};

static const char * const dsc_scan_section_name[15] = {

 "Type", "Comments", 

 "pre-Preview", "Preview",

 "pre-Defaults", "Defaults",

 "pre-Prolog", "Prolog",

 "pre-Setup", "Setup",

 "pre-Page", "Page",

 "pre-Trailer", "Trailer",

 "EOF"

};

/******************************************************************/

/* Public functions                                               */

/******************************************************************/

/* constructor */

CDSC *

dsc_init(void *caller_data)

{

    CDSC *dsc = (CDSC *)malloc(sizeof(CDSC));

    if (dsc == NULL)

  return NULL;

    memset(dsc, 0, sizeof(CDSC));

    dsc->caller_data = caller_data;

    return dsc_init2(dsc);

}

/* constructor, with caller supplied memalloc */

CDSC *

dsc_init_with_alloc(

    void *caller_data,

    void *(*memalloc)(size_t size, void *closure_data),

    void (*memfree)(void *ptr, void *closure_data),

    void *closure_data)

{

    CDSC *dsc = (CDSC *)memalloc(sizeof(CDSC), closure_data);

    if (dsc == NULL)

  return NULL;

    memset(dsc, 0, sizeof(CDSC));

    dsc->caller_data = caller_data;

    dsc->memalloc = memalloc;

    dsc->memfree = memfree;

    dsc->mem_closure_data = closure_data;

    return dsc_init2(dsc);

}

/* destructor */

void 

dsc_free(CDSC *dsc)

{

    if (dsc == NULL)

  return;

    dsc_reset(dsc);

    dsc_memfree(dsc, dsc);

}

/* Tell DSC parser how long document will be, to allow ignoring

 * of early %%Trailer and %%EOF.  This is optional.

 */

void 

dsc_set_length(CDSC *dsc, unsigned long len)

{

    dsc->file_length = len;

}

/* Process a buffer containing DSC comments and PostScript */

/* Return value is < 0 for error, >=0 for OK.

 *  CDSC_ERROR

 *  CDSC_OK

 *  CDSC_NOTDSC (DSC will be ignored)

 *  other values indicate the last DSC comment read

 */ 

int

dsc_scan_data(CDSC *dsc, const char *data, int length)

{

    int bytes_read;

    int code = 0;

    if (dsc == NULL)

  return CDSC_ERROR;

    if (dsc->id == CDSC_NOTDSC)

  return CDSC_NOTDSC;

    dsc->id = CDSC_OK;

    if (dsc->eof)

  return CDSC_OK; /* ignore */

    if (length == 0) {

  /* EOF, so process what remains */

  dsc->eof = TRUE;

    }

    do {

  if (dsc->id == CDSC_NOTDSC)

      break;

  if (length != 0) {

      if (dsc->data_index > dsc->data_length)

    return CDSC_NOTDSC;

      /* move existing data if needed */

      if (dsc->data_length > CDSC_DATA_LENGTH/2) {

    memmove(dsc->data, dsc->data + dsc->data_index,

        dsc->data_length - dsc->data_index);

    dsc->data_offset += dsc->data_index;

    dsc->data_length -= dsc->data_index;

    dsc->data_index = 0;

      }

      /* append to buffer */

      bytes_read = min(length, (int)(CDSC_DATA_LENGTH - dsc->data_length));

      memcpy(dsc->data + dsc->data_length, data, bytes_read);

      dsc->data_length += bytes_read;

      data += bytes_read;

      length -= bytes_read;

  }

  if (dsc->scan_section == scan_none) {

      code = dsc_scan_type(dsc);

      if (code == CDSC_NEEDMORE) {

    /* need more characters before we can identify type */

    code = CDSC_OK;

    break;

      }

      dsc->id = code;

  }

        if (code == CDSC_NOTDSC) {

      dsc->id = CDSC_NOTDSC;

      break;

  }

  while ((code = dsc_read_line(dsc)) > 0) {

      if (dsc->id == CDSC_NOTDSC)

    break;

      if (dsc->doseps_end && 

    (dsc->data_offset + dsc->data_index > dsc->doseps_end)) {

    /* have read past end of DOS EPS PostScript section */

    return CDSC_OK; /* ignore */

      }

      if (dsc->eof)

    return CDSC_OK;

      if (dsc->skip_document)

    continue;  /* embedded document */

      if (dsc->skip_lines)

    continue; /* embedded lines */

      if (IS_DSC(dsc->line, "%%BeginData:"))

    continue;

      if (IS_DSC(dsc->line, "%%BeginBinary:"))

    continue;

      if (IS_DSC(dsc->line, "%%EndDocument"))

    continue;

      if (IS_DSC(dsc->line, "%%EndData"))

    continue;

      if (IS_DSC(dsc->line, "%%EndBinary"))

    continue;

      do {

    switch (dsc->scan_section) {

        case scan_comments:

      code = dsc_scan_comments(dsc);

      break;

        case scan_pre_preview:

        case scan_preview:

      code = dsc_scan_preview(dsc);

      break;

        case scan_pre_defaults:

        case scan_defaults:

      code = dsc_scan_defaults(dsc);

      break;

        case scan_pre_prolog:

        case scan_prolog:

      code = dsc_scan_prolog(dsc);

      break;

        case scan_pre_setup:

        case scan_setup:

      code = dsc_scan_setup(dsc);

      break;

        case scan_pre_pages:

        case scan_pages:

      code = dsc_scan_page(dsc);

      break;

        case scan_pre_trailer:

        case scan_trailer:

      code = dsc_scan_trailer(dsc);

      break;

        case scan_eof:

      code = CDSC_OK;

      break;

        default:

      /* invalid state */

      code = CDSC_ERROR;

    }

    /* repeat if line is start of next section */

      } while (code == CDSC_PROPAGATE);

      /* if DOS EPS header not complete, ask for more */

      if (code == CDSC_NEEDMORE) {

    code = CDSC_OK;

    break;

      }

      if (code == CDSC_NOTDSC) {

    dsc->id = CDSC_NOTDSC;

    break;

      }

  }

    } while (length != 0);

    return (code < 0) ? code : dsc->id;

}

/* Tidy up from incorrect DSC comments */

int 

dsc_fixup(CDSC *dsc)

{

    unsigned int i;

    char buf[32];

    unsigned long *last;

    if (dsc->id == CDSC_NOTDSC)

  return 0;

    /* flush last partial line */

    dsc_scan_data(dsc, NULL, 0);

    /* Fix DSC error: code between %%EndSetup and %%Page */

    if (dsc->page_count && (dsc->page[0].begin != dsc->endsetup)

    && (dsc->endsetup != dsc->beginsetup)) {

  dsc->endsetup = dsc->page[0].begin;

  dsc_debug_print(dsc, "Warning: code included between setup and first page\n");

    }

    /* Last page contained a false trailer, */

    /* so extend last page to start of trailer */

    if (dsc->page_count && (dsc->begintrailer != 0) &&

  (dsc->page[dsc->page_count-1].end != dsc->begintrailer)) {

  dsc_debug_print(dsc, "Ignoring earlier misplaced trailer\n");

  dsc_debug_print(dsc, "and extending last page to start of trailer\n"); 

  dsc->page[dsc->page_count-1].end = dsc->begintrailer;

    }

    /* 

     * Join up all sections.

     * There might be extra code between them, or we might have

     * missed including the \n which followed \r.

     */

    last = &dsc->endcomments;

    dsc_section_join(dsc->beginpreview, &dsc->endpreview, &last);

    dsc_section_join(dsc->begindefaults, &dsc->enddefaults, &last);

    dsc_section_join(dsc->beginprolog, &dsc->endprolog, &last);

    dsc_section_join(dsc->beginsetup, &dsc->endsetup, &last);

    for (i=0; i<dsc->page_count; i++)

  dsc_section_join(dsc->page[i].begin, &dsc->page[i].end, &last);

    if (dsc->begintrailer)

  *last = dsc->begintrailer;

    if ((dsc->page_pages == 0) && (dsc->page_count == 1)) {

  /* don't flag an error if %%Pages absent but one %%Page found */

  /* adjust incorrect page count */

  dsc->page_pages = dsc->page_count;

    }

    /* Warnings and Errors that we can now identify */

    if ((dsc->page_count != dsc->page_pages)) {

  int rc = dsc_error(dsc, CDSC_MESSAGE_PAGES_WRONG, NULL, 0);

  switch (rc) {

      case CDSC_RESPONSE_OK:

    /* adjust incorrect page count */

    dsc->page_pages = dsc->page_count;

    break;

      case CDSC_RESPONSE_CANCEL:

    break;;

      case CDSC_RESPONSE_IGNORE_ALL:

    return CDSC_NOTDSC;

  }

    }

    if (dsc->epsf && (dsc->bbox == (CDSCBBOX *)NULL)) {

  /* EPS files MUST include a BoundingBox */

  int rc = dsc_error(dsc, CDSC_MESSAGE_EPS_NO_BBOX, NULL, 0);

  switch (rc) {

      case CDSC_RESPONSE_OK:

    /* Assume that it is EPS */

    break;

      case CDSC_RESPONSE_CANCEL:

    /* Is NOT an EPS file */

    dsc->epsf = FALSE;

      case CDSC_RESPONSE_IGNORE_ALL:

    return CDSC_NOTDSC;

  }

    }

    if (dsc->epsf && ((dsc->page_count > 1) || (dsc->page_pages > 1))) {

  int rc = dsc_error(dsc, CDSC_MESSAGE_EPS_PAGES, NULL, 0);

  switch (rc) {

      case CDSC_RESPONSE_OK:

    /* Is an EPS file */

    break;

      case CDSC_RESPONSE_CANCEL:

    /* Is NOT an EPS file */

    dsc->epsf = FALSE;

    break;

      case CDSC_RESPONSE_IGNORE_ALL:

    return CDSC_NOTDSC;

  }

    }

    if ((dsc->media_count == 1) && (dsc->page_media == NULL)) {

  /* if one only media was specified, and default page media */

  /* was not specified, assume that default is the only media. */

  dsc->page_media = dsc->media[0];

    }

    if ((dsc->media_count != 0) && (dsc->page_media == NULL)) {

  int rc = dsc_error(dsc, CDSC_MESSAGE_NO_MEDIA, NULL, 0);

  switch (rc) {

      case CDSC_RESPONSE_OK:

    /* default media is first listed */

    dsc->page_media = dsc->media[0];

    break;

      case CDSC_RESPONSE_CANCEL:

    /* No default media */

    break;

      case CDSC_RESPONSE_IGNORE_ALL:

    return CDSC_NOTDSC;

  }

    }

    /* make sure all pages have a label */

    for (i=0; i<dsc->page_count; i++) {

  if (strlen(dsc->page[i].label) == 0) {

      sprintf(buf, "%d", i+1);

      if ((dsc->page[i].label = dsc_alloc_string(dsc, buf, strlen(buf))) 

    == (char *)NULL)

    return CDSC_ERROR; /* no memory */

  }

    }

    return CDSC_OK;

}

/* Install a function to be used for displaying messages about 

 * DSC errors and warnings, and to request advice from user.

 * Installing an error function is optional.

 */

void 

dsc_set_error_function(CDSC *dsc, 

  int (*fn)(P5(void *caller_data, CDSC *dsc, 

  unsigned int explanation, const char *line, unsigned int line_len)))

{

    dsc->dsc_error_fn = fn;

}

/* Install a function for printing debug messages */

/* This is optional */

void 

dsc_set_debug_function(CDSC *dsc, 

  void (*debug_fn)(P2(void *caller_data, const char *str)))

{

    dsc->debug_print_fn = debug_fn;

}

/* Doesn't need to be public for PostScript documents */

/* Made public so GSview can add pages when processing PDF files */

int 

dsc_add_page(CDSC *dsc, int ordinal, char *label)

{

    dsc->page[dsc->page_count].ordinal = ordinal;

    dsc->page[dsc->page_count].label = 

  dsc_alloc_string(dsc, label, strlen(label)+1);

    dsc->page[dsc->page_count].begin = 0;

    dsc->page[dsc->page_count].end = 0;

    dsc->page[dsc->page_count].orientation = CDSC_ORIENT_UNKNOWN;

    dsc->page[dsc->page_count].media = NULL;

    dsc->page[dsc->page_count].bbox = NULL;

    dsc->page[dsc->page_count].viewing_orientation = NULL;

    dsc->page_count++;

    if (dsc->page_count >= dsc->page_chunk_length) {

  CDSCPAGE *new_page = (CDSCPAGE *)dsc_memalloc(dsc, 

      (CDSC_PAGE_CHUNK+dsc->page_count) * sizeof(CDSCPAGE));

  if (new_page == NULL)

      return CDSC_ERROR; /* out of memory */

  memcpy(new_page, dsc->page, 

      dsc->page_count * sizeof(CDSCPAGE));

  dsc_memfree(dsc, dsc->page);

  dsc->page= new_page;

  dsc->page_chunk_length = CDSC_PAGE_CHUNK+dsc->page_count;

    }

    return CDSC_OK;

}

/* Doesn't need to be public for PostScript documents */

/* Made public so GSview can store PDF MediaBox */

int

dsc_add_media(CDSC *dsc, CDSCMEDIA *media)

{

    CDSCMEDIA **newmedia_array;

    CDSCMEDIA *newmedia;

    /* extend media array  */

    newmedia_array = (CDSCMEDIA **)dsc_memalloc(dsc, 

  (dsc->media_count + 1) * sizeof(CDSCMEDIA *));

    if (newmedia_array == NULL)

  return CDSC_ERROR; /* out of memory */

    if (dsc->media != NULL) {

  memcpy(newmedia_array, dsc->media, 

      dsc->media_count * sizeof(CDSCMEDIA *));

  dsc_memfree(dsc, dsc->media);

    }

    dsc->media = newmedia_array;

    /* allocate new media */

    newmedia = dsc->media[dsc->media_count] =

  (CDSCMEDIA *)dsc_memalloc(dsc, sizeof(CDSCMEDIA));

    if (newmedia == NULL)

  return CDSC_ERROR; /* out of memory */

    newmedia->name = NULL;

    newmedia->width = 595.0;

    newmedia->height = 842.0;

    newmedia->weight = 80.0;

    newmedia->colour = NULL;

    newmedia->type = NULL;

    newmedia->mediabox = NULL;

    dsc->media_count++;

    if (media->name) {

  newmedia->name = dsc_alloc_string(dsc, media->name,

      strlen(media->name));

  if (newmedia->name == NULL)

      return CDSC_ERROR; /* no memory */

    }

    newmedia->width = media->width;

    newmedia->height = media->height;

    newmedia->weight = media->weight;

    if (media->colour) {

  newmedia->colour = dsc_alloc_string(dsc, media->colour, 

      strlen(media->colour));

        if (newmedia->colour == NULL)

      return CDSC_ERROR; /* no memory */

    }

    if (media->type) {

  newmedia->type = dsc_alloc_string(dsc, media->type, 

      strlen(media->type));

  if (newmedia->type == NULL)

      return CDSC_ERROR; /* no memory */

    }

    newmedia->mediabox = NULL;

    if (media->mediabox) {

  newmedia->mediabox = (CDSCBBOX *)dsc_memalloc(dsc, sizeof(CDSCBBOX));

  if (newmedia->mediabox == NULL)

      return CDSC_ERROR; /* no memory */

  *newmedia->mediabox = *media->mediabox;

    }

    return CDSC_OK;

}

/* Doesn't need to be public for PostScript documents */

/* Made public so GSview can store PDF CropBox */

int

dsc_set_page_bbox(CDSC *dsc, unsigned int page_number, 

    int llx, int lly, int urx, int ury)

{

    CDSCBBOX *bbox;

    if (page_number >= dsc->page_count)

  return CDSC_ERROR;

    bbox = dsc->page[page_number].bbox;

    if (bbox == NULL)

  dsc->page[page_number].bbox = bbox = 

      (CDSCBBOX *)dsc_memalloc(dsc, sizeof(CDSCBBOX));

    if (bbox == NULL)

  return CDSC_ERROR;

    bbox->llx = llx;

    bbox->lly = lly;

    bbox->urx = urx;

    bbox->ury = ury;

    return CDSC_OK;

}

/******************************************************************/

/* Private functions below here.                                  */

/******************************************************************/

dsc_private void *

dsc_memalloc(CDSC *dsc, size_t size)

{

    if (dsc->memalloc)

  return dsc->memalloc(size, dsc->mem_closure_data);

    return malloc(size);

}

dsc_private void

dsc_memfree(CDSC*dsc, void *ptr)

{

    if (dsc->memfree) 

  dsc->memfree(ptr, dsc->mem_closure_data);

    else

  free(ptr);

}

/* private constructor */

dsc_private CDSC *

dsc_init2(CDSC *dsc)

{

    dsc_reset(dsc);

    dsc->string_head = (CDSCSTRING *)dsc_memalloc(dsc, sizeof(CDSCSTRING));

    if (dsc->string_head == NULL) {

  dsc_free(dsc);

  return NULL; /* no memory */

    }

    dsc->string = dsc->string_head;

    dsc->string->next = NULL;

    dsc->string->data = (char *)dsc_memalloc(dsc, CDSC_STRING_CHUNK);

    if (dsc->string->data == NULL) {

  dsc_free(dsc);

  return NULL; /* no memory */

    }

    dsc->string->index = 0;

    dsc->string->length = CDSC_STRING_CHUNK;

    dsc->page = (CDSCPAGE *)dsc_memalloc(dsc, CDSC_PAGE_CHUNK * sizeof(CDSCPAGE));

    if (dsc->page == NULL) {

  dsc_free(dsc);

  return NULL; /* no memory */

    }

    dsc->page_chunk_length = CDSC_PAGE_CHUNK;

    dsc->page_count = 0;

    dsc->line = NULL;

    dsc->data_length = 0;

    dsc->data_index = dsc->data_length;

    return dsc;

}

dsc_private void 

dsc_reset(CDSC *dsc)

{

    unsigned int i;

    /* Clear public members */

    dsc->dsc = FALSE;

    dsc->ctrld = FALSE;

    dsc->pjl = FALSE;

    dsc->epsf = FALSE;

    dsc->pdf = FALSE;

    dsc->epsf = FALSE;

    dsc->preview = CDSC_NOPREVIEW;

    dsc->dsc_version = NULL; /* stored in dsc->string */

    dsc->language_level = 0;

    dsc->document_data = CDSC_DATA_UNKNOWN;

    dsc->begincomments = 0;

    dsc->endcomments = 0;

    dsc->beginpreview = 0;

    dsc->endpreview = 0;

    dsc->begindefaults = 0;

    dsc->enddefaults = 0;

    dsc->beginprolog = 0;

    dsc->endprolog = 0;

    dsc->beginsetup = 0;

    dsc->endsetup = 0;

    dsc->begintrailer = 0;

    dsc->endtrailer = 0;

    for (i=0; i<dsc->page_count; i++) {

  /* page media is pointer to an element of media or dsc_known_media */

  /* do not free it. */

  if (dsc->page[i].bbox)

      dsc_memfree(dsc, dsc->page[i].bbox);

  if (dsc->page[i].viewing_orientation)

      dsc_memfree(dsc, dsc->page[i].viewing_orientation);

    }

    if (dsc->page)

  dsc_memfree(dsc, dsc->page);

    dsc->page = NULL;

    dsc->page_count = 0;

    dsc->page_pages = 0;

    dsc->page_order = CDSC_ORDER_UNKNOWN;

    dsc->page_orientation = CDSC_ORIENT_UNKNOWN;

    if (dsc->viewing_orientation)

  dsc_memfree(dsc, dsc->viewing_orientation);

    dsc->viewing_orientation = NULL;

    if (dsc->media) {

  for (i=0; i<dsc->media_count; i++) {

      if (dsc->media[i]) {

    if (dsc->media[i]->mediabox)

        dsc_memfree(dsc, dsc->media[i]->mediabox);

    dsc_memfree(dsc, dsc->media[i]);

      }

  }

  dsc_memfree(dsc, dsc->media);

    }

    dsc->media_count = 0;

    dsc->media = NULL;

    /* page_media is pointer to an element of media or dsc_known_media */

    /* do not free it. */

    dsc->page_media = NULL;

    if (dsc->bbox)

  dsc_memfree(dsc, dsc->bbox);

    dsc->bbox = NULL;

    if (dsc->page_bbox)

  dsc_memfree(dsc, dsc->page_bbox);

    dsc->page_bbox = NULL;

    if (dsc->doseps)

  dsc_memfree(dsc, dsc->doseps);

    dsc->doseps = NULL;

    dsc->dsc_title = NULL;

    dsc->dsc_creator = NULL;

    dsc->dsc_date = NULL;

    dsc->dsc_for = NULL;

    dsc->max_error = DSC_MAX_ERROR;

    dsc->severity = dsc_severity;

    /* Clear private members */

    /* Don't touch dsc->caller_data */

    dsc->id = CDSC_OK;

    dsc->scan_section = scan_none;

    dsc->doseps_end = 0;

    dsc->page_chunk_length = 0;

    dsc->file_length = 0;

    dsc->skip_document = 0;

    dsc->skip_bytes = 0;

    dsc->skip_lines = 0;

    dsc->skip_pjl = 0;

    dsc->begin_font_count = 0;

    dsc->begin_feature_count = 0;

    dsc->begin_resource_count = 0;

    dsc->begin_procset_count = 0;

    dsc->data_length = 0;

    dsc->data_index = 0;

    dsc->data_offset = 0;

    dsc->eof = 0;

    dsc->line = 0;

    dsc->line_length = 0;

    dsc->eol = 0;

    dsc->last_cr = FALSE;

    dsc->line_count = 1;

    dsc->long_line = FALSE;

    memset(dsc->last_line, 0, sizeof(dsc->last_line));

    dsc->string = dsc->string_head;

    while (dsc->string != (CDSCSTRING *)NULL) {

  if (dsc->string->data)

      dsc_memfree(dsc, dsc->string->data);

  dsc->string_head = dsc->string;

  dsc->string = dsc->string->next;

  dsc_memfree(dsc, dsc->string_head);

    }

    dsc->string_head = NULL;

    dsc->string = NULL;

    /* don't touch caller functions */

    /* public data */

    if (dsc->hires_bbox)

  dsc_memfree(dsc, dsc->hires_bbox);

    dsc->hires_bbox = NULL;

    if (dsc->crop_box)

  dsc_memfree(dsc, dsc->crop_box);

    dsc->crop_box = NULL;

}

/* 

* Join up all sections.

* There might be extra code between them, or we might have

* missed including the \n which followed \r.

* begin is the start of this section

* pend is a pointer to the end of this section

* pplast is a pointer to a pointer of the end of the previous section

*/

dsc_private void 

dsc_section_join(unsigned long begin, unsigned long *pend, unsigned long **pplast)

{

    if (begin)

  **pplast = begin;

    if (*pend > begin)

  *pplast = pend;

}

/* return value is 0 if no line available, or length of line */

dsc_private int

dsc_read_line(CDSC *dsc)

{

    char *p, *last;

    dsc->line = NULL;

    if (dsc->eof) {

  /* return all that remains, even if line incomplete */

  dsc->line = dsc->data + dsc->data_index;

  dsc->line_length = dsc->data_length - dsc->data_index;

  dsc->data_index = dsc->data_length;

  return dsc->line_length;

    }

    /* ignore embedded bytes */

    if (dsc->skip_bytes) {

  int cnt = min(dsc->skip_bytes,

         (int)(dsc->data_length - dsc->data_index));

  dsc->skip_bytes -= cnt;

  dsc->data_index += cnt;

  if (dsc->skip_bytes != 0)

      return 0;

    }

    do {

  if (dsc->data_index >= dsc->data_length) {

      dsc->line_length = 0;

      return 0;

  }

  dsc->line = dsc->data + dsc->data_index;

  last = dsc->data + dsc->data_length;

  if (dsc->eol) {

      /* if previous line was complete, increment line count */

      dsc->line_count++;

      if (dsc->skip_lines)

    dsc->skip_lines--;

  }

  /* skip over \n which followed \r */

  if (dsc->last_cr && dsc->line[0] == '\n') {

      dsc->data_index++;

      dsc->line++;

  }

  dsc->last_cr = FALSE;

  /* look for EOL */

  dsc->eol = FALSE;

  for (p = dsc->line; p < last; p++) {

      if (*p == '\r') {

    p++;

    if ((p<last) && (*p == '\n'))

        p++;  /* include line feed also */

    else

        dsc->last_cr = TRUE; /* we might need to skip \n */

    dsc->eol = TRUE; /* dsc->line is a complete line */

    break;

      }

      if (*p == '\n') {

    p++;

    dsc->eol = TRUE; /* dsc->line is a complete line */

    break;

      }

      if (*p == '\032') {   /* MS-DOS Ctrl+Z */

    dsc->eol = TRUE;

      }

  }

  if (dsc->eol == FALSE) {

      /* we haven't got a complete line yet */

      if (dsc->data_length - dsc->data_index < sizeof(dsc->data)/2) {

    /* buffer is less than half full, ask for some more */

    dsc->line_length = 0;

    return 0;

      }

  }

  dsc->data_index += dsc->line_length = (p - dsc->line);

    } while (dsc->skip_lines && dsc->line_length);

    if (dsc->line_length == 0)

  return 0;

    if ((dsc->line[0]=='%') && (dsc->line[1]=='%'))  {

  /* handle recursive %%BeginDocument */

  if ((dsc->skip_document) && dsc->line_length &&

    COMPARE(dsc->line, "%%EndDocument")) {

      dsc->skip_document--;