← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/ghostscript/oneiric

« back to all changes in this revision

Viewing changes to base/gscparam.c

  • Committer: Bazaar Package Importer
  • Author(s): Till Kamppeter
  • Date: 2011-07-15 16:49:55 UTC
  • mfrom: (1.1.23 upstream)
  • Revision ID: james.westby@ubuntu.com-20110715164955-uga6qibao6kez05c
Tags: 9.04~dfsg~20110715-0ubuntu1
* New upstream release
   - GIT snapshot from Jult, 12 2011.
* debian/patches/020110406~a54df2d.patch,
  debian/patches/020110408~0791cc8.patch,
  debian/patches/020110408~507cbee.patch,
  debian/patches/020110411~4509a49.patch,
  debian/patches/020110412~78bb9a6.patch,
  debian/patches/020110418~a05ab8a.patch,
  debian/patches/020110420~20b6c78.patch,
  debian/patches/020110420~4ddefa2.patch: Removed upstream patches.
* debian/rules: Generate ABI version number (variable "abi") correctly,
  cutting off repackaging and pre-release parts.
* debian/rules: Added ./lcms2/ directory to DEB_UPSTREAM_REPACKAGE_EXCLUDES.
* debian/copyright: Added lcms2/* to the list of excluded files.
* debian/symbols.common: Updated for new upstream source. Applied patch
  which dpkg-gensymbols generated for debian/libgs9.symbols to this file.

Show diffs side-by-side

added added

removed removed

Lines of Context:
base/gscparam.c
1
1
/* Copyright (C) 2001-2006 Artifex Software, Inc.
2
2
   All Rights Reserved.
3
 
  
 
3
 
4
4
   This software is provided AS-IS with no warranty, either express or
5
5
   implied.
6
6
 
11
11
   San Rafael, CA  94903, U.S.A., +1(415)492-9861, for further information.
12
12
*/
13
13
 
14
 
/* $Id: gscparam.c 8250 2007-09-25 13:31:24Z giles $ */
 
14
/* $Id$ */
15
15
/* Default implementation of parameter lists */
16
16
#include "memory_.h"
17
17
#include "string_.h"
55
55
 
56
56
/* GC descriptor and procedures */
57
57
gs_private_st_composite(st_c_param, gs_c_param, "gs_c_param",
58
 
                        c_param_enum_ptrs, c_param_reloc_ptrs);
 
58
                        c_param_enum_ptrs, c_param_reloc_ptrs);
59
59
ENUM_PTRS_WITH(c_param_enum_ptrs, gs_c_param *param) {
60
60
    index -= 3;
61
61
    switch (param->type) {
62
 
        /* Only the aggregate types are handled specially. */
 
62
        /* Only the aggregate types are handled specially. */
63
63
    case gs_param_type_dict:
64
64
    case gs_param_type_dict_int_keys:
65
65
    case gs_param_type_array:
66
 
        return ENUM_USING(st_c_param_list, &param->value.d,
67
 
                          sizeof(param->value.d), index);
 
66
        return ENUM_USING(st_c_param_list, &param->value.d,
 
67
                          sizeof(param->value.d), index);
68
68
    default: {
69
 
        gs_param_typed_value value;
 
69
        gs_param_typed_value value;
70
70
 
71
 
        value.value = *(const gs_param_value *)&param->value;
72
 
        value.type = param->type;
73
 
        return gs_param_typed_value_enum_ptrs(mem, &value, sizeof(value), index,
74
 
                                              pep, NULL, gcst);
 
71
        value.value = *(const gs_param_value *)&param->value;
 
72
        value.type = param->type;
 
73
        return gs_param_typed_value_enum_ptrs(mem, &value, sizeof(value), index,
 
74
                                              pep, NULL, gcst);
75
75
    }
76
76
    }
77
77
}
79
79
case 1: return ENUM_OBJ(param->alternate_typed_data);
80
80
case 2:
81
81
    if (!param->key.persistent) {
82
 
        gs_const_string key;
 
82
        gs_const_string key;
83
83
 
84
 
        key.data = param->key.data;
85
 
        key.size = param->key.size;
86
 
        return ENUM_STRING(&key);
 
84
        key.data = param->key.data;
 
85
        key.size = param->key.size;
 
86
        return ENUM_STRING(&key);
87
87
    } else
88
 
        return ENUM_OBJ(0);     /* keep going */
 
