PJL Parser - change a number of static tables to dynamic allocations

In order to provide for storage in excess of 256 bytes for a given PJL
variable, we either need to increase the size of the fixed strings stored
in a number of tales, or change the string storage to be dynamic.

Obviously its more memory efficient (at the cost of some performance) to
allocate the strings to the required size rather than wasting memory.

This commit alters the PJL 'environment' as well as its defaults and
associated factory defaults table, and the similar fontsource and its
defaults and associated factory defaults tables so that we only allocate
memory as required.

1 files changed, 348 insertions, 62 deletions

diff --git a/pcl/pl/pjparse.c b/pcl/pl/pjparse.c
index add19c1e8..496b25c8b 100644
--- a/pcl/pl/pjparse.c
+++ b/pcl/pl/pjparse.c
@@ -40,15 +40,14 @@
 typedef struct pjl_fontsource
 {
     char designator[2];
-    char pathname[PJL_PATH_NAME_LENGTH + 1];
-    char fontnumber[PJL_STRING_LENGTH + 1];
+    char *pathname;
+    char *fontnumber;
 } pjl_fontsource_t;
 
 /* definitions for variable names and values */
-typedef struct pjl_envir_var_s
-{
-    char var[PJL_STRING_LENGTH + 1];
-    char value[PJL_STRING_LENGTH + 1];
+typedef struct pjl_envir_var_s {
+  char *var;
+  char *value;
 } pjl_envir_var_t;
 
 /* the pjl current environment and the default user environment.  Note
@@ -282,10 +281,10 @@ pjl_side_effects(pjl_parser_state_t * pst, char *variable, char *value,
                            (int)(pjl_media[indx].width) :
                            (int)(pjl_media[indx].height));
         int formlines = pjl_calc_formlines_new_page_size(page_length);
-        pjl_envir_var_t var;
+        char value[32];
 
-        gs_sprintf(var.value, "%d", formlines);
-        pjl_set(pst, (char *)"FORMLINES", var.value, defaults);
+        gs_sprintf(value, "%d", formlines);
+        pjl_set(pst, (char *)"FORMLINES", value, defaults);
     }
     /* fill in other side effects here */
     return;
@@ -296,19 +295,26 @@ static int
 pjl_set(pjl_parser_state_t * pst, char *variable, char *value, bool defaults)
 {
     pjl_envir_var_t *table = (defaults ? pst->defaults : pst->envir);
-    int i;
+    int i=0;
 
     if (defaults)               /* default also sets current environment. */
         pjl_set(pst, variable, value, false);
 
-    for (i = 0; table[i].var[0]; i++)
+    while (table[i].var) {
         if (!pjl_compare(table[i].var, variable)) {
             /* set the value */
-            strcpy(table[i].value, value);
+            char *newvalue = (char *)gs_alloc_bytes(pst->mem, strlen(value) + 1, "pjl_set, create new value");
+            if (!newvalue)
+                return 0;
+            strcpy(newvalue, value);
+            gs_free_object(pst->mem, table[i].value, "pjl_set free old value");
+            table[i].value = newvalue;
             /* set any side effects of setting the value */
             pjl_side_effects(pst, variable, value, defaults);
             return 1;
         }
+        i++;
+    }
     /* didn't find variable */
     return 0;
 }
@@ -375,9 +381,12 @@ pjl_get_token(pjl_parser_state_t * pst, char token[])
 
         /* NB add other cases here */
         /* check for variables that we support */
-        for (i = 0; pst->envir[i].var[0]; i++)
+        i = 0;
+        while (pst->envir[i].var) {
             if (!pjl_compare(pst->envir[i].var, token))
                 return VARIABLE;
+            i++;
+        }
 
         /* NB assume this is a setting yuck */
         return SETTING;
@@ -447,15 +456,28 @@ pjl_check_font_path(char *path_list, gs_memory_t * mem)
 static void
 pjl_reset_fontsource_fontnumbers(pjl_parser_state_t * pst)
 {
-    char default_font_number[] = "0";   /* default number if resources are present */
+    char default_font_number[] = {0x30, 0x00};   /* default number if resources are present */
     gs_memory_t *mem = pst->mem;
     int i;
+    char *newvalue;
 
     for (i = 0; pst->font_defaults[i].designator[0]; i++) {
-        if (pjl_check_font_path(pst->font_defaults[i].pathname, mem))
-            strcpy(pst->font_defaults[i].fontnumber, default_font_number);
-        if (pjl_check_font_path(pst->font_envir[i].pathname, mem))
-            strcpy(pst->font_envir[i].fontnumber, default_font_number);
+        if (pjl_check_font_path(pst->font_defaults[i].pathname, mem)) {
+            newvalue = (char *)gs_alloc_bytes(mem, strlen(default_font_number) + 1, "pjl_reset_fontsource_fontnumbers, create new value");
+            if (newvalue) {
+                gs_free_object(mem, pst->font_defaults[i].fontnumber, "pjl_reset_fontsource_fontnumbers");
+                strcpy(newvalue, default_font_number);
+                pst->font_defaults[i].fontnumber = newvalue;
+            }
+        }
+        if (pjl_check_font_path(pst->font_envir[i].pathname, mem)) {
+            newvalue = (char *)gs_alloc_bytes(mem, strlen(default_font_number) + 1, "pjl_reset_fontsource_fontnumbers, create new value");
+            if (newvalue) {
+                gs_free_object(mem, pst->font_envir[i].fontnumber, "pjl_reset_fontsource_fontnumbers");
+                strcpy(newvalue, default_font_number);
+                pst->font_envir[i].fontnumber = newvalue;
+            }
+        }
     }
 }
 
@@ -808,18 +830,18 @@ pjl_parse_and_process_line(pjl_parser_state_t * pst)
                 }
             case INITIALIZE:
                 /* set the user default environment to the factory default environment */
