Mercurial > ~dholland > hg > ag > index.cgi

comparison anagram/guisupport/charsdc.cpp @ 0:13d2b8934445

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import AnaGram (near-)release tree into Mercurial.
author David A. Holland
date Sat, 22 Dec 2007 17:52:45 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:13d2b8934445
1 /*
2 * AnaGram, A System for Syntax Directed Programming
3 * Copyright 1993-2000 Parsifal Software. All Rights Reserved.
4 * See the file COPYING for license and usage terms.
5 *
6 * charsdc.cpp - Character set display module
7 */
8
9 #include "arrays.h"
10 #include "charsdc.h"
11 #include "csexp.h"
12 #include "data.h"
13 #include "dc.h"
14 #include "dict.h"
15 #include "stacks.h"
16 #include "symbol.h"
17 #include "token.h"
18 #include "tree.h"
19 #include "ut.h"
20 #include "ws.h"
21
22 //#define INCLUDE_LOGGING
23 #include "log.h"
24
25
26 #define PURE_MARKER '%'
27
28 static int partition_set_tabs[] = {5,0};
29
30 static void part_set_display(int pn) {
31 int tn = map_part_number[pn].token_number;
32 token_number_map *tp = &map_token_number[tn];
33 int name, tree;
34
35 ssprintf("P%03d\tT%03d", pn, tn);
36 if (tn == 0) {
37 return;
38 }
39 name = tp->token_name;
40 if (name) {
41 ass(": ");
42 //ass(dict_str(tkn_dict, name));
43 ass(Symbol(name)->string.pointer());
44 if (tp->pure) {
45 acs(PURE_MARKER);
46 }
47 return;
48 }
49 tree = tp->parse_tree;
50 if (tree) {
51 name = map_parse_tree[tree].token_name;
52 if (name) {
53 //ass(dict_str(tkn_dict,name));
54 ass(Symbol(name)->string.pointer());
55 if (tp->pure) {
56 acs(PURE_MARKER);
57 }
58 }
59 }
60 }
61
62 static int part_set_window_ok(int pn) {
63 return pn > 0 && (unsigned)pn < part_dict->nsx;
64 }
65
66 dc_ref part_set_window(int pn){
67 unsigned *list = lstptr(map_part_number[pn], chars);
68 dc_ref window;
69
70 AgString foot = AgString::format("P%03d", pn);
71 //window = find_on_screen("Set Elements", foot);
72 //if (window.exists()) return window;
73 return dc_ref(new set_elements_dc(list,
74 map_part_number[pn].size,foot.pointer()));
75 }
76
77
78 static int char_map_tabs[] = {5,8,14,0};
79
80 char_map_dc::char_map_dc(void)
81 : dc("Character Map")
82 {
83 tab_stops = char_map_tabs;
84 columnHeadTitle = "Code\tChar\tSet\tToken";
85 //des->c_size = cursor_bar_size;
86 des->d_size.y = n_chars;
87 //getWidth();
88 //resize_window();
89 }
90
91 //extern int ersatz_tab;
92
93 void char_map_dc::getLine(unsigned ln) const {
94 LOGSECTION("char_map_dc::getLine");
95 char_number_map cm = map_char_number[ln];
96 int name = map_char_number[ln].token_name;
97 int tn = cm.token_number;
98 extern int min_char_number;
99 int ch = ln + min_char_number;
100 int c = ch > 0 && ch < 255 ? ch : 32;
101
102 LOGV(tn) LCV(name);
103 LOGV(ch) LCV(c) LCV(cm.part_number);
104 //ersatz_tab = 255;
105 if (c == '\t') {
106 c = 255;
107 }
108 ssprintf("%3d\t%c\tP%03d\tT%03d", ch, c, cm.part_number, tn);
109 if (tn) {
110 ass(": ");
111 atkn(tn);
112 return;
113 }
114 if (name) {
115 apprintf(" %s", Symbol(name)->string.pointer());
116 //apprintf(" %s", dict_str(tkn_dict, name));
117 apprintf(" %s", Symbol(name)->string.pointer());
118 }
119 }
120
121 int char_map_dc::set_elements_ok(unsigned ln) {
122 return part_set_window_ok(map_char_number[ln].part_number);
123 }
124
125 dc_ref char_map_dc:: set_elements(unsigned ln) {
126 return part_set_window(map_char_number[ln].part_number);
127 }
128
129 int char_map_dc::usage_ok(unsigned ln) {
130 return token_usage_window_ok(map_char_number[ln].token_number);
131 }
132
133 dc_ref char_map_dc::usage(unsigned ln) {
134 return token_usage_window(map_char_number[ln].token_number);
135 }
136
137 static int char_set_tabs[] = {6,12, 0};
138
139 void char_set_dc::getLine(unsigned ln) const {
140 int pt;
141 int tn;
142 int name;
143
144 ln++;
145 ssprintf("C%03d:\t",ln);
146 pt = map_char_set[ln].parse_tree;
147 tn = map_parse_tree[pt].token_number;
148 if (tn) {
149 apprintf("T%03d:\t",tn);
150 name = map_token_number[tn].token_name;
151 }
152 else {
153 acs('\t');
154 name = map_parse_tree[pt].token_name;
155 }
156 if (name) {
157 //apprintf("%s = ", dict_str(tkn_dict,name));
158 apprintf("%s = ", Symbol(name)->string.pointer());
159 }
160 //ass(node_string(map_parse_tree[pt].tree,4).pointer());
161 ass(map_parse_tree[pt].expression->asString().pointer());
162 }
163
164 char_set_dc::char_set_dc(void)
165 : dc("Character Sets")
166 {
167 //des->c_size = cursor_bar_size;
168 des->d_size.y = char_set_dict->nsx - 1;
169
170 tab_stops = char_set_tabs;
171 columnHeadTitle = "Set\tToken\tSet Representation";
172 //getWidth();
173 //resize_window();
174 }
175
176 int char_set_dc::set_elements_ok(unsigned ln) {
177 return char_set_window_ok(ln+1);
178 }
179
180 dc_ref char_set_dc::set_elements(unsigned ln) {
181 return char_set_window(ln+1);
182 }
183
184 dc_ref char_set_dc::partition_sets(unsigned ln) {
185 return new partition_set_dc(ln+1, AgString::format("C%03d", ln));
186 }
187
188 int char_set_dc::usage_ok(unsigned ln) {
189 int pt = map_char_set[ln+1].parse_tree;
190 return token_usage_window_ok(map_parse_tree[pt].token_number);
191 }
192
193 dc_ref char_set_dc::usage(unsigned ln) {
194 int pt = map_char_set[ln+1].parse_tree;
195 return token_usage_window(map_parse_tree[pt].token_number);
196 }
197
198
199 partition_set_dc::partition_set_dc(unsigned csn, const AgString foot)
200 : dc("Partition Sets", foot)
201 {
202 char_set_number = csn;
203 des->d_size.y = map_char_set[csn].nparts;
204
205 tab_stops = partition_set_tabs;
206 columnHeadTitle = "Set\tToken";
207 //getWidth();
208 //des->c_size = cursor_bar_size;
209 //resize_window();
210 }
211
212 void partition_set_dc::getLine(unsigned ln) const {
213 unsigned *parts = lstptr(map_char_set[char_set_number], part);
214 part_set_display(parts[ln]);
215 }
216
217 dc_ref partition_set_dc:: set_elements(unsigned ln) {
218 unsigned *parts = lstptr(map_char_set[char_set_number], part);
219 return part_set_window(parts[ln]);
220 }
221
222
223 int partition_set_dc::usage_ok(unsigned ln) {
224 unsigned *parts = lstptr(map_char_set[char_set_number], part);
225 return token_usage_window_ok(map_part_number[parts[ln]].token_number);
226 }
227
228 dc_ref partition_set_dc::usage(unsigned ln) {
229 unsigned *parts = lstptr(map_char_set[char_set_number], part);
230 return token_usage_window(map_part_number[parts[ln]].token_number);
231 }
232
233 void partition_table_dc::getLine(unsigned ln) const {
234 part_set_display(ln);
235 }
236
237 partition_table_dc::partition_table_dc(void)
238 : dc("Partition Sets")
239 {
240 //des->c_size = cursor_bar_size;
241 des->d_size.y = part_dict->nsx;
242
243 tab_stops = partition_set_tabs;
244 columnHeadTitle = "Set\tToken";
245 //getWidth();
246 //resize_window();
247 }
248
249 dc_ref partition_table_dc::set_elements(unsigned ln) {
250 return part_set_window(ln);
251 }
252
253 int partition_table_dc::usage_ok(unsigned ln) {
254 return token_usage_window_ok(map_part_number[ln].token_number);
255 }
256
257 dc_ref partition_table_dc::usage(unsigned ln) {
258 return token_usage_window(map_part_number[ln].token_number);
259 }
260
261 static int set_elements_tabs[] = {5,0};
262 void set_elements_dc::getLine(unsigned ln) const {
263 int ch = list[ln];
264 int c = ch > 0 && ch < 255 ? ch : 32;
265 ssprintf("%3d\t%c", ch, c);
266 }
267
268 set_elements_dc::set_elements_dc(unsigned *l, unsigned n, char *foot)
269 : dc("Set Elements", foot)
270 {
271 list = l;
272 tab_stops = set_elements_tabs;
273 columnHeadTitle = "No.\tCharacter";
274 //des->c_size = cursor_bar_size;
275 des->d_size.y = n;
276 //getWidth();
277 //resize_window();
278 }
279
280