88
        return ENUM_OBJ(0);     /* keep going */
89
89
ENUM_PTRS_END
90
90
RELOC_PTRS_WITH(c_param_reloc_ptrs, gs_c_param *param) {
91
91
    RELOC_VAR(param->next);
92
92
    RELOC_VAR(param->alternate_typed_data);
93
93
    if (!param->key.persistent) {
94
 
        gs_const_string key;
 
94
        gs_const_string key;
95
95
 
96
 
        key.data = param->key.data;
97
 
        key.size = param->key.size;
98
 
        RELOC_CONST_STRING_VAR(key);
99
 
        param->key.data = key.data;
 
96
        key.data = param->key.data;
 
97
        key.size = param->key.size;
 
98
        RELOC_CONST_STRING_VAR(key);
 
99
        param->key.data = key.data;
100
100
    }
101
101
    switch (param->type) {
102
 
        /* Only the aggregate types are handled specially. */
 
102
        /* Only the aggregate types are handled specially. */
103
103
    case gs_param_type_dict:
104
104
    case gs_param_type_dict_int_keys:
105
105
    case gs_param_type_array:
106
 
        RELOC_USING(st_c_param_list, &param->value.d, sizeof(param->value.d));
107
 
        break;
 
106
        RELOC_USING(st_c_param_list, &param->value.d, sizeof(param->value.d));
 
107
        break;
108
108
    default: {
109
 
        gs_param_typed_value value;
 
109
        gs_param_typed_value value;
110
110
 
111
 
        value.value = *(gs_param_value *)&param->value;
112
 
        value.type = param->type;
113
 
        gs_param_typed_value_reloc_ptrs(&value, sizeof(value), NULL, gcst);
114
 
        *(gs_param_value *)&param->value = value.value;
 
111
        value.value = *(gs_param_value *)&param->value;
 
112
        value.type = param->type;
 
113
        gs_param_typed_value_reloc_ptrs(&value, sizeof(value), NULL, gcst);
 
114
        *(gs_param_value *)&param->value = value.value;
115
115
    }
116
116
    }
117
117
}
132
132
    uint len = strlen(pkey);
133
133
 
134
134
    for (; pparam != 0; pparam = pparam->next)
135
 
        if (pparam->key.size == len && !memcmp(pparam->key.data, pkey, len))
136
 
            return (pparam->type != gs_param_type_any || any ? pparam : 0);
 
135
        if (pparam->key.size == len && !memcmp(pparam->key.data, pkey, len))
 
136
            return (pparam->type != gs_param_type_any || any ? pparam : 0);
137
137
    return 0;
138
138
}
139
139
 
191
191
    gs_c_param *pparam;
192
192
 
193
193
    while ((pparam = plist->head) != 0) {
194
 
        gs_c_param *next = pparam->next;
 
194
        gs_c_param *next = pparam->next;
195
195
 
196
 
        switch (pparam->type) {
197
 
            case gs_param_type_dict:
198
 
            case gs_param_type_dict_int_keys:
199
 
            case gs_param_type_array:
200
 
                gs_c_param_list_release(&pparam->value.d);
201
 
                break;
202
 
            case gs_param_type_string:
203
 
            case gs_param_type_name:
204
 
            case gs_param_type_int_array:
205
 
            case gs_param_type_float_array:
206
 
            case gs_param_type_string_array:
207
 
            case gs_param_type_name_array:
208
 
                if (!pparam->value.s.persistent)
209
 
                    gs_free_const_object(mem, pparam->value.s.data,
210
 
                                         "gs_c_param_list_release data");
211
 
                break;
212
 
            default:
213
 
                break;
214
 
        }
215
 
        if (pparam->free_key) {
216
 
            /* We allocated this, so we must free it. */
217
 
            gs_free_const_string(mem, pparam->key.data, pparam->key.size,
218
 
                                 "gs_c_param_list_release key");
219
 
        }
220
 
        gs_free_object(mem, pparam->alternate_typed_data,
221
 
                       "gs_c_param_list_release alternate data");
222
 
        gs_free_object(mem, pparam,
223
 
                       "gs_c_param_list_release entry");
224
 
        plist->head = next;
225
 
        plist->count--;
 
196
        switch (pparam->type) {
 
197
            case gs_param_type_dict:
 
198
            case gs_param_type_dict_int_keys:
 
199
            case gs_param_type_array:
 
200
                gs_c_param_list_release(&pparam->value.d);
 
201
                break;
 
202
            case gs_param_type_string:
 
203
            case gs_param_type_name:
 
204
            case gs_param_type_int_array:
 
205
            case gs_param_type_float_array:
 
206
            case gs_param_type_string_array:
 
207
            case gs_param_type_name_array:
 
208
                if (!pparam->value.s.persistent)
 
209
                    gs_free_const_object(mem, pparam->value.s.data,
 
210
                                         "gs_c_param_list_release data");
 
211
                break;
 
212
            default:
 
213
                break;
 
214
        }
 
215
        if (pparam->free_key) {
 
216
            /* We allocated this, so we must free it. */
 
217
            gs_free_const_string(mem, pparam->key.data, pparam->key.size,
 
218
                                 "gs_c_param_list_release key");
 
219
        }
 
220
        gs_free_object(mem, pparam->alternate_typed_data,
 
221
                       "gs_c_param_list_release alternate data");
 
222
        gs_free_object(mem, pparam,
 
223
                       "gs_c_param_list_release entry");
 
224
        plist->head = next;
 
225
        plist->count--;
226
226
    }
