1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
/* Copyright (C) 1998 Aladdin Enterprises. All rights reserved.
This file is part of Aladdin Ghostscript.
Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND. No author
or distributor accepts any responsibility for the consequences of using it,
or for whether it serves any particular purpose or works at all, unless he
or she says so in writing. Refer to the Aladdin Ghostscript Free Public
License (the "License") for full details.
Every copy of Aladdin Ghostscript must include a copy of the License,
normally in a plain ASCII text file named PUBLIC. The License grants you
the right to copy, modify and redistribute Aladdin Ghostscript, but only
under certain conditions described in the License. Among other things, the
License requires that the copyright notice and this notice be preserved on
all copies.
*/
/* Generic dictionary stack API */
#ifndef idstack_INCLUDED
# define idstack_INCLUDED
#include "istack.h"
/* Define the dictionary stack structure. */
typedef struct dict_stack_s {
ref_stack stack; /* the actual stack of dictionaries */
/*
* Switching between Level 1 and Level 2 involves inserting and removing
* globaldict on the dictionary stack. Instead of truly inserting and
* removing entries, we replace globaldict by a copy of systemdict in
* Level 1 mode. min_dstack_size, the minimum number of entries, does not
* change depending on language level; the countdictstack and dictstack
* operators must take this into account.
*/
uint min_size; /* size of stack after clearing */
int userdict_index; /* index of userdict on stack */
/*
* Cache a value for fast checking of def operations.
* If the top entry on the dictionary stack is a writable dictionary,
* dsspace is the space of the dictionary; if it is a non-writable
* dictionary, dsspace = -1. Then def is legal precisely if
* r_space(pvalue) <= dsspace. Note that in order for this trick to work,
* the result of r_space must be a signed integer; some compilers treat
* enums as unsigned, probably in violation of the ANSI standard.
*/
int def_space;
/*
* Cache values for fast name lookup. If the top entry on the dictionary
* stack is a readable dictionary with packed keys, dtop_keys, dtop_npairs,
* and dtop_values are keys.value.packed, npairs, and values.value.refs
* for that dictionary; otherwise, these variables point to a dummy
* empty dictionary.
*/
const ref_packed *top_keys;
uint top_npairs;
ref *top_values;
/*
* Cache a copy of the bottom entry on the stack, which is never deleted.
*/
ref system_dict;
} dict_stack_t;
/*
* Reset the cached top values. Every routine that alters the
* dictionary stack (including changing the protection or size of the
* top dictionary on the stack) must call this.
*/
void dstack_set_top(P1(dict_stack_t *));
/* Check whether a dictionary is one of the permanent ones on the d-stack. */
bool dstack_dict_is_permanent(P2(const dict_stack_t *, const ref *));
/* Define the type of pointers into the dictionary stack. */
typedef s_ptr ds_ptr;
typedef const_s_ptr const_ds_ptr;
/* Clean up a dictionary stack after a garbage collection. */
void dstack_gc_cleanup(P1(dict_stack_t *));
/*
* Define a special fast entry for name lookup on a dictionary stack.
* The key is known to be a name; search the entire dict stack.
* Return the pointer to the value slot.
* If the name isn't found, just return 0.
*/
ref *dstack_find_name_by_index(P2(dict_stack_t *, uint));
/*
* Define an extra-fast macro for name lookup, optimized for
* a single-probe lookup in the top dictionary on the stack.
* Amazingly enough, this seems to hit over 90% of the time
* (aside from operators, of course, which are handled either with
* the special cache pointer or with 'bind').
*/
#define dstack_find_name_by_index_inline(pds,nidx,htemp)\
((pds)->top_keys[htemp = dict_hash_mod_inline(dict_name_index_hash(nidx),\
(pds)->top_npairs) + 1] == pt_tag(pt_literal_name) + (nidx) ?\
(pds)->top_values + htemp : dstack_find_name_by_index(pds, nidx))
/*
* Define a similar macro that only checks the top dictionary on the stack.
*/
#define if_dstack_find_name_by_index_top(pds,nidx,htemp,pvslot)\
if ( (((pds)->top_keys[htemp = dict_hash_mod_inline(dict_name_index_hash(nidx),\
(pds)->top_npairs) + 1] == pt_tag(pt_literal_name) + (nidx)) ?\
((pvslot) = (pds)->top_values + (htemp), 1) :\
0)\
)
#endif /* idstack_INCLUDED */
|