-                memcpy(pst->defaults, &pjl_factory_defaults,
-                       sizeof(pjl_factory_defaults));
-                memcpy(pst->font_defaults, &pjl_fontsource_table,
-                       sizeof(pjl_fontsource_table));
+                free_pjl_defaults(pst->mem, &pst->defaults);
+                set_pjl_defaults_to_factory(pst->mem, &pst->defaults);
+                free_pjl_default_fontsource(pst->mem, &pst->font_defaults);
+                set_pjl_default_fontsource_to_factory(pst->mem, &pst->font_defaults);
                 pjl_reset_fontsource_fontnumbers(pst);
                 return 0;
                 /* set the current environment to the user default environment */
             case RESET:
-                memcpy(pst->envir, pst->defaults,
-                       sizeof(pjl_factory_defaults));
-                memcpy(pst->font_envir, pst->font_defaults,
-                       sizeof(pjl_fontsource_table));
+                free_pjl_defaults(pst->mem, &pst->defaults);
+                set_pjl_environment_to_factory(pst->mem, &pst->defaults);
+                free_pjl_fontsource(pst->mem, pst->font_envir);
+                set_pjl_fontsource_to_factory(pst->mem, &pst->font_envir);
                 return 0;
             case ENTER:
                 /* there is no setting for the default language */
@@ -978,8 +1000,11 @@ pjl_get_named_resource(pjl_parser_state * pst, char *name, byte * data)
 void
 pjl_set_init_from_defaults(pjl_parser_state_t * pst)
 {
-    memcpy(pst->envir, pst->defaults, sizeof(pjl_factory_defaults));
-    memcpy(pst->font_envir, pst->font_defaults, sizeof(pjl_fontsource_table));
+    free_pjl_environment(pst->mem, &pst->envir);
+    set_pjl_environment(pst->mem, &pst->envir, pst->defaults);
+
+    free_pjl_fontsource(pst->mem, &pst->font_envir);
+    set_pjl_fontsource(pst->mem, &pst->font_envir, pst->font_defaults);
 }
 
 void