227
227
}
228
228
 
231
231
c_param_add(gs_c_param_list * plist, gs_param_name pkey)
232
232
{
233
233
    gs_c_param *pparam =
234
 
        gs_alloc_struct(plist->memory, gs_c_param, &st_c_param,
235
 
                        "c_param_add entry");
 
234
        gs_alloc_struct(plist->memory, gs_c_param, &st_c_param,
 
235
                        "c_param_add entry");
236
236
    uint len = strlen(pkey);
237
237
 
238
238
    if (pparam == 0)
239
 
        return 0;
 
239
        return 0;
240
240
    pparam->next = plist->head;
241
241
    if (!plist->persistent_keys) {
242
 
        /* We must copy the key. */
243
 
        byte *str = gs_alloc_string(plist->memory, len, "c_param_add key");
 
242
        /* We must copy the key. */
 
243
        byte *str = gs_alloc_string(plist->memory, len, "c_param_add key");
244
244
 
245
 
        if (str == 0) {
246
 
            gs_free_object(plist->memory, pparam, "c_param_add entry");
247
 
            return 0;
248
 
        }
249
 
        memcpy(str, pkey, len);
250
 
        pparam->key.data = str;
251
 
        pparam->key.persistent = false; /* we will free it */
252
 
        pparam->free_key = true;
 
245
        if (str == 0) {
 
246
            gs_free_object(plist->memory, pparam, "c_param_add entry");
 
247
            return 0;
 
248
        }
 
249
        memcpy(str, pkey, len);
 
250
        pparam->key.data = str;
 
251
        pparam->key.persistent = false; /* we will free it */
 
252
        pparam->free_key = true;
253
253
    } else {
254
 
        pparam->key.data = (const byte *)pkey;
255
 
        pparam->key.persistent = true;
256
 
        pparam->free_key = false;
 
254
        pparam->key.data = (const byte *)pkey;
 
255
        pparam->key.persistent = true;
 
256
        pparam->free_key = false;
257
257
    }
258
258
    pparam->key.size = len;
259
259
    pparam->alternate_typed_data = 0;
263
263
/*  Write a dynamically typed parameter to a list. */
264
264
static int
265
265
c_param_write(gs_c_param_list * plist, gs_param_name pkey, void *pvalue,
266
 
              gs_param_type type)
 
266
              gs_param_type type)
