dscparse.cpp

okular

    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 {
	dsc->line = dsc->data + dsc->data_index;
	last = dsc->data + dsc->data_length;
	if (dsc->data_index == dsc->data_length) {
	    dsc->line_length = 0;
	    return 0;
	}