@@ -1019,14 +1044,16 @@ pjl_set_next_fontsource(pjl_parser_state_t * pst)
 pjl_envvar_t *
 pjl_get_envvar(pjl_parser_state * pst, const char *pjl_var)
 {
-    int i;
+    int i=0;
     pjl_envir_var_t *env = pst->envir;
 
     /* lookup up the value */
-    for (i = 0; env[i].var[0]; i++)
+    while(env[i].var) {
         if (!pjl_compare(env[i].var, pjl_var)) {
             return env[i].value;
         }
+        i++;
+    }
     return NULL;
 }
 
@@ -1226,32 +1253,272 @@ pjl_fontsource_to_path(const pjl_parser_state * pjls,
     return NULL;
 }
 
+int set_pjl_defaults_to_factory(gs_memory_t * mem, pjl_envir_var_t **def)
+{
+    return set_pjl_defaults(mem, def, &pjl_factory_defaults);
+}
+
+int set_pjl_defaults(gs_memory_t * mem, pjl_envir_var_t **def, pjl_envir_var_t *from)
+{
+    pjl_envir_var_t *pjl_def;
+    char *key, *value, *newkey, *newvalue;
+    int i = 0;
+
+    while (from[i].var && from[i].var[0] != 0x00)
+        i++;
+
+    pjl_def = (pjl_envir_var_t *) gs_alloc_bytes(mem,
+                                                  sizeof
+                                                  (pjl_envir_var_t) * (i + 1),
+                                                  "pjl_envir");
+    if (!pjl_def)
+        return -1;
+
+    memset(pjl_def, 0x00, sizeof(pjl_envir_var_t) * (i + 1));
+    i--;
+    while (i >= 0) {
+        key = from[i].var;
+        value = from[i].value;
+
+        newkey = (char *)gs_alloc_bytes(mem, strlen(key) + 1, "new_pjl_defaults, key");
+        newvalue = (char *)gs_alloc_bytes(mem, strlen(value) + 1, "new_pjl_defaults, value");
+        if (!newkey || !newvalue) {
+            free_pjl_defaults(mem, &pjl_def);
+            return -1;
+        }
+        strcpy(newkey, key);
+        strcpy(newvalue, value);
+        pjl_def[i].var = newkey;
+        pjl_def[i].value = newvalue;
+
+        i--;
+    }
+    *def = pjl_def;
+    return 0;
+}
+
+int set_pjl_environment_to_factory(gs_memory_t * mem, pjl_envir_var_t **env)
+{
+    return set_pjl_environment(mem, env, &pjl_factory_defaults);
+}
+
+int set_pjl_environment(gs_memory_t * mem, pjl_envir_var_t **env, pjl_envir_var_t *from)
+{
+    pjl_envir_var_t *pjl_env;
+    char *key, *value, *newkey, *newvalue;
+    int i = 0;
+
+    while (from[i].var && from[i].var[0] != 0x00)
+        i++;
+
+    pjl_env = (pjl_envir_var_t *) gs_alloc_bytes(mem,
+                                                  sizeof
+                                                  (pjl_envir_var_t) * (i + 1),
+                                                  "pjl_envir");
+    if (!pjl_env)
+        return -1;
+
+    memset(pjl_env, 0x00, sizeof(pjl_envir_var_t) * (i + 1));
+    i--;
+    while (i >= 0) {
+        key = from[i].var;
+        value = from[i].value;
+        newkey = (char *)gs_alloc_bytes(mem, strlen(key) + 1, "pjl_envir, key");
+        newvalue = (char *)gs_alloc_bytes(mem, strlen(value) + 1, "pjl_envir, value");
+        if (!newkey || !newvalue) {
+            free_pjl_environment(mem, &pjl_env);
+            return -1;
+        }
+        strcpy(newkey, key);
+        strcpy(newvalue, value);
+        pjl_env[i].var = newkey;
+        pjl_env[i].value = newvalue;
+
+        i--;
+    }
+    *env = pjl_env;
+    return 0;
+}
+
+int set_pjl_fontsource_to_factory(gs_memory_t * mem, pjl_fontsource_t **fontenv)
+{
+    return set_pjl_fontsource(mem, fontenv, &pjl_fontsource_table);
+}
+
+int set_pjl_fontsource(gs_memory_t * mem, pjl_fontsource_t **fontenv, pjl_fontsource_t *from)
+{
+    pjl_fontsource_t *pjl_fontenv;
+    char *key, *value, *newkey, *newvalue;
+    int i = 0;
+
+    while (from[i].pathname && from[i].pathname[0] != 0x00)
+        i++;
+
+    pjl_fontenv = (pjl_fontsource_t *) gs_alloc_bytes(mem,
+                                                      sizeof
+                                                      (pjl_fontsource_t) * (i + 1),
+                                                      "font_envir");
+    if (!pjl_fontenv)
+        return -1;
+
+    memset(pjl_fontenv, 0x00, sizeof(pjl_fontsource_t) * (i + 1));
+    i--;
+    while (i >= 0) {
+        key = from[i].pathname;
+        value = from[i].fontnumber;
+
+        newkey = (char *)gs_alloc_bytes(mem, strlen(key) + 1, "new_font_envir, pathname");
+        if (!newkey) {
+            free_pjl_fontsource(mem, &pjl_fontenv);
+            return -1;
+        }
+        strcpy(newkey, key);
+        pjl_fontenv[i].pathname = newkey;
+        if (value) {
+            newvalue = (char *)gs_alloc_bytes(mem, strlen(value) + 1, "new_font_envir, fontnumber");
+            if (!newvalue) {
+                free_pjl_fontsource(mem, &pjl_fontenv);
+                return -1;
+            }
+            strcpy(newvalue, value);
+            pjl_fontenv[i].fontnumber = newvalue;
+        } else {
+            pjl_fontenv[i].fontnumber = 0x00;
+        }
+        memcpy(pjl_fontenv[i].designator, pjl_fontsource_table[i].designator, 2);
+
+        i--;
+    }
+    *fontenv = pjl_fontenv;
+    return 0;
+}
+
+int set_pjl_default_fontsource_to_factory(gs_memory_t * mem, pjl_fontsource_t **fontdef)
+{
+    return set_pjl_default_fontsource(mem, fontdef, &pjl_fontsource_table);
+}
+
+int set_pjl_default_fontsource(gs_memory_t * mem, pjl_fontsource_t **fontdef, pjl_fontsource_t *from)
+{
+    pjl_fontsource_t *pjl_fontdef;
+    char *key, *value, *newkey, *newvalue;
+    int i = 0;
+
+    while (from[i].pathname && from[i].pathname[0] != 0x00)
+        i++;
+
+    pjl_fontdef = (pjl_fontsource_t *) gs_alloc_bytes(mem,
+                                                      sizeof
+                                                      (pjl_fontsource_t) * (i + 1),
+                                                      "new_font_defaults");
+    if (!pjl_fontdef)
+        return -1;
+
+    memset(pjl_fontdef, 0x00, sizeof(pjl_fontsource_t) * (i + 1));
+    i--;
+    while (i >= 0) {
+        key = from[i].pathname;
+        value = from[i].fontnumber;
+
+        newkey = (char *)gs_alloc_bytes(mem, strlen(key) + 1, "new_font_defaults, pathname");
+        if (!newkey) {
+            free_pjl_default_fontsource(mem, &pjl_fontdef);
+            return -1;
+        }
+        strcpy(newkey, key);
+        pjl_fontdef[i].pathname = newkey;
+        if (value) {
+            newvalue = (char *)gs_alloc_bytes(mem, strlen(value) + 1, "new_font_defaults, fontnumber");
+            if (!newvalue) {
+                free_pjl_default_fontsource(mem, &pjl_fontdef);
+                return -1;
+            }
+            strcpy(newvalue, value);
+            pjl_fontdef[i].fontnumber = newvalue;
+        } else {
+            pjl_fontdef[i].fontnumber = 0x00;
+        }
+        memcpy(pjl_fontdef[i].designator, pjl_fontsource_table[i].designator, 2);
+
+        i--;
+    }
+    *fontdef = pjl_fontdef;
+    return 0;
+}
+
+int free_pjl_defaults(gs_memory_t * mem, pjl_envir_var_t **def)
+{
+    int i=0;
+    pjl_envir_var_t *pjl_def = *def;
+
+    while (pjl_def[i].var) {
+        gs_free_object(mem, pjl_def[i].var, "free pjl_defaults key");
+        gs_free_object(mem, pjl_def[i].value, "free pjl_defaults value");
+        i++;
+    }
+    gs_free_object(mem, pjl_def, "pjl_defaults");
+    *def = 0x00;
+    return 0;
+}
+
+int free_pjl_environment(gs_memory_t * mem, pjl_envir_var_t **env)
+{
+    int i=0;
+    pjl_envir_var_t *pjl_env = *env;
+
+    while (pjl_env[i].var) {
+        gs_free_object(mem, pjl_env[i].var, "free pjl_environment key");
+        gs_free_object(mem, pjl_env[i].value, "free pjl_environment value");
+        i++;
+    }
+    gs_free_object(mem, pjl_env, "pjl_environment");
+    *env = 0x00;
+    return 0;
+}
+
+int free_pjl_fontsource(gs_memory_t * mem, pjl_fontsource_t **fontenv)
+{
+    int i=0;
+    pjl_fontsource_t *pjl_fontenv = *fontenv;
+
+    while (pjl_fontenv[i].pathname) {
+        gs_free_object(mem, pjl_fontenv[i].pathname, "pjl_font_envir pathname");
+        gs_free_object(mem, pjl_fontenv[i].fontnumber, "pjl_font_envir fontnumber");
+        i++;
+    }
+    gs_free_object(mem, pjl_fontenv, "pjl_font_envir");
+    *fontenv = 0x00;
+    return 0;
+}
+
+int free_pjl_default_fontsource(gs_memory_t * mem, pjl_fontsource_t **fontdef)
+{
+    int i=0;
+    pjl_fontsource_t *pjl_fontdef = *fontdef;
+
+    while (pjl_fontdef[i].pathname) {
+        gs_free_object(mem, pjl_fontdef[i].pathname, "pjl_font_defaults pathname");
+        gs_free_object(mem, pjl_fontdef[i].fontnumber, "pjl_font_defaults fontnumber");
+        i++;
+    }
+    gs_free_object(mem, pjl_fontdef, "pjl_font_defaults");
+    *fontdef = 0x00;
+    return 0;
+}
+
 /* Create and initialize a new state. */
 pjl_parser_state *
 pjl_process_init(gs_memory_t * mem)
 {
+    pjl_envir_var_t *pjl_env, *pjl_def;
+    pjl_fontsource_t *pjl_fontenv, *pjl_fontdef;
+
     pjl_parser_state_t *pjlstate = (pjl_parser_state *) gs_alloc_bytes(mem,
                                                                        sizeof
                                                                        (pjl_parser_state_t),
                                                                        "pjl_state");
-    pjl_envir_var_t *pjl_env = (pjl_envir_var_t *) gs_alloc_bytes(mem,
-                                                                  sizeof
-                                                                  (pjl_factory_defaults),
-                                                                  "pjl_envir");
-    pjl_envir_var_t *pjl_def = (pjl_envir_var_t *) gs_alloc_bytes(mem,
-                                                                  sizeof
-                                                                  (pjl_factory_defaults),
-                                                                  "pjl_defaults");
-    pjl_fontsource_t *pjl_fontenv = (pjl_fontsource_t *) gs_alloc_bytes(mem,
-                                                                        sizeof
-                                                                        (pjl_fontsource_table),
-                                                                        "pjl_font_envir");
-    pjl_fontsource_t *pjl_fontdef = (pjl_fontsource_t *) gs_alloc_bytes(mem,
-                                                                        sizeof
-                                                                        (pjl_fontsource_table),
-                                                                        "pjl_font_defaults");
-
-    if (pjlstate == NULL || pjl_env == NULL || pjl_def == NULL)
+
+    if (pjlstate == NULL)
         return NULL;            /* should be fatal so we don't bother piecemeal frees */
 
     /* check for an environment variable */
@@ -1276,20 +1543,38 @@ pjl_process_init(gs_memory_t * mem)
         } else                  /* environmet variable does not exist use pjl fontsource */
             pjlstate->environment_font_path = NULL;
     }