267
267
{
268
268
    unsigned top_level_sizeof = 0;
269
269
    unsigned second_level_sizeof = 0;
270
270
    gs_c_param *pparam = c_param_add(plist, pkey);
271
271
 
272
272
    if (pparam == 0)
273
 
        return_error(gs_error_VMerror);
 
273
        return_error(gs_error_VMerror);
274
274
    memcpy(&pparam->value, pvalue, gs_param_type_sizes[(int)type]);
275
275
    pparam->type = type;
276
276
 
277
277
    /* Need deeper copies of data if it's not persistent */
278
278
    switch (type) {
279
 
            gs_param_string const *curr_string;
280
 
            gs_param_string const *end_string;
281
 
 
282
 
        case gs_param_type_string_array:
283
 
        case gs_param_type_name_array:
284
 
            /* Determine how much mem needed to hold actual string data */
285
 
            curr_string = pparam->value.sa.data;
286
 
            end_string = curr_string + pparam->value.sa.size;
287
 
            for (; curr_string < end_string; ++curr_string)
288
 
                if (!curr_string->persistent)
289
 
                    second_level_sizeof += curr_string->size;
290
 
            /* fall thru */
291
 
 
292
 
        case gs_param_type_string:
293
 
        case gs_param_type_name:
294
 
        case gs_param_type_int_array:
295
 
        case gs_param_type_float_array:
296
 
            if (!pparam->value.s.persistent) {  /* Allocate & copy object pointed to by array or string */
297
 
                byte *top_level_memory = NULL;
298
 
 
299
 
                top_level_sizeof =
300
 
                    pparam->value.s.size * gs_param_type_base_sizes[type];
301
 
                if (top_level_sizeof + second_level_sizeof > 0) {
302
 
                    top_level_memory =
303
 
                        gs_alloc_bytes_immovable(plist->memory,
304
 
                                     top_level_sizeof + second_level_sizeof,
305
 
                                             "c_param_write data");
306
 
                    if (top_level_memory == 0) {
307
 
                        gs_free_object(plist->memory, pparam, "c_param_write entry");
308
 
                        return_error(gs_error_VMerror);
309
 
                    }
310
 
                    memcpy(top_level_memory, pparam->value.s.data, top_level_sizeof);
311
 
                }
312
 
                pparam->value.s.data = top_level_memory;
313
 
 
314
 
                /* String/name arrays need to copy actual str data */
315
 
 
316
 
                if (second_level_sizeof > 0) {
317
 
                    byte *second_level_memory =
318
 
                    top_level_memory + top_level_sizeof;
319
 
 
320
 
                    curr_string = pparam->value.sa.data;
321
 
                    end_string = curr_string + pparam->value.sa.size;
322
 
                    for (; curr_string < end_string; ++curr_string)
323
 
                        if (!curr_string->persistent) {
324
 
                            memcpy(second_level_memory,
325
 
                                   curr_string->data, curr_string->size);
326
 
                            ((gs_param_string *) curr_string)->data
327
 
                                = second_level_memory;
328
 
                            second_level_memory += curr_string->size;
329
 
                        }
330
 
                }
331
 
            }
332
 
            break;
333
 
        default:
334
 
            break;
 
279
            gs_param_string const *curr_string;
 
280
            gs_param_string const *end_string;
 
281
 
 
282
        case gs_param_type_string_array:
 
283
        case gs_param_type_name_array:
 
284
            /* Determine how much mem needed to hold actual string data */
 
285
            curr_string = pparam->value.sa.data;
 
286
            end_string = curr_string + pparam->value.sa.size;
 
287
            for (; curr_string < end_string; ++curr_string)
 
288
                if (!curr_string->persistent)
 
289
                    second_level_sizeof += curr_string->size;
 
290
            /* fall thru */
 
291
 
 
292
        case gs_param_type_string:
 
293
        case gs_param_type_name:
 
294
        case gs_param_type_int_array:
 
295
        case gs_param_type_float_array:
 
296
            if (!pparam->value.s.persistent) {  /* Allocate & copy object pointed to by array or string */
 
297
                byte *top_level_memory = NULL;
 
298
 
 
299
                top_level_sizeof =
 
300
                    pparam->value.s.size * gs_param_type_base_sizes[type];
 
301
                if (top_level_sizeof + second_level_sizeof > 0) {
 
302
                    top_level_memory =
 
303
                        gs_alloc_bytes_immovable(plist->memory,
 
304
                                     top_level_sizeof + second_level_sizeof,
 
305
                                             "c_param_write data");
 
306
                    if (top_level_memory == 0) {
 
307
                        gs_free_object(plist->memory, pparam, "c_param_write entry");
 
308
                        return_error(gs_error_VMerror);
 
309
                    }
 
310
                    memcpy(top_level_memory, pparam->value.s.data, top_level_sizeof);
 
311
                }
 
312
                pparam->value.s.data = top_level_memory;
 
313
 
 
314
                /* String/name arrays need to copy actual str data */
 
315
 
 
316
                if (second_level_sizeof > 0) {
 
317
                    byte *second_level_memory =
 
318
                    top_level_memory + top_level_sizeof;
 
319
 
 
320
                    curr_string = pparam->value.sa.data;
 
321
                    end_string = curr_string + pparam->value.sa.size;
 
322
                    for (; curr_string < end_string; ++curr_string)
 
323
                        if (!curr_string->persistent) {
 
324
                            memcpy(second_level_memory,
 
325
                                   curr_string->data, curr_string->size);
 
326
                            ((gs_param_string *) curr_string)->data
 
327
                                = second_level_memory;
 
328
                            second_level_memory += curr_string->size;
 
329
                        }
 
330
                }
 
331
            }
 
332
            break;
 
333
        default:
 
334
            break;
335
335
    }
336
336
 
337
337
    plist->head = pparam;
342
342
/* Individual writing routines. */
343
343
static int
344
344
c_param_begin_write_collection(gs_param_list * plist, gs_param_name pkey,
345
 
               gs_param_dict * pvalue, gs_param_collection_type_t coll_type)
 
345
               gs_param_dict * pvalue, gs_param_collection_type_t coll_type)
