summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--base/gsdparam.c26
-rw-r--r--base/gslib.c12
-rw-r--r--base/gsparam.c146
-rw-r--r--base/gsparam.h23
-rw-r--r--base/gsparam2.c4
-rw-r--r--base/gsparams.c4
-rw-r--r--base/gxdevcli.h10
-rw-r--r--base/gxpcache.h4
-rw-r--r--base/gxpcmap.c24
-rw-r--r--base/gxpcolor.h6
-rw-r--r--base/spprint.c70
-rw-r--r--base/spprint.h12
-rw-r--r--base/spsdf.c8
-rw-r--r--devices/vector/gdevpsdp.c2
-rw-r--r--pcl/pl/plmain.c12
-rw-r--r--psi/imainarg.c7
-rw-r--r--psi/iparam.c13
17 files changed, 313 insertions, 70 deletions
diff --git a/base/gsdparam.c b/base/gsdparam.c
index 70a2305b0..55093d820 100644
--- a/base/gsdparam.c
+++ b/base/gsdparam.c
@@ -216,16 +216,16 @@ int gx_default_get_param(gx_device *dev, char *Param, void *list)
return param_write_bool(plist, ".LockSafetyParams", &dev->LockSafetyParams);
}
if (strcmp(Param, "MaxPatternBitmap") == 0) {
- return param_write_int(plist, "MaxPatternBitmap", &dev->MaxPatternBitmap);
+ return param_write_size_t(plist, "MaxPatternBitmap", &dev->MaxPatternBitmap);
}
if (strcmp(Param, "PageUsesTransparency") == 0) {
return param_write_bool(plist, "PageUsesTransparency", &dev->page_uses_transparency);
}
if (strcmp(Param, "MaxBitmap") == 0) {
- return param_write_long(plist, "MaxBitmap", &(dev->space_params.MaxBitmap));
+ return param_write_size_t(plist, "MaxBitmap", &(dev->space_params.MaxBitmap));
}
if (strcmp(Param, "BandBufferSpace") == 0) {
- return param_write_long(plist, "BandBufferSpace", &dev->space_params.band.BandBufferSpace);
+ return param_write_size_t(plist, "BandBufferSpace", &dev->space_params.band.BandBufferSpace);
}
if (strcmp(Param, "BandHeight") == 0) {
return param_write_int(plist, "BandHeight", &dev->space_params.band.BandHeight);
@@ -234,7 +234,7 @@ int gx_default_get_param(gx_device *dev, char *Param, void *list)
return param_write_int(plist, "BandWidth", &dev->space_params.band.BandWidth);
}
if (strcmp(Param, "BufferSpace") == 0) {
- return param_write_long(plist, "BufferSpace", &dev->space_params.BufferSpace);
+ return param_write_size_t(plist, "BufferSpace", &dev->space_params.BufferSpace);
}
if (strcmp(Param, "InterpolateControl") == 0) {
int interpolate_control = dev->interpolate_control;
@@ -719,13 +719,13 @@ gx_default_get_params(gx_device * dev, gs_param_list * plist)
(code = param_write_bool(plist, "AntidropoutDownscaler",
&dev->color_info.use_antidropout_downscaler)) < 0 ||
(code = param_write_bool(plist, ".LockSafetyParams", &dev->LockSafetyParams)) < 0 ||
- (code = param_write_int(plist, "MaxPatternBitmap", &dev->MaxPatternBitmap)) < 0 ||
+ (code = param_write_size_t(plist, "MaxPatternBitmap", &dev->MaxPatternBitmap)) < 0 ||
(code = param_write_bool(plist, "PageUsesTransparency", &dev->page_uses_transparency)) < 0 ||
- (code = param_write_long(plist, "MaxBitmap", &(dev->space_params.MaxBitmap))) < 0 ||
- (code = param_write_long(plist, "BandBufferSpace", &dev->space_params.band.BandBufferSpace)) < 0 ||
+ (code = param_write_size_t(plist, "MaxBitmap", &(dev->space_params.MaxBitmap))) < 0 ||
+ (code = param_write_size_t(plist, "BandBufferSpace", &dev->space_params.band.BandBufferSpace)) < 0 ||
(code = param_write_int(plist, "BandHeight", &dev->space_params.band.BandHeight)) < 0 ||
(code = param_write_int(plist, "BandWidth", &dev->space_params.band.BandWidth)) < 0 ||
- (code = param_write_long(plist, "BufferSpace", &dev->space_params.BufferSpace)) < 0 ||
+ (code = param_write_size_t(plist, "BufferSpace", &dev->space_params.BufferSpace)) < 0 ||
(code = param_write_int(plist, "InterpolateControl", &dev->interpolate_control)) < 0
)
return code;
@@ -1406,7 +1406,7 @@ gx_default_put_params(gx_device * dev, gs_param_list * plist)
long ColorValues = (depth >= 32 ? -1 : 1L << depth);
int tab = dev->color_info.anti_alias.text_bits;
int gab = dev->color_info.anti_alias.graphics_bits;
- int mpbm = dev->MaxPatternBitmap;
+ size_t mpbm = dev->MaxPatternBitmap;
int ic = dev->interpolate_control;
bool page_uses_transparency = dev->page_uses_transparency;
gdev_space_params sp = dev->space_params;
@@ -1770,7 +1770,7 @@ nce:
ecode = code;
if ((code = param_read_bool(plist, "AntidropoutDownscaler", &use_antidropout)) < 0)
ecode = code;
- if ((code = param_read_int(plist, "MaxPatternBitmap", &mpbm)) < 0)
+ if ((code = param_read_size_t(plist, "MaxPatternBitmap", &mpbm)) < 0)
ecode = code;
if ((code = param_read_int(plist, "InterpolateControl", &ic)) < 0)
ecode = code;
@@ -1779,7 +1779,7 @@ nce:
ecode = code;
param_signal_error(plist, param_name, ecode);
}
- if ((code = param_read_long(plist, "MaxBitmap", &sp.MaxBitmap)) < 0)
+ if ((code = param_read_size_t(plist, "MaxBitmap", &sp.MaxBitmap)) < 0)
ecode = code;
#define CHECK_PARAM_CASES(member, bad, label)\
@@ -1796,7 +1796,7 @@ label:\
case 1:\
break
- switch (code = param_read_long(plist, (param_name = "BufferSpace"), &sp.BufferSpace)) {
+ switch (code = param_read_size_t(plist, (param_name = "BufferSpace"), &sp.BufferSpace)) {
CHECK_PARAM_CASES(BufferSpace, sp.BufferSpace < 10000, bse);
}
@@ -1808,7 +1808,7 @@ label:\
CHECK_PARAM_CASES(band.BandHeight, sp.band.BandHeight < 0, bhe);
}
- switch (code = param_read_long(plist, (param_name = "BandBufferSpace"), &sp.band.BandBufferSpace)) {
+ switch (code = param_read_size_t(plist, (param_name = "BandBufferSpace"), &sp.band.BandBufferSpace)) {
CHECK_PARAM_CASES(band.BandBufferSpace, sp.band.BandBufferSpace < 0, bbse);
}
diff --git a/base/gslib.c b/base/gslib.c
index 151da9a13..fff2433d8 100644
--- a/base/gslib.c
+++ b/base/gslib.c
@@ -930,7 +930,7 @@ test10(gs_gstate * pgs, gs_memory_t * mem)
gs_param_int_array HWSa;
int HWSize[2];
float HWResolution[2], PageSize[2];
- long MaxBitmap;
+ size_t MaxBitmap;
int code;
gx_device *dev = gs_currentdevice(pgs);
float xlate_x, xlate_y;
@@ -972,13 +972,13 @@ test10(gs_gstate * pgs, gs_memory_t * mem)
}
emprintf3(mem, "PageSize[%d] = [ %f, %f ]\n", PSa.size,
PSa.data[0], PSa.data[1]);
- code = param_read_long((gs_param_list *) & list,
- "MaxBitmap", &MaxBitmap);
+ code = param_read_size_t((gs_param_list *) & list,
+ "MaxBitmap", &MaxBitmap);
if (code < 0) {
lprintf1("reading MaxBitmap failed! code = %d\n", code);
gs_abort(mem);
}
- emprintf1(mem, "MaxBitmap = %ld\n", MaxBitmap);
+ emprintf1(mem, "MaxBitmap = %"PRIi64"\n", MaxBitmap);
/* Switch to param list functions to "write" */
gs_c_param_list_write(&list, mem);
/* Always set the PageSize. */
@@ -1015,8 +1015,8 @@ test10(gs_gstate * pgs, gs_memory_t * mem)
code = param_write_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
MaxBitmap = 1000000L;
- code = param_write_long((gs_param_list *) & list,
- "MaxBitmap", &MaxBitmap);
+ code = param_write_size_t((gs_param_list *) & list,
+ "MaxBitmap", &MaxBitmap);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *) & list);
diff --git a/base/gsparam.c b/base/gsparam.c
index 80cb0b2aa..fc3807c2a 100644
--- a/base/gsparam.c
+++ b/base/gsparam.c
@@ -178,6 +178,20 @@ param_coerce_typed(gs_param_typed_value * pvalue, gs_param_type req_type,
switch (pvalue->type /* actual type */ ) {
case gs_param_type_int:
switch (req_type) {
+ case gs_param_type_i64:
+ {
+ int64_t i64 = (int64_t)pvalue->value.i;
+ pvalue->value.i64 = i64;
+ goto ok;
+ }
+ case gs_param_type_size_t:
+ {
+ size_t z = (size_t)pvalue->value.i;
+ if (pvalue->value.i < 0)
+ return gs_error_rangecheck;
+ pvalue->value.z = z;
+ goto ok;
+ }
case gs_param_type_long:
{
long l = (long)pvalue->value.i;
@@ -196,14 +210,31 @@ param_coerce_typed(gs_param_typed_value * pvalue, gs_param_type req_type,
break;
case gs_param_type_long:
switch (req_type) {
+ case gs_param_type_i64:
+ {
+ int64_t i64 = (int64_t)pvalue->value.l;
+ pvalue->value.i64 = i64;
+ goto ok;
+ }
+ case gs_param_type_size_t:
+ {
+ size_t z = (size_t)pvalue->value.l;
+ if (pvalue->value.l < 0
+#if ARCH_SIZEOF_SIZE_T < ARCH_SIZEOF_LONG
+ || pvalue->value.l != (long)z
+#endif
+ )
+ return_error(gs_error_rangecheck);
+ pvalue->value.z = z;
+ goto ok;
+ }
case gs_param_type_int:
{
- int int1;
+ int int1 = (int)pvalue->value.l;
#if ARCH_SIZEOF_INT < ARCH_SIZEOF_LONG
- if (pvalue->value.l != (int)pvalue->value.l)
+ if (pvalue->value.l != (long)int1)
return_error(gs_error_rangecheck);
#endif
- int1 = (int)pvalue->value.l;
pvalue->value.i = int1;
goto ok;
}
@@ -217,6 +248,95 @@ param_coerce_typed(gs_param_typed_value * pvalue, gs_param_type req_type,
break;
}
break;
+ case gs_param_type_i64:
+ switch (req_type) {
+ case gs_param_type_size_t:
+ {
+ size_t z = (size_t)pvalue->value.i64;
+ if (pvalue->value.i64 < 0
+#if ARCH_SIZEOF_SIZE_T < 8 /* sizeof(int64_t) */
+ || pvalue->value.i64 != (int64_t)z
+#endif
+ )
+ return_error(gs_error_rangecheck);
+ pvalue->value.z = z;
+ goto ok;
+ }
+ case gs_param_type_long:
+ {
+ long l = (long)pvalue->value.i64;
+#if ARCH_SIZEOF_LONG < 8 /* sizeof(int64_t) */
+ if (pvalue->value.i64 != (int64_t)l)
+ return_error(gs_error_rangecheck);
+#endif
+ pvalue->value.l = l;
+ goto ok;
+ }
+ case gs_param_type_int:
+ {
+ int int1 = (int)pvalue->value.l;
+#if ARCH_SIZEOF_INT < 8 /* sizeof(int64_t) */
+ if (pvalue->value.i64 != (int)int1)
+ return_error(gs_error_rangecheck);
+#endif
+ pvalue->value.i = int1;
+ goto ok;
+ }
+ case gs_param_type_float:
+ {
+ float fl = (float)pvalue->value.i64;
+ pvalue->value.f = fl;
+ goto ok;
+ }
+ default:
+ break;
+ }
+ break;
+ case gs_param_type_size_t:
+ switch (req_type) {
+ case gs_param_type_i64:
+ {
+ int64_t i64 = (int64_t)pvalue->value.z;
+ if (i64 < 0
+#if 8 /* sizeof(int64_t) */ < ARCH_SIZEOF_SIZE_T
+ /* Unlikely, but let's plan for the day when we need 128bit addressing :) */
+ || pvalue->value.z != (size_t)i64
+#endif
+ )
+ return_error(gs_error_rangecheck);
+ pvalue->value.i64 = i64;
+ goto ok;
+ }
+ case gs_param_type_long:
+ {
+ long l = (long)pvalue->value.i64;
+#if ARCH_SIZEOF_LONG < 8 /* sizeof(int64_t) */
+ if (pvalue->value.i64 != (int64_t)l)
+ return_error(gs_error_rangecheck);
+#endif
+ pvalue->value.l = l;
+ goto ok;
+ }
+ case gs_param_type_int:
+ {
+ int int1 = (int)pvalue->value.l;
+#if ARCH_SIZEOF_INT < 8 /* sizeof(int64_t) */
+ if (pvalue->value.i64 != (int)int1)
+ return_error(gs_error_rangecheck);
+#endif
+ pvalue->value.i = int1;
+ goto ok;
+ }
+ case gs_param_type_float:
+ {
+ float fl = (float)pvalue->value.i64;
+ pvalue->value.f = fl;
+ goto ok;
+ }
+ default:
+ break;
+ }
+ break;
case gs_param_type_string:
if (req_type == gs_param_type_name)
goto ok;
@@ -321,6 +441,16 @@ param_read_long(gs_param_list * plist, gs_param_name pkey, long *pvalue)
RETURN_READ_TYPED(l, gs_param_type_long);
}
int
+param_read_i64(gs_param_list * plist, gs_param_name pkey, int64_t *pvalue)
+{
+ RETURN_READ_TYPED(i64, gs_param_type_i64);
+}
+int
+param_read_size_t(gs_param_list * plist, gs_param_name pkey, size_t *pvalue)
+{
+ RETURN_READ_TYPED(z, gs_param_type_size_t);
+}
+int
param_read_float(gs_param_list * plist, gs_param_name pkey, float *pvalue)
{
RETURN_READ_TYPED(f, gs_param_type_float);
@@ -397,6 +527,16 @@ param_write_long(gs_param_list * plist, gs_param_name pkey, const long *pvalue)
RETURN_WRITE_TYPED(l, gs_param_type_long);
}
int
+param_write_i64(gs_param_list * plist, gs_param_name pkey, const int64_t *pvalue)
+{
+ RETURN_WRITE_TYPED(i64, gs_param_type_i64);
+}
+int
+param_write_size_t(gs_param_list * plist, gs_param_name pkey, const size_t *pvalue)
+{
+ RETURN_WRITE_TYPED(z, gs_param_type_size_t);
+}
+int
param_write_float(gs_param_list * plist, gs_param_name pkey,
const float *pvalue)
{
diff --git a/base/gsparam.h b/base/gsparam.h
index 0f474c266..5d85e74e9 100644
--- a/base/gsparam.h
+++ b/base/gsparam.h
@@ -20,6 +20,7 @@
# define gsparam_INCLUDED
#include "gsstype.h"
+#include "stdint_.h"
/*
* Several interfaces use parameter dictionaries to communicate sets of
@@ -47,7 +48,7 @@ typedef const char *gs_param_name;
typedef enum {
/* Scalar */
gs_param_type_null, gs_param_type_bool, gs_param_type_int,
- gs_param_type_long, gs_param_type_float,
+ gs_param_type_long, gs_param_type_size_t, gs_param_type_i64, gs_param_type_float,
/* Homogenous collection */
gs_param_type_string, gs_param_type_name,
gs_param_type_int_array, gs_param_type_float_array,
@@ -98,8 +99,8 @@ typedef gs_param_collection gs_param_array;
* Define the sizes of the various parameter value types, indexed by type.
*/
#define GS_PARAM_TYPE_SIZES(dict_size)\
- 0, sizeof(bool), sizeof(int), sizeof(long), sizeof(float),\
- sizeof(gs_param_string), sizeof(gs_param_string),\
+ 0, sizeof(bool), sizeof(int), sizeof(long), sizeof(size_t), sizeof(int64_t),\
+ sizeof(float), sizeof(gs_param_string), sizeof(gs_param_string),\
sizeof(gs_param_int_array), sizeof(gs_param_float_array),\
sizeof(gs_param_string_array), sizeof(gs_param_string_array),\
(dict_size), (dict_size), (dict_size)
@@ -108,8 +109,8 @@ typedef gs_param_collection gs_param_array;
* to by the various value types.
*/
#define GS_PARAM_TYPE_BASE_SIZES(dict_elt_size)\
- 0, sizeof(bool), sizeof(int), sizeof(long), sizeof(float),\
- 1, 1, sizeof(int), sizeof(float),\
+ 0, sizeof(bool), sizeof(int), sizeof(long), sizeof(size_t), sizeof(int64_t),\
+ sizeof(float), 1, 1, sizeof(int), sizeof(float),\
sizeof(gs_param_string), sizeof(gs_param_string),\
(dict_elt_size), (dict_elt_size), (dict_elt_size)
@@ -122,6 +123,8 @@ extern const byte gs_param_type_base_sizes[];
bool b;\
int i;\
long l;\
+ size_t z;\
+ int64_t i64;\
float f;\
gs_param_string s;\
gs_param_string n;\
@@ -190,10 +193,8 @@ typedef enum {
* union means 'beginning of enumeration'.
*/
typedef union gs_param_enumerator_s {
- int intval;
- long longval;
- void *pvoid;
- char *pchar;
+ int intval; /* Used by the ref stack param list to index a stack */
+ void *pvoid; /* Used by the C param list to walk a linked list */
} gs_param_enumerator_t;
typedef gs_param_string gs_param_key_t;
@@ -402,6 +403,10 @@ int param_read_int(gs_param_list *, gs_param_name, int *);
int param_write_int(gs_param_list *, gs_param_name, const int *);
int param_read_long(gs_param_list *, gs_param_name, long *);
int param_write_long(gs_param_list *, gs_param_name, const long *);
+int param_read_i64(gs_param_list *, gs_param_name, int64_t *);
+int param_write_i64(gs_param_list *, gs_param_name, const int64_t *);
+int param_read_size_t(gs_param_list *, gs_param_name, size_t *);
+int param_write_size_t(gs_param_list *, gs_param_name, const size_t *);
int param_read_float(gs_param_list *, gs_param_name, float *);
int param_write_float(gs_param_list *, gs_param_name, const float *);
int param_read_string(gs_param_list *, gs_param_name, gs_param_string *);
diff --git a/base/gsparam2.c b/base/gsparam2.c
index 05202c779..d4cb61c97 100644
--- a/base/gsparam2.c
+++ b/base/gsparam2.c
@@ -100,6 +100,8 @@ gs_param_list_puts(stream *dest, gs_param_list *list)
case gs_param_type_bool:
case gs_param_type_int:
case gs_param_type_long:
+ case gs_param_type_size_t:
+ case gs_param_type_i64:
case gs_param_type_float:
sput_bytes(dest, (byte *)&value.value, value_top_sizeof);
case gs_param_type_null:
@@ -247,6 +249,8 @@ gs_param_list_gets(stream *src, gs_param_list *list, gs_memory_t *mem)
case gs_param_type_bool:
case gs_param_type_int:
case gs_param_type_long:
+ case gs_param_type_size_t:
+ case gs_param_type_i64:
case gs_param_type_float:
code = sget_bytes(src, (byte *)&typed.value, value_top_sizeof);
case gs_param_type_null:
diff --git a/base/gsparams.c b/base/gsparams.c
index 4e5adab37..447b4077d 100644
--- a/base/gsparams.c
+++ b/base/gsparams.c
@@ -141,6 +141,8 @@ gs_param_list_serialize(
case gs_param_type_bool:
case gs_param_type_int:
case gs_param_type_long:
+ case gs_param_type_size_t:
+ case gs_param_type_i64:
case gs_param_type_float:
wb_put_bytes((byte *) & value.value, value_top_sizeof, &write_buf);
break;
@@ -259,6 +261,8 @@ gs_param_list_unserialize(
case gs_param_type_bool:
case gs_param_type_int:
case gs_param_type_long:
+ case gs_param_type_size_t:
+ case gs_param_type_i64:
case gs_param_type_float:
break;
diff --git a/base/gxdevcli.h b/base/gxdevcli.h
index 30d0eda01..9b17bc9e3 100644
--- a/base/gxdevcli.h
+++ b/base/gxdevcli.h
@@ -680,8 +680,8 @@ typedef struct gx_device_cached_colors_s {
typedef struct gx_band_params_s {
int BandWidth; /* (optional) band width in pixels */
int BandHeight; /* (optional) */
- long BandBufferSpace; /* (optional) */
- long tile_cache_size; /* (optional) */
+ size_t BandBufferSpace; /* (optional) */
+ size_t tile_cache_size; /* (optional) */
} gx_band_params_t;
#define BAND_PARAMS_INITIAL_VALUES 0, 0, 0, 0
@@ -696,8 +696,8 @@ typedef enum {
the appropriate additions/changes to the compare_gdev_prn_space_params()
function in gdevprn.c */
typedef struct gdev_space_params_s {
- long MaxBitmap; /* max size of non-buffered bitmap */
- long BufferSpace; /* space to use for buffer */
+ size_t MaxBitmap; /* max size of non-buffered bitmap */
+ size_t BufferSpace; /* space to use for buffer */
gx_band_params_t band; /* see gxband.h */
bool params_are_read_only; /* true if put_params may not modify this struct */
gdev_banding_type banding_type; /* used to force banding or bitmap */
@@ -767,7 +767,7 @@ typedef struct gdev_pagelist_s {
long band_offset_y; /* for rendering that is phase sensitive (old wtsimdi) */\
bool BLS_force_memory;\
gx_stroked_gradient_recognizer_t sgr;\
- int MaxPatternBitmap; /* Threshold for switching to pattern_clist mode */\
+ size_t MaxPatternBitmap; /* Threshold for switching to pattern_clist mode */\
bool page_uses_transparency; /* PDF 1.4 transparency is used. */\
gdev_space_params space_params;\
cmm_dev_profile_t *icc_struct; /* object dependent profiles */\
diff --git a/base/gxpcache.h b/base/gxpcache.h
index e619e3ef0..f52cc5184 100644
--- a/base/gxpcache.h
+++ b/base/gxpcache.h
@@ -35,8 +35,8 @@ struct gx_pattern_cache_s {
uint num_tiles;
uint tiles_used;
uint next; /* round-robin index */
- ulong bits_used;
- ulong max_bits;
+ size_t bits_used;
+ size_t max_bits;
void (*free_all) (gx_pattern_cache *);
};
diff --git a/base/gxpcmap.c b/base/gxpcmap.c
index ebd1de22f..5c7547e4f 100644
--- a/base/gxpcmap.c
+++ b/base/gxpcmap.c
@@ -216,27 +216,25 @@ static dev_proc_destroy_buf_device(dummy_destroy_buf_device)
/* Attempt to determine the size of a pattern (the approximate amount that will */
/* be needed in the pattern cache). If we end up using the clist, this is only */
/* a guess -- we use the tile size which will _probably_ be too large. */
-static int
+static size_t
gx_pattern_size_estimate(gs_pattern1_instance_t *pinst, bool has_tags)
{
gx_device *tdev = pinst->saved->device;
int depth = (pinst->templat.PaintType == 2 ? 1 : tdev->color_info.depth);
- int64_t raster;
- int64_t size;
+ size_t raster;
+ size_t size;
if (pinst->size.x == 0 || pinst->size.y == 0)
return 0;
if (pinst->templat.uses_transparency) {
/* if the device has tags, add in an extra tag byte for the pdf14 compositor */
- raster = ((int64_t)pinst->size.x * ((depth/8) + 1 + (has_tags ? 1 : 0)));
+ raster = ((size_t)pinst->size.x * ((depth/8) + 1 + (has_tags ? 1 : 0)));
} else {
- raster = ((int64_t)pinst->size.x * depth + 7) / 8;
+ raster = ((size_t)pinst->size.x * depth + 7) / 8;
}
- size = raster > max_int / pinst->size.y ? (max_int & ~0xFFFF) : raster * pinst->size.y;
- if (size > (int64_t)max_int)
- size = (max_int & ~0xFFFF);
- return (int)size;
+ size = raster > max_size_t / pinst->size.y ? (max_size_t - 0xFFFF) : raster * pinst->size.y;
+ return size;
}
static void gx_pattern_accum_finalize_cw(gx_device * dev)
@@ -262,10 +260,10 @@ gx_pattern_accum_alloc(gs_memory_t * mem, gs_memory_t * storage_memory,
{
gx_device *tdev = pinst->saved->device;
bool has_tags = device_encodes_tags(tdev);
- int size = gx_pattern_size_estimate(pinst, has_tags);
+ size_t size = gx_pattern_size_estimate(pinst, has_tags);
gx_device_forward *fdev;
int force_no_clist = 0;
- int max_pattern_bitmap = tdev->MaxPatternBitmap == 0 ? MaxPatternBitmap_DEFAULT :
+ size_t max_pattern_bitmap = tdev->MaxPatternBitmap == 0 ? MaxPatternBitmap_DEFAULT :
tdev->MaxPatternBitmap;
pinst->is_planar = tdev->is_planar;
@@ -987,7 +985,7 @@ gx_pattern_cache_free_entry(gx_pattern_cache * pcache, gx_color_tile * ctile)
/* enough space is available (or nothing left to free). */
/* This will allow 1 oversized entry */
void
-gx_pattern_cache_ensure_space(gs_gstate * pgs, int needed)
+gx_pattern_cache_ensure_space(gs_gstate * pgs, size_t needed)
{
int code = ensure_pattern_cache(pgs);
gx_pattern_cache *pcache;
@@ -1015,7 +1013,7 @@ gx_pattern_cache_ensure_space(gs_gstate * pgs, int needed)
/* Export updating the pattern_cache bits_used and tiles_used for clist reading */
void
-gx_pattern_cache_update_used(gs_gstate *pgs, ulong used)
+gx_pattern_cache_update_used(gs_gstate *pgs, size_t used)
{
gx_pattern_cache *pcache = pgs->pattern_cache;
diff --git a/base/gxpcolor.h b/base/gxpcolor.h
index 38cd625bf..cf62904e7 100644
--- a/base/gxpcolor.h
+++ b/base/gxpcolor.h
@@ -294,12 +294,12 @@ bool gx_device_is_pattern_accum(gx_device *dev);
/* Given the size of a new pattern tile, free entries from the cache until */
/* enough space is available (or nothing left to free). */
/* This will allow 1 oversized entry */
-void gx_pattern_cache_ensure_space(gs_gstate * pgs, int needed);
+void gx_pattern_cache_ensure_space(gs_gstate * pgs, size_t needed);
-void gx_pattern_cache_update_used(gs_gstate *pgs, ulong used);
+void gx_pattern_cache_update_used(gs_gstate *pgs, size_t used);
/* Update cache tile space */
-void gx_pattern_cache_update_space(gs_gstate * pgs, int64_t used);
+void gx_pattern_cache_update_space(gs_gstate * pgs, size_t used);
/* Add an accumulated pattern to the cache. */
/* Note that this does not free any of the data in the accumulator */
diff --git a/base/spprint.c b/base/spprint.c
index cc12d3975..11f33ffb8 100644
--- a/base/spprint.c
+++ b/base/spprint.c
@@ -156,7 +156,7 @@ pprintg6(stream * s, const char *format, double v1, double v2, double v3,
/* Print a long value using a format. */
const char *
-pprintld1(stream * s, const char *format, long v)
+pprintld1(stream *s, const char *format, long v)
{
const char *fp = pprintf_scan(s, format);
char str[25];
@@ -170,16 +170,80 @@ pprintld1(stream * s, const char *format, long v)
return pprintf_scan(s, fp + 3);
}
const char *
-pprintld2(stream * s, const char *format, long v1, long v2)
+pprintld2(stream *s, const char *format, long v1, long v2)
{
return pprintld1(s, pprintld1(s, format, v1), v2);
}
const char *
-pprintld3(stream * s, const char *format, long v1, long v2, long v3)
+pprintld3(stream *s, const char *format, long v1, long v2, long v3)
{
return pprintld2(s, pprintld1(s, format, v1), v2, v3);
}
+/* Print a size_t value using a format. */
+const char *
+pprintzd1(stream *s, const char *format, size_t v)
+{
+ const char *fp = pprintf_scan(s, format);
+ char str[25];
+ const size_t z = strlen("%"PRIdSIZE);
+
+#ifdef DEBUG
+ size_t i;
+
+ for (i = 0; i < z; i++)
+ if (fp[i] != ("%"PRIdSIZE)[i])
+ break;
+ if (i != z)
+ lprintf1("Bad format in pprintzd: %s\n", format);
+#endif
+ gs_sprintf(str, "%"PRIdSIZE, v);
+ pputs_short(s, str);
+ return pprintf_scan(s, fp + z);
+}
+const char *
+pprintzd2(stream *s, const char *format, size_t v1, size_t v2)
+{
+ return pprintzd1(s, pprintzd1(s, format, v1), v2);
+}
+const char *
+pprintzd3(stream *s, const char *format, size_t v1, size_t v2, size_t v3)
+{
+ return pprintzd2(s, pprintzd1(s, format, v1), v2, v3);
+}
+
+/* Print an int64_t value using a format. */
+const char *
+pprinti64d1(stream *s, const char *format, int64_t v)
+{
+ const char *fp = pprintf_scan(s, format);
+ char str[25];
+ const size_t z = strlen("%"PRId64);
+
+#ifdef DEBUG
+ size_t i;
+
+ for (i = 0; i < z; i++)
+ if (fp[i] != ("%"PRId64)[i])
+ break;
+ if (i != z)
+ lprintf1("Bad format in pprinti64d: %s\n", format);
+#endif
+ gs_sprintf(str, "%"PRId64, v);
+ pputs_short(s, str);
+ return pprintf_scan(s, fp + z);
+}
+const char *
+pprinti64d2(stream *s, const char *format, int64_t v1, int64_t v2)
+{
+ return pprinti64d1(s, pprinti64d1(s, format, v1), v2);
+}
+const char *
+pprinti64d3(stream *s, const char *format, int64_t v1, int64_t v2, int64_t v3)
+{
+ return pprinti64d2(s, pprinti64d1(s, format, v1), v2, v3);
+}
+
/* Print (a) string(s) using a format. */
const char *
pprints1(stream * s, const char *format, const char *str)
diff --git a/base/spprint.h b/base/spprint.h
index 3e5f57a49..013ea0691 100644
--- a/base/spprint.h
+++ b/base/spprint.h
@@ -67,6 +67,18 @@ const char *pprintld2(stream * s, const char *format, long v1, long v2);
const char *pprintld3(stream * s, const char *format,
long v1, long v2, long v3);
+/* Print a size_t value using a format. */
+const char *pprintzd1(stream *s, const char *format, size_t v);
+const char *pprintzd2(stream *s, const char *format, size_t v1, size_t v2);
+const char *pprintzd3(stream *s, const char *format,
+ size_t v1, size_t v2, size_t v3);
+
+/* Print an int64_t value using a format. */
+const char *pprinti64d1(stream *s, const char *format, int64_t v);
+const char *pprinti64d2(stream *s, const char *format, int64_t v1, int64_t v2);
+const char *pprinti64d3(stream *s, const char *format,
+ int64_t v1, int64_t v2, int64_t v3);
+
/* Print (a) string(s) using a format. */
const char *pprints1(stream * s, const char *format, const char *str);
const char *pprints2(stream * s, const char *format,
diff --git a/base/spsdf.c b/base/spsdf.c
index 2f2a3f787..f8544f0f4 100644
--- a/base/spsdf.c
+++ b/base/spsdf.c
@@ -213,7 +213,13 @@ param_print_typed(gs_param_list * plist, gs_param_name pkey,
pprintd1(s, " %d", pvalue->value.i);
break;
case gs_param_type_long:
- pprintld1(s, " %l", pvalue->value.l);
+ pprintld1(s, " %ld", pvalue->value.l);
+ break;
+ case gs_param_type_size_t:
+ pprintzd1(s, " %"PRIdSIZE, pvalue->value.z);
+ break;
+ case gs_param_type_i64:
+ pprinti64d1(s, " %"PRId64, pvalue->value.i64);
break;
case gs_param_type_float:
pprintg1(s, " %g", pvalue->value.f);
diff --git a/devices/vector/gdevpsdp.c b/devices/vector/gdevpsdp.c
index bda3fe2ab..2b0da8934 100644
--- a/devices/vector/gdevpsdp.c
+++ b/devices/vector/gdevpsdp.c
@@ -232,7 +232,7 @@ static const gs_param_item_t psdf_param_items[] = {
/* (DefaultRenderingIntent) */
pi("DetectBlends", gs_param_type_bool, DetectBlends),
pi("DoThumbnails", gs_param_type_bool, DoThumbnails),
- pi("ImageMemory", gs_param_type_long, ImageMemory),
+ pi("ImageMemory", gs_param_type_size_t, ImageMemory),
/* (LockDistillerParams) */
pi("LZWEncodePages", gs_param_type_bool, LZWEncodePages),
pi("OPM", gs_param_type_int, OPM),
diff --git a/pcl/pl/plmain.c b/pcl/pl/plmain.c
index abc89a520..462a0df46 100644
--- a/pcl/pl/plmain.c
+++ b/pcl/pl/plmain.c
@@ -870,7 +870,7 @@ parse_floats(gs_memory_t * mem, uint arg_count, const char *arg, float *f)
#define argcmp(A, S, L) \
(!strncmp(A, S, L) && (A[L] == 0 || A[L] == '='))
-static int check_for_special_int(pl_main_instance_t * pmi, const char *arg, int b)
+static int check_for_special_int(pl_main_instance_t * pmi, const char *arg, int64_t b)
{
if (argcmp(arg, "BATCH", 5))
return (b == 1) ? 0 : gs_note_error(gs_error_rangecheck);
@@ -1030,7 +1030,7 @@ set_param(pl_main_instance_t * pmi, const char *arg)
/* We're setting a device parameter to a non-string value. */
const char *eqp = strchr(arg, '=');
const char *value;
- int vi;
+ int64_t vi;
float vf;
bool bval = true;
char buffer[128];
@@ -1070,7 +1070,7 @@ set_param(pl_main_instance_t * pmi, const char *arg)
spt_val = value+1;
} else if (strchr(value, '#')) {
/* We have a non-decimal 'radix' number */
- int base = 0;
+ int64_t base = 0;
const char *val = strchr(value, '#') + 1;
const char *v = value;
char c;
@@ -1110,12 +1110,12 @@ set_param(pl_main_instance_t * pmi, const char *arg)
if (code < 0) code = 0;
if (code <= 0)
return code;
- code = param_write_int((gs_param_list *) params,
+ code = param_write_i64((gs_param_list *) params,
buffer, &vi);
spt_type = pl_spt_int;
spt_val = &vi;
} else if ((!strchr(value, '.')) &&
- (sscanf(value, "%d", &vi) == 1)) {
+ (sscanf(value, "%"PRId64, &vi) == 1)) {
/* Here we have an int -- check for a scaling suffix */
char suffix = eqp[strlen(eqp) - 1];
@@ -1141,7 +1141,7 @@ set_param(pl_main_instance_t * pmi, const char *arg)
if (code < 0) code = 0;
if (code <= 0)
return code;
- code = param_write_int((gs_param_list *) params,
+ code = param_write_i64((gs_param_list *) params,
buffer, &vi);
spt_type = pl_spt_int;
spt_val = &vi;
diff --git a/psi/imainarg.c b/psi/imainarg.c
index c5d74caf0..6ff12df7b 100644
--- a/psi/imainarg.c
+++ b/psi/imainarg.c
@@ -829,14 +829,15 @@ run_stdin:
ialloc_set_space(idmemory, avm_system);
if (isd) {
- int num, i;
+ int i;
+ int64_t num;
/* Check for numbers so we can provide for suffix scalers */
/* Note the check for '#' is for PS "radix" numbers such as 16#ff */
/* and check for '.' and 'e' or 'E' which are 'real' numbers */
if ((strchr(eqp, '#') == NULL) && (strchr(eqp, '.') == NULL) &&
(strchr(eqp, 'e') == NULL) && (strchr(eqp, 'E') == NULL) &&
- ((i = sscanf((const char *)eqp, "%d", &num)) == 1)) {
+ ((i = sscanf((const char *)eqp, "%"PRIi64, &num)) == 1)) {
char suffix = eqp[strlen(eqp) - 1];
switch (suffix) {
@@ -857,7 +858,7 @@ run_stdin:
default:
break; /* not a valid suffix or last char was digit */
}
- make_int(&value, num);
+ make_int(&value, (ps_int)num);
} else {
/* use the PS scanner to capture other valid token types */
stream astream;
diff --git a/psi/iparam.c b/psi/iparam.c
index 3106f412e..6ae475125 100644
--- a/psi/iparam.c
+++ b/psi/iparam.c
@@ -222,8 +222,17 @@ ref_param_write_typed(gs_param_list * plist, gs_param_name pkey,
make_int(&value, pvalue->value.i);
break;
case gs_param_type_long:
+ /* FIXME: Rangecheck? */
make_int(&value, pvalue->value.l);
break;
+ case gs_param_type_size_t:
+ /* FIXME: Rangecheck? */
+ make_int(&value, pvalue->value.z);
+ break;
+ case gs_param_type_i64:
+ /* FIXME: Rangecheck? */
+ make_int(&value, pvalue->value.i64);
+ break;
case gs_param_type_float:
make_real(&value, pvalue->value.f);
break;
@@ -782,8 +791,8 @@ ref_param_read_typed(gs_param_list * plist, gs_param_name pkey,
}
return 0;
case t_integer:
- pvalue->type = gs_param_type_long;
- pvalue->value.l = loc.pvalue->value.intval;
+ pvalue->type = gs_param_type_i64;
+ pvalue->value.i64 = loc.pvalue->value.intval;
return 0;
case t_name:
pvalue->type = gs_param_type_name;
View Lorry Controller Status