13 files changed, 107 insertions, 20 deletions

diff --git a/xps/xpsdoc.c b/xps/xpsdoc.c
index c4724ec71..395153954 100644
--- a/xps/xpsdoc.c
+++ b/xps/xpsdoc.c
@@ -26,9 +26,18 @@ xps_new_part(xps_context_t *ctx, char *name, int size)
     xps_part_t *part;
 
     part = xps_alloc(ctx, sizeof(xps_part_t));
+    if (!part) {
+        gs_throw(gs_error_VMerror, "out of memory: xps_new_part\n");
+        return NULL;
+    }
     part->name = xps_strdup(ctx, name);
     part->size = size;
     part->data = xps_alloc(ctx, size);
+    if (!part->data) {
+        xps_free(ctx, part);
+        gs_throw(gs_error_VMerror, "out of memory: xps_new_part\n");
+        return NULL;
+    }
 
     return part;
 }
@@ -81,6 +90,10 @@ xps_add_fixed_document(xps_context_t *ctx, char *name)
     if_debug1m('|', ctx->memory, "doc: adding fixdoc %s\n", name);
 
     fixdoc = xps_alloc(ctx, sizeof(xps_document_t));
+    if (!fixdoc) {
+        gs_throw(gs_error_VMerror, "out of memory: xps_add_fixed_document\n");
+        return;
+    }
     fixdoc->name = xps_strdup(ctx, name);
     fixdoc->next = NULL;
 
@@ -124,6 +137,10 @@ xps_add_fixed_page(xps_context_t *ctx, char *name, int width, int height)
     if_debug1m('|', ctx->memory, "doc: adding page %s\n", name);
 
     page = xps_alloc(ctx, sizeof(xps_page_t));
+    if (!page) {
+        gs_throw(gs_error_VMerror, "out of memory: xps_add_fixed_page\n");
+        return;
+    }
     page->name = xps_strdup(ctx, name);
     page->width = width;
     page->height = height;
diff --git a/xps/xpsfont.c b/xps/xpsfont.c
index 20968cf1c..9a19021ac 100644
--- a/xps/xpsfont.c
+++ b/xps/xpsfont.c
@@ -53,7 +53,7 @@ xps_new_font(xps_context_t *ctx, byte *buf, int buflen, int index)
     font = xps_alloc(ctx, sizeof(xps_font_t));
     if (!font)
     {
-        gs_throw(-1, "out of memory");
+        gs_throw(gs_error_VMerror, "out of memory");
         return NULL;
     }
 