346
346
{
347
347
    gs_c_param_list *const cplist = (gs_c_param_list *)plist;
348
348
    gs_c_param_list *dlist =
349
 
        gs_c_param_list_alloc(cplist->memory,
350
 
                              "c_param_begin_write_collection");
 
349
        gs_c_param_list_alloc(cplist->memory,
 
350
                              "c_param_begin_write_collection");
351
351
 
352
352
    if (dlist == 0)
353
 
        return_error(gs_error_VMerror);
 
353
        return_error(gs_error_VMerror);
354
354
    gs_c_param_list_write(dlist, cplist->memory);
355
355
    dlist->coll_type = coll_type;
356
356
    pvalue->list = (gs_param_list *) dlist;
358
358
}
359
359
static int
360
360
c_param_end_write_collection(gs_param_list * plist, gs_param_name pkey,
361
 
                             gs_param_dict * pvalue)
 
361
                             gs_param_dict * pvalue)
362
362
{
363
363
    gs_c_param_list *const cplist = (gs_c_param_list *)plist;
364
364
    gs_c_param_list *dlist = (gs_c_param_list *) pvalue->list;
365
365
 
366
366
    return c_param_write(cplist, pkey, pvalue->list,
367
 
                    (dlist->coll_type == gs_param_collection_dict_int_keys ?
368
 
                     gs_param_type_dict_int_keys :
369
 
                     dlist->coll_type == gs_param_collection_array ?
370
 
                     gs_param_type_array : gs_param_type_dict));
 
367
                    (dlist->coll_type == gs_param_collection_dict_int_keys ?
 
368
                     gs_param_type_dict_int_keys :
 
369
                     dlist->coll_type == gs_param_collection_array ?
 
370
                     gs_param_type_array : gs_param_type_dict));
371
371
}
372
372
static int
373
373
c_param_write_typed(gs_param_list * plist, gs_param_name pkey,
374
 
                    gs_param_typed_value * pvalue)
 
374
                    gs_param_typed_value * pvalue)
375
375
{
376
376
    gs_c_param_list *const cplist = (gs_c_param_list *)plist;
377
377
    gs_param_collection_type_t coll_type;
378
378
 
379
379
    switch (pvalue->type) {
380
 
        case gs_param_type_dict:
381
 
            coll_type = gs_param_collection_dict_any;
382
 
            break;
383
 
        case gs_param_type_dict_int_keys:
384
 
            coll_type = gs_param_collection_dict_int_keys;
385
 
            break;
386
 
        case gs_param_type_array:
387
 
            coll_type = gs_param_collection_array;
388
 
            break;
389
 
        default:
390
 
            return c_param_write(cplist, pkey, &pvalue->value, pvalue->type);
 
380
        case gs_param_type_dict:
 
381
            coll_type = gs_param_collection_dict_any;
 
382
            break;
 
383
        case gs_param_type_dict_int_keys:
 
384
            coll_type = gs_param_collection_dict_int_keys;
 
385
            break;
 
386
        case gs_param_type_array:
 
387
            coll_type = gs_param_collection_array;
 
388
            break;
 
389
        default:
 
390
            return c_param_write(cplist, pkey, &pvalue->value, pvalue->type);
391
391
    }
392
392
    return c_param_begin_write_collection
393
 
        (plist, pkey, &pvalue->value.d, coll_type);
 
393
        (plist, pkey, &pvalue->value.d, coll_type);
394
394
}
395
395
 