+
+    /* initialize the default and initial pjl environment.  We assume
+       that these are the same layout as the factory defaults. */
+    if (set_pjl_defaults_to_factory(mem, &pjl_def) < 0) {
+        gs_free_object(mem, pjlstate, "pjl_state");
+        return NULL;
+    }
+    if (set_pjl_environment_to_factory(mem, &pjl_env) < 0) {
+        free_pjl_defaults(mem, &pjl_def);
+        gs_free_object(mem, pjlstate, "pjl_state");
+        return NULL;
+    }
+    if (set_pjl_fontsource_to_factory(mem, &pjl_fontenv) < 0) {
+        free_pjl_defaults(mem, &pjl_def);
+        free_pjl_environment(mem, &pjl_env);
+        gs_free_object(mem, pjlstate, "pjl_state");
+        return NULL;
+    }
+    if (set_pjl_default_fontsource_to_factory(mem, &pjl_fontdef) < 0) {
+        free_pjl_defaults(mem, &pjl_def);
+        free_pjl_environment(mem, &pjl_env);
+        free_pjl_fontsource(mem, &pjl_fontenv);
+        gs_free_object(mem, pjlstate, "pjl_state");
+        return NULL;
+    }
+
+    /* initialize the font repository data as well */
     pjlstate->defaults = pjl_def;
     pjlstate->envir = pjl_env;
     pjlstate->font_envir = pjl_fontenv;
     pjlstate->font_defaults = pjl_fontdef;