diff --git a/xps/xpsgradient.c b/xps/xpsgradient.c
index 60e1fa5eb..bf0335d5f 100644
--- a/xps/xpsgradient.c
+++ b/xps/xpsgradient.c
@@ -259,12 +259,20 @@ xps_create_gradient_stop_function(xps_context_t *ctx, struct stop *stops, int co
     k = count - 1; /* number of intervals / functions */
 
     domain = xps_alloc(ctx, 2 * sizeof(float));
+    if (!domain) {
+        gs_throw(gs_error_VMerror, "out of memory: domain\n");
+        return NULL;
+    }
     domain[0] = 0.0;
     domain[1] = 1.0;
     sparams.m = 1;
     sparams.Domain = domain;
 
     range = xps_alloc(ctx, 6 * sizeof(float));
+    if (!range) {
+        gs_throw(gs_error_VMerror, "out of memory: range\n");
+        return NULL;
+    }
     range[0] = 0.0;
     range[1] = 1.0;
     range[2] = 0.0;
@@ -274,8 +282,20 @@ xps_create_gradient_stop_function(xps_context_t *ctx, struct stop *stops, int co
     sparams.Range = range;
 
     functions = xps_alloc(ctx, k * sizeof(void*));
+    if (!functions) {
+        gs_throw(gs_error_VMerror, "out of memory: functions.\n");
+        return NULL;
+    }
     bounds = xps_alloc(ctx, (k - 1) * sizeof(float));
+    if (!bounds) {
+        gs_throw(gs_error_VMerror, "out of memory: bounds.\n");
+        return NULL;
+    }
     encode = xps_alloc(ctx, (k * 2) * sizeof(float));
+    if (!encode) {
+        gs_throw(gs_error_VMerror, "out of memory: encode.\n");
+        return NULL;
+    }
 
     sparams.k = k;
     sparams.Functions = functions;
@@ -296,12 +316,20 @@ xps_create_gradient_stop_function(xps_context_t *ctx, struct stop *stops, int co
     for (i = 0; i < k; i++)
     {
         domain = xps_alloc(ctx, 2 * sizeof(float));
+        if (!domain) {
+            gs_throw(gs_error_VMerror, "out of memory: domain.\n");
+            return NULL;
+    }
         domain[0] = 0.0;
         domain[1] = 1.0;
         lparams.m = 1;
         lparams.Domain = domain;
 
         range = xps_alloc(ctx, 6 * sizeof(float));
+        if (!range) {
+            gs_throw(gs_error_VMerror, "out of memory: range.\n");
+            return NULL;
+        }
         range[0] = 0.0;
         range[1] = 1.0;
         range[2] = 0.0;
@@ -311,9 +339,17 @@ xps_create_gradient_stop_function(xps_context_t *ctx, struct stop *stops, int co
         lparams.Range = range;
 
         c0 = xps_alloc(ctx, 3 * sizeof(float));
+        if (!c0) {
+            gs_throw(gs_error_VMerror, "out of memory: c0.\n");
+            return NULL;
+        }
         lparams.C0 = c0;
 
         c1 = xps_alloc(ctx, 3 * sizeof(float));
+        if (!c0) {
+            gs_throw(gs_error_VMerror, "out of memory: c1.\n");
+            return NULL;
+        }
         lparams.C1 = c1;
 
         if (opacity_only)
diff --git a/xps/xpshash.c b/xps/xpshash.c
index 2acdd8c9f..cda0c55cf 100644
--- a/xps/xpshash.c
+++ b/xps/xpshash.c
@@ -70,7 +70,7 @@ xps_hash_new(xps_context_t *ctx)
     table = xps_alloc(ctx, sizeof(xps_hash_table_t));
     if (!table)
     {
-        gs_throw(-1, "out of memory: hash table struct");
+        gs_throw(gs_error_VMerror, "out of memory: hash table struct");
         return NULL;
     }
 
@@ -81,7 +81,7 @@ xps_hash_new(xps_context_t *ctx)
     if (!table->entries)
     {
         xps_free(ctx, table);
-        gs_throw(-1, "out of memory: hash table entries array");
+        gs_throw(gs_error_VMerror, "out of memory: hash table entries array");
         return NULL;
     }
 
@@ -111,7 +111,7 @@ xps_hash_double(xps_context_t *ctx, xps_hash_table_t *table)
     old_entries = table->entries;
     new_entries = xps_alloc(ctx, sizeof(xps_hash_entry_t) * new_size);
     if (!new_entries)
-        return gs_throw(-1, "out of memory: hash table entries array");
+        return gs_throw(gs_error_VMerror, "out of memory: hash table entries array");
 
     table->size = new_size;
     table->entries = new_entries;
diff --git a/xps/xpsimage.c b/xps/xpsimage.c
index 733e4f2e0..c68aebe8b 100644
--- a/xps/xpsimage.c
+++ b/xps/xpsimage.c
@@ -35,6 +35,10 @@ xps_isolate_alpha_channel_8(xps_context_t *ctx, xps_image_t *image)
     byte *sp, *dp, *ap;
 
     image->alpha = xps_alloc(ctx, image->width * image->height);
+    if (!image->alpha) {
+        gs_throw(gs_error_VMerror, "out of memory: image->alpha.\n");
+        return;
+    }
 
     for (y = 0; y < image->height; y++)
     {
@@ -62,6 +66,10 @@ xps_isolate_alpha_channel_16(xps_context_t *ctx, xps_image_t *image)
     unsigned short *sp, *dp, *ap;
 
     image->alpha = xps_alloc(ctx, image->width * image->height * 2);
+    if (!image->alpha) {
+        gs_throw(gs_error_VMerror, "out of memory: image->alpha.\n");
+        return;
+    }
 
     for (y = 0; y < image->height; y++)
     {
@@ -250,7 +258,7 @@ xps_paint_image_brush_imp(xps_context_t *ctx, xps_image_t *image, int alpha)
 
     penum = gs_image_enum_alloc(ctx->memory, "xps_parse_image_brush (gs_image_enum_alloc)");
     if (!penum)
-        return gs_throw(-1, "gs_enum_allocate failed");
+        return gs_throw(gs_error_VMerror, "gs_enum_allocate failed");
 
     if ((code = gs_image_init(penum, &gsimage, false, ctx->pgs)) < 0)
         return gs_throw(code, "gs_image_init failed");
diff --git a/xps/xpsjpeg.c b/xps/xpsjpeg.c
index d4e2030c0..29fc375c1 100644
--- a/xps/xpsjpeg.c
+++ b/xps/xpsjpeg.c
@@ -129,7 +129,7 @@ xps_decode_jpeg(xps_context_t *ctx, byte *rbuf, int rlen, xps_image_t *image)
     wlen = image->stride * image->height;
     wbuf = xps_alloc(ctx, wlen);
     if (!wbuf)
-        return gs_throw1(-1, "out of memory allocating samples: %d", wlen);
+        return gs_throw1(gs_error_VMerror, "out of memory allocating samples: %d", wlen);
 
     image->samples = wbuf;
 
diff --git a/xps/xpsjxr.c b/xps/xpsjxr.c
index 762d9c289..12cb1e16d 100644
--- a/xps/xpsjxr.c
+++ b/xps/xpsjxr.c
@@ -98,6 +98,10 @@ xps_decode_jpegxr_block(jxr_image_t image, int mx, int my, int *data)
         output->bits = 8;
         output->stride = output->width * output->comps;
         output->samples = xps_alloc(ctx, output->stride * output->height);
+        if (!output->samples) {
+            gs_throw(gs_error_VMerror, "out of memory: output->samples.\n");
+            return;
+        }
 
         switch (output->comps)
         {
@@ -142,6 +146,10 @@ xps_decode_jpegxr_alpha_block(jxr_image_t image, int mx, int my, int *data)
     if (!output->alpha)
     {
         output->alpha = xps_alloc(ctx, output->width * output->height);
+        if (!output->alpha) {
+            gs_throw(gs_error_VMerror, "out of memory: output->alpha.\n");
+            return;
+        }
     }
 
     depth = jxr_get_OUTPUT_BITDEPTH(image);
diff --git a/xps/xpspath.c b/xps/xpspath.c
index 90244dd8c..0cb22e272 100644
--- a/xps/xpspath.c
+++ b/xps/xpspath.c
@@ -262,6 +262,10 @@ xps_parse_abbreviated_geometry(xps_context_t *ctx, char *geom)
     int reset_smooth;
 
     args = xps_alloc(ctx, sizeof(char*) * (strlen(geom) + 1));
+    if (!args) {
+        gs_throw(gs_error_VMerror, "out of memory: args.\n");
+        return;
+    }
     pargs = args;
 
     //dmprintf1(ctx->memory, "new path (%.70s)\n", geom);
diff --git a/xps/xpspng.c b/xps/xpspng.c
index 632afed4a..f7a6f91d3 100644
--- a/xps/xpspng.c
+++ b/xps/xpspng.c
@@ -287,6 +287,9 @@ xps_decode_png(xps_context_t *ctx, byte *rbuf, int rlen, xps_image_t *image)
     image->stride = (image->width * image->comps * image->bits + 7) / 8;
 
     image->samples = xps_alloc(ctx, image->stride * image->height);
+    if (!image->samples) {
+        return gs_throw(gs_error_VMerror, "out of memory.\n");
+    }
 
     for (pass = 0; pass < npasses; pass++)
     {
diff --git a/xps/xpsresource.c b/xps/xpsresource.c
index fac53b617..5843bef9f 100644
--- a/xps/xpsresource.c
+++ b/xps/xpsresource.c
@@ -158,7 +158,7 @@ xps_parse_resource_dictionary(xps_context_t *ctx, xps_resource_t **dictp, char *
         {
             entry = xps_alloc(ctx, sizeof(xps_resource_t));
             if (!entry)
-                return gs_throw(-1, "cannot allocate resource entry");
+                return gs_throw(gs_error_VMerror, "cannot allocate resource entry");
             entry->name = key;
             entry->base_uri = NULL;
             entry->base_xml = NULL;
diff --git a/xps/xpstiff.c b/xps/xpstiff.c
index a2e18089f..28cd9f4c3 100644
--- a/xps/xpstiff.c
+++ b/xps/xpstiff.c
@@ -570,7 +570,7 @@ xps_expand_colormap(xps_context_t *ctx, xps_tiff_t *tiff, xps_image_t *image)
 
     samples = xps_alloc(ctx, stride * image->height);
     if (!samples)
-        return gs_throw(-1, "out of memory: samples");
+        return gs_throw(gs_error_VMerror, "out of memory: samples");
 
     for (y = 0; y < image->height; y++)
     {
@@ -687,7 +687,7 @@ xps_decode_tiff_strips(xps_context_t *ctx, xps_tiff_t *tiff, xps_image_t *image)
 
     image->samples = xps_alloc(ctx, image->stride * image->height);
     if (!image->samples)
-        return gs_throw(-1, "could not allocate image samples");
+        return gs_throw(gs_error_VMerror, "could not allocate image samples");
 
     memset(image->samples, 0x55, image->stride * image->height);
 
@@ -935,7 +935,7 @@ xps_read_tiff_tag(xps_context_t *ctx, xps_tiff_t *tiff, unsigned offset)
     case ICCProfile:
         tiff->profile = xps_alloc(ctx, count);
         if (!tiff->profile)
-            return gs_throw(-1, "could not allocate embedded icc profile");
+            return gs_throw(gs_error_VMerror, "could not allocate embedded icc profile");
         /* ICC profile data type is set to UNDEFINED.
          * TBYTE reading not correct in xps_read_tiff_tag_value */
         xps_read_tiff_bytes(tiff->profile, tiff, value, count);
@@ -950,21 +950,21 @@ xps_read_tiff_tag(xps_context_t *ctx, xps_tiff_t *tiff, unsigned offset)
     case StripOffsets:
         tiff->stripoffsets = (unsigned*) xps_alloc(ctx, count * sizeof(unsigned));
         if (!tiff->stripoffsets)
-            return gs_throw(-1, "could not allocate strip offsets");
+            return gs_throw(gs_error_VMerror, "could not allocate strip offsets");
         xps_read_tiff_tag_value(tiff->stripoffsets, tiff, type, value, count);
         break;
 
     case StripByteCounts:
         tiff->stripbytecounts = (unsigned*) xps_alloc(ctx, count * sizeof(unsigned));
         if (!tiff->stripbytecounts)
-            return gs_throw(-1, "could not allocate strip byte counts");
+            return gs_throw(gs_error_VMerror, "could not allocate strip byte counts");
         xps_read_tiff_tag_value(tiff->stripbytecounts, tiff, type, value, count);
         break;
 
     case ColorMap:
         tiff->colormap = (unsigned*) xps_alloc(ctx, count * sizeof(unsigned));
         if (!tiff->colormap)
-            return gs_throw(-1, "could not allocate color map");
+            return gs_throw(gs_error_VMerror, "could not allocate color map");
         xps_read_tiff_tag_value(tiff->colormap, tiff, type, value, count);
         break;
 
diff --git a/xps/xpsxml.c b/xps/xpsxml.c
index 02c3458ef..4f0add949 100644
--- a/xps/xpsxml.c
+++ b/xps/xpsxml.c
@@ -110,9 +110,10 @@ on_open_tag(void *zp, char *ns_name, char **atts)
     }
 
     item = xps_alloc(ctx, sizeof(xps_item_t) + attslen + namelen + textlen);
-    if (!item)
-    {
+    if (!item) {
         parser->error = "out of memory";
+        gs_throw(gs_error_VMerror, "out of memory.\n");
+        return;
     }
 
     /* copy strings to new memory */
@@ -198,6 +199,7 @@ on_text(void *zp, char *buf, int len)
             if (!tmp)
             {
                 parser->error = "out of memory";
+                gs_throw(gs_error_VMerror, "out of memory.\n");
                 return;
             }
 
@@ -249,12 +251,14 @@ xps_parse_xml(xps_context_t *ctx, byte *buf, int len)
     XML_SetCharacterDataHandler(xp, (XML_CharacterDataHandler)on_text);
 
     code = XML_Parse(xp, (char*)buf, len, 1);
-    if (code == 0)
+    if (code == 0 || parser.error != NULL)
     {
         if (parser.root)
             xps_free_item(ctx, parser.root);
+        if (XML_ErrorString(XML_GetErrorCode(xp)) != 0)
+            emprintf1(parser.ctx->memory, "XML_Error: %s\n", XML_ErrorString(XML_GetErrorCode(xp)));
         XML_ParserFree(xp);
-        gs_throw1(-1, "xml error: %s", XML_ErrorString(XML_GetErrorCode(xp)));
+        gs_throw1(-1, "parser error: %s", parser.error);
         return NULL;
     }
 
diff --git a/xps/xpszip.c b/xps/xpszip.c
index 7c8c5b352..64a695388 100644
--- a/xps/xpszip.c
+++ b/xps/xpszip.c
@@ -48,7 +48,11 @@ static inline int getlong(FILE *file)
 static void *
 xps_zip_alloc_items(xps_context_t *ctx, int items, int size)
 {
-    return xps_alloc(ctx, items * size);
+    void *item = xps_alloc(ctx, items * size);
+    if (!item) {
+        gs_throw(gs_error_VMerror, "out of memory: item.\n");
+        return NULL;
+    }
 }
 
 static void
@@ -126,6 +130,9 @@ xps_read_zip_entry(xps_context_t *ctx, xps_entry_t *ent, unsigned char *outbuf)
     else if (method == 8)
     {
         inbuf = xps_alloc(ctx, ent->csize);
+        if (!inbuf) {
+            return gs_throw(gs_error_VMerror, "out of memory.\n");
+        }
 
         fread(inbuf, 1, ent->csize, ctx->file);
 
@@ -196,7 +203,7 @@ xps_read_zip_dir(xps_context_t *ctx, int start_offset)
     ctx->zip_count = count;
     ctx->zip_table = xps_alloc(ctx, sizeof(xps_entry_t) * count);
     if (!ctx->zip_table)
-        return gs_throw(-1, "cannot allocate zip entry table");
+        return gs_throw(gs_error_VMerror, "cannot allocate zip entry table");
 
     memset(ctx->zip_table, 0, sizeof(xps_entry_t) * count);
 
@@ -227,7 +234,7 @@ xps_read_zip_dir(xps_context_t *ctx, int start_offset)
 
         ctx->zip_table[i].name = xps_alloc(ctx, namesize + 1);
         if (!ctx->zip_table[i].name)
-            return gs_throw(-1, "cannot allocate zip entry name");
+            return gs_throw(gs_error_VMerror, "cannot allocate zip entry name");
 
         fread(ctx->zip_table[i].name, 1, namesize, ctx->file);
         ctx->zip_table[i].name[namesize] = 0;