396
396
/* Other procedures */
403
403
 
404
404
    cplist->any_requested = true;
405
405
    if (c_param_find(cplist, pkey, true))
406
 
        return 0;
 
406
        return 0;
407
407
    pparam = c_param_add(cplist, pkey);
408
408
    if (pparam == 0)
409
 
        return_error(gs_error_VMerror);
 
409
        return_error(gs_error_VMerror);
410
410
    pparam->type = gs_param_type_any; /* mark as undefined */
411
411
    cplist->head = pparam;
412
412
    return 0;
420
420
    int code;
421
421
 
422
422
    if (!cplist->any_requested)
423
 
        return (target ? param_requested(target, pkey) : -1);
 
423
        return (target ? param_requested(target, pkey) : -1);
424
424
    if (c_param_find(cplist, pkey, true) != 0)
425
 
        return 1;
 
425
        return 1;
426
426
    if (!target)
427
 
        return 0;
 
427
        return 0;
428
428
    code = param_requested(target, pkey);
429
429
    return (code < 0 ? 0 : 1);
430
430
}
462
462
 
463
463
static int
464
464
c_param_read_typed(gs_param_list * plist, gs_param_name pkey,
465
 
                   gs_param_typed_value * pvalue)
 
465
                   gs_param_typed_value * pvalue)
466
466
{
467
467
    gs_c_param_list *const cplist = (gs_c_param_list *)plist;
468
468
    gs_param_type req_type = pvalue->type;
470
470
    int code;
471
471
 
472
472
    if (pparam == 0)
473
 
        return (cplist->target ?
474
 
                param_read_typed(cplist->target, pkey, pvalue) : 1);
 
473
        return (cplist->target ?
 
474
                param_read_typed(cplist->target, pkey, pvalue) : 1);
475
475
    pvalue->type = pparam->type;
476
476
    switch (pvalue->type) {
477
 
        case gs_param_type_dict:
478
 
        case gs_param_type_dict_int_keys:
479
 
        case gs_param_type_array:
480
 
            gs_c_param_list_read(&pparam->value.d);
481
 
            pvalue->value.d.list = (gs_param_list *) & pparam->value.d;
482
 
            pvalue->value.d.size = pparam->value.d.count;
483
 
            return 0;
484
 
        default:
485
 
            break;
 
477
        case gs_param_type_dict:
 
478
        case gs_param_type_dict_int_keys:
 
479
        case gs_param_type_array:
 
480
            gs_c_param_list_read(&pparam->value.d);
 
481
            pvalue->value.d.list = (gs_param_list *) & pparam->value.d;
 
482
            pvalue->value.d.size = pparam->value.d.count;
 
483
            return 0;
 
484
        default:
 
485
            break;
486
486
    }
487
487
    memcpy(&pvalue->value, &pparam->value,
488
 
           gs_param_type_sizes[(int)pparam->type]);
 
488
           gs_param_type_sizes[(int)pparam->type]);
489
489
    code = param_coerce_typed(pvalue, req_type, NULL);