-    /* initialize the default and initial pjl environment.  We assume
-       that these are the same layout as the factory defaults. */
-    memcpy(pjlstate->defaults, pjl_factory_defaults,
-           sizeof(pjl_factory_defaults));
-    memcpy(pjlstate->envir, pjlstate->defaults, sizeof(pjl_factory_defaults));
-    /* initialize the font repository data as well */
-    memcpy(pjlstate->font_defaults, pjl_fontsource_table,
-           sizeof(pjl_fontsource_table));
-    memcpy(pjlstate->font_envir, pjl_fontsource_table,
-           sizeof(pjl_fontsource_table));
+
     /* initialize the current position in the line array and bytes pending */
     pjlstate->bytes_to_read = 0;
     pjlstate->bytes_to_write = 0;
@@ -1322,10 +1607,11 @@ pjl_compare(const pjl_envvar_t * s1, const char *s2)
 void
 pjl_process_destroy(pjl_parser_state * pst, gs_memory_t * mem)
 {
-    gs_free_object(mem, pst->font_envir, "pjl_font_envir");
-    gs_free_object(mem, pst->font_defaults, "pjl_font_defaults");
-    gs_free_object(mem, pst->defaults, "pjl_defaults");
-    gs_free_object(mem, pst->envir, "pjl_envir");
+    free_pjl_defaults(mem, &pst->defaults);
+    free_pjl_environment(mem, &pst->envir);
+    free_pjl_fontsource(mem, &pst->font_envir);
+    free_pjl_default_fontsource(mem, &pst->font_defaults);
+
     if (pst->environment_font_path)
         gs_free_object(mem, pst->environment_font_path, "pjl_state");
     gs_free_object(mem, pst, "pjl_state");