490
490
/****** SHOULD LET param_coerce_typed DO THIS ******/
491
491
    if (code == gs_error_typecheck &&
492
 
        req_type == gs_param_type_float_array &&
493
 
        pvalue->type == gs_param_type_int_array
494
 
        ) {
495
 
        /* Convert int array to float dest */
496
 
        gs_param_float_array fa;
497
 
        int element;
498
 
 
499
 
        fa.size = pparam->value.ia.size;
500
 
        fa.persistent = false;
501
 
 
502
 
        if (pparam->alternate_typed_data == 0) {
503
 
            if ((pparam->alternate_typed_data
504
 
                 = (void *)gs_alloc_bytes_immovable(cplist->memory,
505
 
                                                    fa.size * sizeof(float),
506
 
                             "gs_c_param_read alternate float array")) == 0)
507
 
                      return_error(gs_error_VMerror);
508
 
 
509
 
            for (element = 0; element < fa.size; ++element)
510
 
                ((float *)(pparam->alternate_typed_data))[element]
511
 
                    = (float)pparam->value.ia.data[element];
512
 
        }
513
 
        fa.data = (float *)pparam->alternate_typed_data;
514
 
 
515
 
        pvalue->value.fa = fa;
516
 
        return 0;
 
492
        req_type == gs_param_type_float_array &&
 
493
        pvalue->type == gs_param_type_int_array
 
494
        ) {
 
495
        /* Convert int array to float dest */
 
496
        gs_param_float_array fa;
 
497
        int element;
 
498
 
 
499
        fa.size = pparam->value.ia.size;
 
500
        fa.persistent = false;
 
501
 
 
502
        if (pparam->alternate_typed_data == 0) {
 
503
            if ((pparam->alternate_typed_data
 
504
                 = (void *)gs_alloc_bytes_immovable(cplist->memory,
 
505
                                                    fa.size * sizeof(float),
 
506
                             "gs_c_param_read alternate float array")) == 0)
 
507
                      return_error(gs_error_VMerror);
 
508
 
 
509
            for (element = 0; element < fa.size; ++element)
 
510
                ((float *)(pparam->alternate_typed_data))[element]
 
511
                    = (float)pparam->value.ia.data[element];
 
512
        }
 
513
        fa.data = (float *)pparam->alternate_typed_data;
 
514
 
 
515
        pvalue->value.fa = fa;
 
516
        return 0;
517
517
    }
518
518
    return code;
519
519
}
521
521
/* Individual reading routines. */
522
522
static int
523
523
c_param_begin_read_collection(gs_param_list * plist, gs_param_name pkey,
524
 
               gs_param_dict * pvalue, gs_param_collection_type_t coll_type)
 
524
               gs_param_dict * pvalue, gs_param_collection_type_t coll_type)
525
525
{
526
526
    gs_c_param_list *const cplist = (gs_c_param_list *)plist;
527
527
    gs_c_param *pparam = c_param_find(cplist, pkey, false);
528
528
 
529
529
    if (pparam == 0)
530
 
        return
531
 
            (cplist->target ?
532
 
             param_begin_read_collection(cplist->target,
533
 
                                         pkey, pvalue, coll_type) :
534
 
             1);
 
530
        return
 
531
            (cplist->target ?
 
532
             param_begin_read_collection(cplist->target,
 
533
                                         pkey, pvalue, coll_type) :
 
534
             1);
535
535
    switch (pparam->type) {
536
 
        case gs_param_type_dict:
537
 
            if (coll_type != gs_param_collection_dict_any)
538
 
                return_error(gs_error_typecheck);
539
 
            break;
540
 
        case gs_param_type_dict_int_keys:
541
 
            if (coll_type == gs_param_collection_array)
542
 
                return_error(gs_error_typecheck);
543
 
            break;
544
 
        case gs_param_type_array:
545
 
            break;
546
 
        default:
547
 
            return_error(gs_error_typecheck);
 
536
        case gs_param_type_dict:
 
537
            if (coll_type != gs_param_collection_dict_any)
 
538
                return_error(gs_error_typecheck);
 
539
            break;
 
540
        case gs_param_type_dict_int_keys:
 
541
            if (coll_type == gs_param_collection_array)
 
542
                return_error(gs_error_typecheck);
 
543
            break;
 
544
        case gs_param_type_array:
 
545
            break;
 
546
        default:
 
547
            return_error(gs_error_typecheck);
548
548
    }
549
549
    gs_c_param_list_read(&pparam->value.d);
550
550
    pvalue->list = (gs_param_list *) & pparam->value.d;
553
553
}
554
554
static int
555
555
c_param_end_read_collection(gs_param_list * plist, gs_param_name pkey,
556
 
                            gs_param_dict * pvalue)
 
556
                            gs_param_dict * pvalue)
557
557
{
558
558
    return 0;
559
559
}
561
561
/* Other procedures */
562
562
static int                      /* ret 0 ok, 1 if EOF, or -ve err */
563
563
c_param_get_next_key(gs_param_list * plist, gs_param_enumerator_t * penum,
564
 
                     gs_param_key_t * key)
 
564
                     gs_param_key_t * key)
565
565
{
566
566
    gs_c_param_list *const cplist = (gs_c_param_list *)plist;
567
567
    gs_c_param *pparam =
569
569
     cplist->head);
570
570
 
571
571
    if (pparam == 0)
572
 
        return 1;
 
572
        return 1;
573
573
    penum->pvoid = pparam;
574
574
    *key = pparam->key;
575
575
    return 0;