File: | src/lib/libcurses/tinfo/parse_entry.c |
Warning: | line 777, column 8 Value stored to 'base' during its initialization is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: parse_entry.c,v 1.13 2010/01/12 23:22:06 nicm Exp $ */ |
2 | |
3 | /**************************************************************************** |
4 | * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. * |
5 | * * |
6 | * Permission is hereby granted, free of charge, to any person obtaining a * |
7 | * copy of this software and associated documentation files (the * |
8 | * "Software"), to deal in the Software without restriction, including * |
9 | * without limitation the rights to use, copy, modify, merge, publish, * |
10 | * distribute, distribute with modifications, sublicense, and/or sell * |
11 | * copies of the Software, and to permit persons to whom the Software is * |
12 | * furnished to do so, subject to the following conditions: * |
13 | * * |
14 | * The above copyright notice and this permission notice shall be included * |
15 | * in all copies or substantial portions of the Software. * |
16 | * * |
17 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * |
18 | * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * |
19 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * |
20 | * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * |
21 | * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * |
22 | * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * |
23 | * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * |
24 | * * |
25 | * Except as contained in this notice, the name(s) of the above copyright * |
26 | * holders shall not be used in advertising or otherwise to promote the * |
27 | * sale, use or other dealings in this Software without prior written * |
28 | * authorization. * |
29 | ****************************************************************************/ |
30 | |
31 | /**************************************************************************** |
32 | * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * |
33 | * and: Eric S. Raymond <esr@snark.thyrsus.com> * |
34 | * and: Thomas E. Dickey 1996-on * |
35 | ****************************************************************************/ |
36 | |
37 | /* |
38 | * parse_entry.c -- compile one terminfo or termcap entry |
39 | * |
40 | * Get an exact in-core representation of an entry. Don't |
41 | * try to resolve use or tc capabilities, that is someone |
42 | * else's job. Depends on the lexical analyzer to get tokens |
43 | * from the input stream. |
44 | */ |
45 | |
46 | #define __INTERNAL_CAPS_VISIBLE |
47 | #include <curses.priv.h> |
48 | |
49 | #include <ctype.h> |
50 | #include <tic.h> |
51 | #include <term_entry.h> |
52 | |
53 | MODULE_ID("$Id: parse_entry.c,v 1.13 2010/01/12 23:22:06 nicm Exp $") |
54 | |
55 | #ifdef LINT |
56 | static short const parametrized[] = |
57 | {0}; |
58 | #else |
59 | #include <parametrized.h> |
60 | #endif |
61 | |
62 | static void postprocess_termcap(TERMTYPE *, bool_Bool); |
63 | static void postprocess_terminfo(TERMTYPE *); |
64 | static struct name_table_entry const *lookup_fullname(const char *name); |
65 | |
66 | #if NCURSES_XNAMES1 |
67 | |
68 | static struct name_table_entry const * |
69 | _nc_extend_names(ENTRY * entryp, char *name, int token_type) |
70 | { |
71 | static struct name_table_entry temp; |
72 | TERMTYPE *tp = &(entryp->tterm); |
73 | unsigned offset = 0; |
74 | unsigned actual; |
75 | unsigned tindex; |
76 | unsigned first, last, n; |
77 | bool_Bool found; |
78 | |
79 | switch (token_type) { |
80 | case BOOLEAN0: |
81 | first = 0; |
82 | last = tp->ext_Booleans; |
83 | offset = tp->ext_Booleans; |
84 | tindex = tp->num_Booleans; |
85 | break; |
86 | case NUMBER1: |
87 | first = tp->ext_Booleans; |
88 | last = tp->ext_Numbers + first; |
89 | offset = tp->ext_Booleans + tp->ext_Numbers; |
90 | tindex = tp->num_Numbers; |
91 | break; |
92 | case STRING2: |
93 | first = tp->ext_Booleans + tp->ext_Numbers; |
94 | last = tp->ext_Strings + first; |
95 | offset = tp->ext_Booleans + tp->ext_Numbers + tp->ext_Strings; |
96 | tindex = tp->num_Strings; |
97 | break; |
98 | case CANCEL3: |
99 | actual = NUM_EXT_NAMES(tp)((tp)->ext_Booleans + (tp)->ext_Numbers + (tp)->ext_Strings ); |
100 | for (n = 0; n < actual; n++) { |
101 | if (!strcmp(name, tp->ext_Names[n])) { |
102 | if (n > (unsigned) (tp->ext_Booleans + tp->ext_Numbers)) { |
103 | token_type = STRING2; |
104 | } else if (n > tp->ext_Booleans) { |
105 | token_type = NUMBER1; |
106 | } else { |
107 | token_type = BOOLEAN0; |
108 | } |
109 | return _nc_extend_names(entryp, name, token_type); |
110 | } |
111 | } |
112 | /* Well, we are given a cancel for a name that we don't recognize */ |
113 | return _nc_extend_names(entryp, name, STRING2); |
114 | default: |
115 | return 0; |
116 | } |
117 | |
118 | /* Adjust the 'offset' (insertion-point) to keep the lists of extended |
119 | * names sorted. |
120 | */ |
121 | for (n = first, found = FALSE0; n < last; n++) { |
122 | int cmp = strcmp(tp->ext_Names[n], name); |
123 | if (cmp == 0) |
124 | found = TRUE1; |
125 | if (cmp >= 0) { |
126 | offset = n; |
127 | tindex = n - first; |
128 | switch (token_type) { |
129 | case BOOLEAN0: |
130 | tindex += BOOLCOUNT44; |
131 | break; |
132 | case NUMBER1: |
133 | tindex += NUMCOUNT39; |
134 | break; |
135 | case STRING2: |
136 | tindex += STRCOUNT414; |
137 | break; |
138 | } |
139 | break; |
140 | } |
141 | } |
142 | if (!found) { |
143 | switch (token_type) { |
144 | case BOOLEAN0: |
145 | tp->ext_Booleans += 1; |
146 | tp->num_Booleans += 1; |
147 | tp->Booleans = typeRealloc(NCURSES_SBOOL, tp->num_Booleans, tp->Booleans)(signed char *)_nc_doalloc(tp->Booleans, (tp->num_Booleans )*sizeof(signed char)); |
148 | for (last = tp->num_Booleans - 1; last > tindex; last--) |
149 | tp->Booleans[last] = tp->Booleans[last - 1]; |
150 | break; |
151 | case NUMBER1: |
152 | tp->ext_Numbers += 1; |
153 | tp->num_Numbers += 1; |
154 | tp->Numbers = typeRealloc(short, tp->num_Numbers, tp->Numbers)(short *)_nc_doalloc(tp->Numbers, (tp->num_Numbers)*sizeof (short)); |
155 | for (last = tp->num_Numbers - 1; last > tindex; last--) |
156 | tp->Numbers[last] = tp->Numbers[last - 1]; |
157 | break; |
158 | case STRING2: |
159 | tp->ext_Strings += 1; |
160 | tp->num_Strings += 1; |
161 | tp->Strings = typeRealloc(char *, tp->num_Strings, tp->Strings)(char * *)_nc_doalloc(tp->Strings, (tp->num_Strings)*sizeof (char *)); |
162 | for (last = tp->num_Strings - 1; last > tindex; last--) |
163 | tp->Strings[last] = tp->Strings[last - 1]; |
164 | break; |
165 | } |
166 | actual = NUM_EXT_NAMES(tp)((tp)->ext_Booleans + (tp)->ext_Numbers + (tp)->ext_Strings ); |
167 | tp->ext_Names = typeRealloc(char *, actual, tp->ext_Names)(char * *)_nc_doalloc(tp->ext_Names, (actual)*sizeof(char * )); |
168 | while (--actual > offset) |
169 | tp->ext_Names[actual] = tp->ext_Names[actual - 1]; |
170 | tp->ext_Names[offset] = _nc_save_str(name); |
171 | } |
172 | |
173 | temp.nte_name = tp->ext_Names[offset]; |
174 | temp.nte_type = token_type; |
175 | temp.nte_index = tindex; |
176 | temp.nte_link = -1; |
177 | |
178 | return &temp; |
179 | } |
180 | #endif /* NCURSES_XNAMES */ |
181 | |
182 | /* |
183 | * int |
184 | * _nc_parse_entry(entry, literal, silent) |
185 | * |
186 | * Compile one entry. Doesn't try to resolve use or tc capabilities. |
187 | * |
188 | * found-forward-use = FALSE |
189 | * re-initialise internal arrays |
190 | * get_token(); |
191 | * if the token was not a name in column 1, complain and die |
192 | * save names in entry's string table |
193 | * while (get_token() is not EOF and not NAMES) |
194 | * check for existence and type-correctness |
195 | * enter cap into structure |
196 | * if STRING |
197 | * save string in entry's string table |
198 | * push back token |
199 | */ |
200 | |
201 | #define BAD_TC_USAGEif (!bad_tc_usage) { bad_tc_usage = 1; _nc_warning("Legacy termcap allows only a trailing tc= clause" ); } if (!bad_tc_usage) \ |
202 | { bad_tc_usage = TRUE1; \ |
203 | _nc_warning("Legacy termcap allows only a trailing tc= clause"); } |
204 | |
205 | NCURSES_EXPORT(int)int |
206 | _nc_parse_entry(struct entry *entryp, int literal, bool_Bool silent) |
207 | { |
208 | int token_type; |
209 | struct name_table_entry const *entry_ptr; |
210 | char *ptr, *base; |
211 | bool_Bool bad_tc_usage = FALSE0; |
212 | |
213 | token_type = _nc_get_token(silent); |
214 | |
215 | if (token_type == EOF(-1)) |
216 | return (EOF(-1)); |
217 | if (token_type != NAMES4) |
218 | _nc_err_abort("Entry does not start with terminal names in column one"); |
219 | |
220 | _nc_init_entry(&entryp->tterm); |
221 | |
222 | entryp->cstart = _nc_comment_start; |
223 | entryp->cend = _nc_comment_end; |
224 | entryp->startline = _nc_start_line; |
225 | DEBUG(2, ("Comment range is %ld to %ld", entryp->cstart, entryp->cend)); |
226 | |
227 | /* |
228 | * Strip off the 2-character termcap name, if present. Originally termcap |
229 | * used that as an indexing aid. We can retain 2-character terminfo names, |
230 | * but note that they would be lost if we translate to/from termcap. This |
231 | * feature is supposedly obsolete since "newer" BSD implementations do not |
232 | * use it; however our reference for this feature is SunOS 4.x, which |
233 | * implemented it. Note that the resulting terminal type was never the |
234 | * 2-character name, but was instead the first alias after that. |
235 | */ |
236 | ptr = _nc_curr_token.tk_name; |
237 | if (_nc_syntax == SYN_TERMCAP1 |
238 | #if NCURSES_XNAMES1 |
239 | && !_nc_user_definable |
240 | #endif |
241 | ) { |
242 | if (ptr[2] == '|') { |
243 | ptr += 3; |
244 | _nc_curr_token.tk_name[2] = '\0'; |
245 | } |
246 | } |
247 | |
248 | entryp->tterm.str_table = entryp->tterm.term_names = _nc_save_str(ptr); |
249 | |
250 | if (entryp->tterm.str_table == 0) |
251 | return (ERR(-1)); |
252 | |
253 | DEBUG(1, ("Starting '%s'", ptr)); |
254 | |
255 | /* |
256 | * We do this because the one-token lookahead in the parse loop |
257 | * results in the terminal type getting prematurely set to correspond |
258 | * to that of the next entry. |
259 | */ |
260 | _nc_set_type(_nc_first_name(entryp->tterm.term_names)); |
261 | |
262 | /* check for overly-long names and aliases */ |
263 | for (base = entryp->tterm.term_names; (ptr = strchr(base, '|')) != 0; |
264 | base = ptr + 1) { |
265 | if (ptr - base > MAX_ALIAS32) { |
266 | _nc_warning("%s `%.*s' may be too long", |
267 | (base == entryp->tterm.term_names) |
268 | ? "primary name" |
269 | : "alias", |
270 | (int) (ptr - base), base); |
271 | } |
272 | } |
273 | |
274 | entryp->nuses = 0; |
275 | |
276 | for (token_type = _nc_get_token(silent); |
277 | token_type != EOF(-1) && token_type != NAMES4; |
278 | token_type = _nc_get_token(silent)) { |
279 | bool_Bool is_use = (strcmp(_nc_curr_token.tk_name, "use") == 0); |
280 | bool_Bool is_tc = !is_use && (strcmp(_nc_curr_token.tk_name, "tc") == 0); |
281 | if (is_use || is_tc) { |
282 | entryp->uses[entryp->nuses].name = _nc_save_str(_nc_curr_token.tk_valstring); |
283 | entryp->uses[entryp->nuses].line = _nc_curr_line; |
284 | entryp->nuses++; |
285 | if (entryp->nuses > 1 && is_tc) { |
286 | BAD_TC_USAGEif (!bad_tc_usage) { bad_tc_usage = 1; _nc_warning("Legacy termcap allows only a trailing tc= clause" ); } |
287 | } |
288 | } else { |
289 | /* normal token lookup */ |
290 | entry_ptr = _nc_find_entry(_nc_curr_token.tk_name, |
291 | _nc_get_hash_table(_nc_syntax)); |
292 | |
293 | /* |
294 | * Our kluge to handle aliasing. The reason it's done |
295 | * this ugly way, with a linear search, is so the hashing |
296 | * machinery doesn't have to be made really complicated |
297 | * (also we get better warnings this way). No point in |
298 | * making this case fast, aliased caps aren't common now |
299 | * and will get rarer. |
300 | */ |
301 | if (entry_ptr == NOTFOUND((struct name_table_entry *) 0)) { |
302 | const struct alias *ap; |
303 | |
304 | if (_nc_syntax == SYN_TERMCAP1) { |
305 | if (entryp->nuses != 0) { |
306 | BAD_TC_USAGEif (!bad_tc_usage) { bad_tc_usage = 1; _nc_warning("Legacy termcap allows only a trailing tc= clause" ); } |
307 | } |
308 | for (ap = _nc_get_alias_table(TRUE1); ap->from; ap++) |
309 | if (strcmp(ap->from, _nc_curr_token.tk_name) == 0) { |
310 | if (ap->to == (char *) 0) { |
311 | _nc_warning("%s (%s termcap extension) ignored", |
312 | ap->from, ap->source); |
313 | goto nexttok; |
314 | } |
315 | |
316 | entry_ptr = _nc_find_entry(ap->to, |
317 | _nc_get_hash_table(TRUE1)); |
318 | if (entry_ptr && !silent) |
319 | _nc_warning("%s (%s termcap extension) aliased to %s", |
320 | ap->from, ap->source, ap->to); |
321 | break; |
322 | } |
323 | } else { /* if (_nc_syntax == SYN_TERMINFO) */ |
324 | for (ap = _nc_get_alias_table(FALSE0); ap->from; ap++) |
325 | if (strcmp(ap->from, _nc_curr_token.tk_name) == 0) { |
326 | if (ap->to == (char *) 0) { |
327 | _nc_warning("%s (%s terminfo extension) ignored", |
328 | ap->from, ap->source); |
329 | goto nexttok; |
330 | } |
331 | |
332 | entry_ptr = _nc_find_entry(ap->to, |
333 | _nc_get_hash_table(FALSE0)); |
334 | if (entry_ptr && !silent) |
335 | _nc_warning("%s (%s terminfo extension) aliased to %s", |
336 | ap->from, ap->source, ap->to); |
337 | break; |
338 | } |
339 | |
340 | if (entry_ptr == NOTFOUND((struct name_table_entry *) 0)) { |
341 | entry_ptr = lookup_fullname(_nc_curr_token.tk_name); |
342 | } |
343 | } |
344 | } |
345 | #if NCURSES_XNAMES1 |
346 | /* |
347 | * If we have extended-names active, we will automatically |
348 | * define a name based on its context. |
349 | */ |
350 | if (entry_ptr == NOTFOUND((struct name_table_entry *) 0) |
351 | && _nc_user_definable |
352 | && (entry_ptr = _nc_extend_names(entryp, |
353 | _nc_curr_token.tk_name, |
354 | token_type)) != 0) { |
355 | if (_nc_tracing >= DEBUG_LEVEL(1)((1) << 13)) |
356 | _nc_warning("extended capability '%s'", _nc_curr_token.tk_name); |
357 | } |
358 | #endif /* NCURSES_XNAMES */ |
359 | |
360 | /* can't find this cap name, not even as an alias */ |
361 | if (entry_ptr == NOTFOUND((struct name_table_entry *) 0)) { |
362 | if (!silent) |
363 | _nc_warning("unknown capability '%s'", |
364 | _nc_curr_token.tk_name); |
365 | continue; |
366 | } |
367 | |
368 | /* deal with bad type/value combinations. */ |
369 | if (token_type != CANCEL3 && entry_ptr->nte_type != token_type) { |
370 | /* |
371 | * Nasty special cases here handle situations in which type |
372 | * information can resolve name clashes. Normal lookup |
373 | * finds the last instance in the capability table of a |
374 | * given name, regardless of type. find_type_entry looks |
375 | * for a first matching instance with given type. So as |
376 | * long as all ambiguous names occur in pairs of distinct |
377 | * type, this will do the job. |
378 | */ |
379 | |
380 | if (token_type == NUMBER1 |
381 | && !strcmp("ma", _nc_curr_token.tk_name)) { |
382 | /* tell max_attributes from arrow_key_map */ |
383 | entry_ptr = _nc_find_type_entry("ma", NUMBER1, |
384 | _nc_get_table(_nc_syntax |
385 | != 0)); |
386 | assert(entry_ptr != 0)((void)0); |
387 | |
388 | } else if (token_type == STRING2 |
389 | && !strcmp("MT", _nc_curr_token.tk_name)) { |
390 | /* map terminfo's string MT to MT */ |
391 | entry_ptr = _nc_find_type_entry("MT", STRING2, |
392 | _nc_get_table(_nc_syntax |
393 | != 0)); |
394 | assert(entry_ptr != 0)((void)0); |
395 | |
396 | } else if (token_type == BOOLEAN0 |
397 | && entry_ptr->nte_type == STRING2) { |
398 | /* treat strings without following "=" as empty strings */ |
399 | token_type = STRING2; |
400 | } else { |
401 | /* we couldn't recover; skip this token */ |
402 | if (!silent) { |
403 | const char *type_name; |
404 | switch (entry_ptr->nte_type) { |
405 | case BOOLEAN0: |
406 | type_name = "boolean"; |
407 | break; |
408 | case STRING2: |
409 | type_name = "string"; |
410 | break; |
411 | case NUMBER1: |
412 | type_name = "numeric"; |
413 | break; |
414 | default: |
415 | type_name = "unknown"; |
416 | break; |
417 | } |
418 | _nc_warning("wrong type used for %s capability '%s'", |
419 | type_name, _nc_curr_token.tk_name); |
420 | } |
421 | continue; |
422 | } |
423 | } |
424 | |
425 | /* now we know that the type/value combination is OK */ |
426 | switch (token_type) { |
427 | case CANCEL3: |
428 | switch (entry_ptr->nte_type) { |
429 | case BOOLEAN0: |
430 | entryp->tterm.Booleans[entry_ptr->nte_index] = CANCELLED_BOOLEAN((signed char)-2); |
431 | break; |
432 | |
433 | case NUMBER1: |
434 | entryp->tterm.Numbers[entry_ptr->nte_index] = CANCELLED_NUMERIC(-2); |
435 | break; |
436 | |
437 | case STRING2: |
438 | entryp->tterm.Strings[entry_ptr->nte_index] = CANCELLED_STRING(char *)(-1); |
439 | break; |
440 | } |
441 | break; |
442 | |
443 | case BOOLEAN0: |
444 | entryp->tterm.Booleans[entry_ptr->nte_index] = TRUE1; |
445 | break; |
446 | |
447 | case NUMBER1: |
448 | entryp->tterm.Numbers[entry_ptr->nte_index] = |
449 | _nc_curr_token.tk_valnumber; |
450 | break; |
451 | |
452 | case STRING2: |
453 | ptr = _nc_curr_token.tk_valstring; |
454 | if (_nc_syntax == SYN_TERMCAP1) |
455 | ptr = _nc_captoinfo(_nc_curr_token.tk_name, |
456 | ptr, |
457 | parametrized[entry_ptr->nte_index]); |
458 | entryp->tterm.Strings[entry_ptr->nte_index] = _nc_save_str(ptr); |
459 | break; |
460 | |
461 | default: |
462 | if (!silent) |
463 | _nc_warning("unknown token type"); |
464 | _nc_panic_mode((char) ((_nc_syntax == SYN_TERMCAP1) ? ':' : ',')); |
465 | continue; |
466 | } |
467 | } /* end else cur_token.name != "use" */ |
468 | nexttok: |
469 | continue; /* cannot have a label w/o statement */ |
470 | } /* endwhile (not EOF and not NAMES) */ |
471 | |
472 | _nc_push_token(token_type); |
473 | _nc_set_type(_nc_first_name(entryp->tterm.term_names)); |
474 | |
475 | /* |
476 | * Try to deduce as much as possible from extension capabilities |
477 | * (this includes obsolete BSD capabilities). Sigh...it would be more |
478 | * space-efficient to call this after use resolution, but it has |
479 | * to be done before entry allocation is wrapped up. |
480 | */ |
481 | if (!literal) { |
482 | if (_nc_syntax == SYN_TERMCAP1) { |
483 | bool_Bool has_base_entry = FALSE0; |
484 | unsigned i; |
485 | |
486 | /* |
487 | * Don't insert defaults if this is a `+' entry meant only |
488 | * for inclusion in other entries (not sure termcap ever |
489 | * had these, actually). |
490 | */ |
491 | if (strchr(entryp->tterm.term_names, '+')) |
492 | has_base_entry = TRUE1; |
493 | else |
494 | /* |
495 | * Otherwise, look for a base entry that will already |
496 | * have picked up defaults via translation. |
497 | */ |
498 | for (i = 0; i < entryp->nuses; i++) |
499 | if (!strchr((char *) entryp->uses[i].name, '+')) |
500 | has_base_entry = TRUE1; |
501 | |
502 | postprocess_termcap(&entryp->tterm, has_base_entry); |
503 | } else |
504 | postprocess_terminfo(&entryp->tterm); |
505 | } |
506 | _nc_wrap_entry(entryp, FALSE0); |
507 | |
508 | return (OK(0)); |
509 | } |
510 | |
511 | NCURSES_EXPORT(int)int |
512 | _nc_capcmp(const char *s, const char *t) |
513 | /* compare two string capabilities, stripping out padding */ |
514 | { |
515 | if (!s && !t) |
516 | return (0); |
517 | else if (!s || !t) |
518 | return (1); |
519 | |
520 | for (;;) { |
521 | if (s[0] == '$' && s[1] == '<') { |
522 | for (s += 2;; s++) |
523 | if (!(isdigit(UChar(*s)((unsigned char)(*s))) |
524 | || *s == '.' |
525 | || *s == '*' |
526 | || *s == '/' |
527 | || *s == '>')) |
528 | break; |
529 | } |
530 | |
531 | if (t[0] == '$' && t[1] == '<') { |
532 | for (t += 2;; t++) |
533 | if (!(isdigit(UChar(*t)((unsigned char)(*t))) |
534 | || *t == '.' |
535 | || *t == '*' |
536 | || *t == '/' |
537 | || *t == '>')) |
538 | break; |
539 | } |
540 | |
541 | /* we've now pushed s and t past any padding they were pointing at */ |
542 | |
543 | if (*s == '\0' && *t == '\0') |
544 | return (0); |
545 | |
546 | if (*s != *t) |
547 | return (*t - *s); |
548 | |
549 | /* else *s == *t but one is not NUL, so continue */ |
550 | s++, t++; |
551 | } |
552 | } |
553 | |
554 | static void |
555 | append_acs0(string_desc * dst, int code, int src) |
556 | { |
557 | if (src != 0) { |
558 | char temp[3]; |
559 | temp[0] = (char) code; |
560 | temp[1] = (char) src; |
561 | temp[2] = 0; |
562 | _nc_safe_strcat(dst, temp); |
563 | } |
564 | } |
565 | |
566 | static void |
567 | append_acs(string_desc * dst, int code, char *src) |
568 | { |
569 | if (src != 0 && strlen(src) == 1) { |
570 | append_acs0(dst, code, *src); |
571 | } |
572 | } |
573 | |
574 | /* |
575 | * The ko capability, if present, consists of a comma-separated capability |
576 | * list. For each capability, we may assume there is a keycap that sends the |
577 | * string which is the value of that capability. |
578 | */ |
579 | typedef struct { |
580 | const char *from; |
581 | const char *to; |
582 | } assoc; |
583 | static assoc const ko_xlate[] = |
584 | { |
585 | {"al", "kil1"}, /* insert line key -> KEY_IL */ |
586 | {"bt", "kcbt"}, /* back tab -> KEY_BTAB */ |
587 | {"cd", "ked"}, /* clear-to-eos key -> KEY_EOL */ |
588 | {"ce", "kel"}, /* clear-to-eol key -> KEY_EOS */ |
589 | {"cl", "kclr"}, /* clear key -> KEY_CLEAR */ |
590 | {"ct", "tbc"}, /* clear all tabs -> KEY_CATAB */ |
591 | {"dc", "kdch1"}, /* delete char -> KEY_DC */ |
592 | {"dl", "kdl1"}, /* delete line -> KEY_DL */ |
593 | {"do", "kcud1"}, /* down key -> KEY_DOWN */ |
594 | {"ei", "krmir"}, /* exit insert key -> KEY_EIC */ |
595 | {"ho", "khome"}, /* home key -> KEY_HOME */ |
596 | {"ic", "kich1"}, /* insert char key -> KEY_IC */ |
597 | {"im", "kIC"}, /* insert-mode key -> KEY_SIC */ |
598 | {"le", "kcub1"}, /* le key -> KEY_LEFT */ |
599 | {"nd", "kcuf1"}, /* nd key -> KEY_RIGHT */ |
600 | {"nl", "kent"}, /* new line key -> KEY_ENTER */ |
601 | {"st", "khts"}, /* set-tab key -> KEY_STAB */ |
602 | {"ta", CANCELLED_STRING(char *)(-1)}, |
603 | {"up", "kcuu1"}, /* up-arrow key -> KEY_UP */ |
604 | {(char *) 0, (char *) 0}, |
605 | }; |
606 | |
607 | /* |
608 | * This routine fills in string caps that either had defaults under |
609 | * termcap or can be manufactured from obsolete termcap capabilities. |
610 | * It was lifted from Ross Ridge's mytinfo package. |
611 | */ |
612 | |
613 | static const char C_CR[] = "\r"; |
614 | static const char C_LF[] = "\n"; |
615 | static const char C_BS[] = "\b"; |
616 | static const char C_HT[] = "\t"; |
617 | |
618 | /* |
619 | * Note that WANTED and PRESENT are not simple inverses! If a capability |
620 | * has been explicitly cancelled, it's not considered WANTED. |
621 | */ |
622 | #define WANTED(s)((s) == (char *)0) ((s) == ABSENT_STRING(char *)0) |
623 | #define PRESENT(s)(((s) != (char *)0) && ((s) != (char *)(-1))) (((s) != ABSENT_STRING(char *)0) && ((s) != CANCELLED_STRING(char *)(-1))) |
624 | |
625 | /* |
626 | * This bit of legerdemain turns all the terminfo variable names into |
627 | * references to locations in the arrays Booleans, Numbers, and Strings --- |
628 | * precisely what's needed. |
629 | */ |
630 | |
631 | #undef CURtp-> |
632 | #define CURtp-> tp-> |
633 | |
634 | static void |
635 | postprocess_termcap(TERMTYPE *tp, bool_Bool has_base) |
636 | { |
637 | char buf[MAX_LINE132 * 2 + 2]; |
638 | string_desc result; |
639 | |
640 | /* |
641 | * TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS |
642 | * |
643 | * This first part of the code is the functional inverse of the |
644 | * fragment in capdefaults.c. |
645 | * ---------------------------------------------------------------------- |
646 | */ |
647 | |
648 | /* if there was a tc entry, assume we picked up defaults via that */ |
649 | if (!has_base) { |
650 | if (WANTED(init_3string)((tp-> Strings[50]) == (char *)0) && termcap_init2tp-> Strings[394]) |
651 | init_3stringtp-> Strings[50] = _nc_save_str(termcap_init2tp-> Strings[394]); |
652 | |
653 | if (WANTED(reset_2string)((tp-> Strings[123]) == (char *)0) && termcap_resettp-> Strings[395]) |
654 | reset_2stringtp-> Strings[123] = _nc_save_str(termcap_resettp-> Strings[395]); |
655 | |
656 | if (WANTED(carriage_return)((tp-> Strings[2]) == (char *)0)) { |
657 | if (carriage_return_delaytp-> Numbers[34] > 0) { |
658 | snprintf(buf, sizeof(buf), "%s$<%d>", C_CR, carriage_return_delaytp-> Numbers[34]); |
659 | carriage_returntp-> Strings[2] = _nc_save_str(buf); |
660 | } else |
661 | carriage_returntp-> Strings[2] = _nc_save_str(C_CR); |
662 | } |
663 | if (WANTED(cursor_left)((tp-> Strings[14]) == (char *)0)) { |
664 | if (backspace_delaytp-> Numbers[36] > 0) { |
665 | snprintf(buf, sizeof(buf), "%s$<%d>", C_BS, backspace_delaytp-> Numbers[36]); |
666 | cursor_lefttp-> Strings[14] = _nc_save_str(buf); |
667 | } else if (backspaces_with_bstp-> Booleans[37] == 1) |
668 | cursor_lefttp-> Strings[14] = _nc_save_str(C_BS); |
669 | else if (PRESENT(backspace_if_not_bs)(((tp-> Strings[397]) != (char *)0) && ((tp-> Strings [397]) != (char *)(-1)))) |
670 | cursor_lefttp-> Strings[14] = backspace_if_not_bstp-> Strings[397]; |
671 | } |
672 | /* vi doesn't use "do", but it does seems to use nl (or '\n') instead */ |
673 | if (WANTED(cursor_down)((tp-> Strings[11]) == (char *)0)) { |
674 | if (PRESENT(linefeed_if_not_lf)(((tp-> Strings[396]) != (char *)0) && ((tp-> Strings [396]) != (char *)(-1)))) |
675 | cursor_downtp-> Strings[11] = linefeed_if_not_lftp-> Strings[396]; |
676 | else if (linefeed_is_newlinetp-> Booleans[41] != 1) { |
677 | if (new_line_delaytp-> Numbers[35] > 0) { |
678 | snprintf(buf, sizeof(buf), "%s$<%d>", C_LF, new_line_delaytp-> Numbers[35]); |
679 | cursor_downtp-> Strings[11] = _nc_save_str(buf); |
680 | } else |
681 | cursor_downtp-> Strings[11] = _nc_save_str(C_LF); |
682 | } |
683 | } |
684 | if (WANTED(scroll_forward)((tp-> Strings[129]) == (char *)0) && crt_no_scrollingtp-> Booleans[38] != 1) { |
685 | if (PRESENT(linefeed_if_not_lf)(((tp-> Strings[396]) != (char *)0) && ((tp-> Strings [396]) != (char *)(-1)))) |
686 | cursor_downtp-> Strings[11] = linefeed_if_not_lftp-> Strings[396]; |
687 | else if (linefeed_is_newlinetp-> Booleans[41] != 1) { |
688 | if (new_line_delaytp-> Numbers[35] > 0) { |
689 | snprintf(buf, sizeof(buf), "%s$<%d>", C_LF, new_line_delaytp-> Numbers[35]); |
690 | scroll_forwardtp-> Strings[129] = _nc_save_str(buf); |
691 | } else |
692 | scroll_forwardtp-> Strings[129] = _nc_save_str(C_LF); |
693 | } |
694 | } |
695 | if (WANTED(newline)((tp-> Strings[103]) == (char *)0)) { |
696 | if (linefeed_is_newlinetp-> Booleans[41] == 1) { |
697 | if (new_line_delaytp-> Numbers[35] > 0) { |
698 | snprintf(buf, sizeof(buf), "%s$<%d>", C_LF, new_line_delaytp-> Numbers[35]); |
699 | newlinetp-> Strings[103] = _nc_save_str(buf); |
700 | } else |
701 | newlinetp-> Strings[103] = _nc_save_str(C_LF); |
702 | } else if (PRESENT(carriage_return)(((tp-> Strings[2]) != (char *)0) && ((tp-> Strings [2]) != (char *)(-1))) && PRESENT(scroll_forward)(((tp-> Strings[129]) != (char *)0) && ((tp-> Strings [129]) != (char *)(-1)))) { |
703 | _nc_str_init(&result, buf, sizeof(buf)); |
704 | if (_nc_safe_strcat(&result, carriage_returntp-> Strings[2]) |
705 | && _nc_safe_strcat(&result, scroll_forwardtp-> Strings[129])) |
706 | newlinetp-> Strings[103] = _nc_save_str(buf); |
707 | } else if (PRESENT(carriage_return)(((tp-> Strings[2]) != (char *)0) && ((tp-> Strings [2]) != (char *)(-1))) && PRESENT(cursor_down)(((tp-> Strings[11]) != (char *)0) && ((tp-> Strings [11]) != (char *)(-1)))) { |
708 | _nc_str_init(&result, buf, sizeof(buf)); |
709 | if (_nc_safe_strcat(&result, carriage_returntp-> Strings[2]) |
710 | && _nc_safe_strcat(&result, cursor_downtp-> Strings[11])) |
711 | newlinetp-> Strings[103] = _nc_save_str(buf); |
712 | } |
713 | } |
714 | } |
715 | |
716 | /* |
717 | * Inverse of capdefaults.c code ends here. |
718 | * ---------------------------------------------------------------------- |
719 | * |
720 | * TERMCAP-TO TERMINFO MAPPINGS FOR SOURCE TRANSLATION |
721 | * |
722 | * These translations will *not* be inverted by tgetent(). |
723 | */ |
724 | |
725 | if (!has_base) { |
726 | /* |
727 | * We wait until now to decide if we've got a working cr because even |
728 | * one that doesn't work can be used for newline. Unfortunately the |
729 | * space allocated for it is wasted. |
730 | */ |
731 | if (return_does_clr_eoltp-> Booleans[43] == 1 || no_correctly_working_crtp-> Booleans[39] == 1) |
732 | carriage_returntp-> Strings[2] = ABSENT_STRING(char *)0; |
733 | |
734 | /* |
735 | * Supposedly most termcap entries have ta now and '\t' is no longer a |
736 | * default, but it doesn't seem to be true... |
737 | */ |
738 | if (WANTED(tab)((tp-> Strings[134]) == (char *)0)) { |
739 | if (horizontal_tab_delaytp-> Numbers[37] > 0) { |
740 | snprintf(buf, sizeof(buf), "%s$<%d>", C_HT, horizontal_tab_delaytp-> Numbers[37]); |
741 | tabtp-> Strings[134] = _nc_save_str(buf); |
742 | } else |
743 | tabtp-> Strings[134] = _nc_save_str(C_HT); |
744 | } |
745 | if (init_tabstp-> Numbers[1] == ABSENT_NUMERIC(-1) && has_hardware_tabstp-> Booleans[42] == TRUE1) |
746 | init_tabstp-> Numbers[1] = 8; |
747 | |
748 | /* |
749 | * Assume we can beep with ^G unless we're given bl@. |
750 | */ |
751 | if (WANTED(bell)((tp-> Strings[1]) == (char *)0)) |
752 | belltp-> Strings[1] = _nc_save_str("\007"); |
753 | } |
754 | |
755 | /* |
756 | * Translate the old termcap :pt: capability to it#8 + ht=\t |
757 | */ |
758 | if (has_hardware_tabstp-> Booleans[42] == TRUE1) { |
759 | if (init_tabstp-> Numbers[1] != 8 && init_tabstp-> Numbers[1] != ABSENT_NUMERIC(-1)) |
760 | _nc_warning("hardware tabs with a width other than 8: %d", init_tabstp-> Numbers[1]); |
761 | else { |
762 | if (tabtp-> Strings[134] && _nc_capcmp(tabtp-> Strings[134], C_HT)) |
763 | _nc_warning("hardware tabs with a non-^I tab string %s", |
764 | _nc_visbuf(tabtp-> Strings[134])); |
765 | else { |
766 | if (WANTED(tab)((tp-> Strings[134]) == (char *)0)) |
767 | tabtp-> Strings[134] = _nc_save_str(C_HT); |
768 | init_tabstp-> Numbers[1] = 8; |
769 | } |
770 | } |
771 | } |
772 | /* |
773 | * Now translate the ko capability, if there is one. This |
774 | * isn't from mytinfo... |
775 | */ |
776 | if (PRESENT(other_non_function_keys)(((tp-> Strings[398]) != (char *)0) && ((tp-> Strings [398]) != (char *)(-1)))) { |
777 | char *base = other_non_function_keystp-> Strings[398]; |
Value stored to 'base' during its initialization is never read | |
778 | char *bp, *cp, *dp; |
779 | struct name_table_entry const *from_ptr; |
780 | struct name_table_entry const *to_ptr; |
781 | assoc const *ap; |
782 | char buf2[MAX_TERMINFO_LENGTH4096]; |
783 | bool_Bool foundim; |
784 | |
785 | /* we're going to use this for a special case later */ |
786 | dp = strchr(other_non_function_keystp-> Strings[398], 'i'); |
787 | foundim = (dp != 0) && (dp[1] == 'm'); |
788 | |
789 | /* look at each comma-separated capability in the ko string... */ |
790 | for (base = other_non_function_keystp-> Strings[398]; |
791 | (cp = strchr(base, ',')) != 0; |
792 | base = cp + 1) { |
793 | size_t len = cp - base; |
794 | |
795 | for (ap = ko_xlate; ap->from; ap++) { |
796 | if (len == strlen(ap->from) |
797 | && strncmp(ap->from, base, len) == 0) |
798 | break; |
799 | } |
800 | if (!(ap->from && ap->to)) { |
801 | _nc_warning("unknown capability `%.*s' in ko string", |
802 | (int) len, base); |
803 | continue; |
804 | } else if (ap->to == CANCELLED_STRING(char *)(-1)) /* ignore it */ |
805 | continue; |
806 | |
807 | /* now we know we found a match in ko_table, so... */ |
808 | |
809 | from_ptr = _nc_find_entry(ap->from, _nc_get_hash_table(TRUE1)); |
810 | to_ptr = _nc_find_entry(ap->to, _nc_get_hash_table(FALSE0)); |
811 | |
812 | if (!from_ptr || !to_ptr) /* should never happen! */ |
813 | _nc_err_abort("ko translation table is invalid, I give up"); |
814 | |
815 | if (WANTED(tp->Strings[from_ptr->nte_index])((tp->Strings[from_ptr->nte_index]) == (char *)0)) { |
816 | _nc_warning("no value for ko capability %s", ap->from); |
817 | continue; |
818 | } |
819 | |
820 | if (tp->Strings[to_ptr->nte_index]) { |
821 | /* There's no point in warning about it if it's the same |
822 | * string; that's just an inefficiency. |
823 | */ |
824 | if (strcmp( |
825 | tp->Strings[from_ptr->nte_index], |
826 | tp->Strings[to_ptr->nte_index]) != 0) |
827 | _nc_warning("%s (%s) already has an explicit value %s, ignoring ko", |
828 | ap->to, ap->from, |
829 | _nc_visbuf(tp->Strings[to_ptr->nte_index])); |
830 | continue; |
831 | } |
832 | |
833 | /* |
834 | * The magic moment -- copy the mapped key string over, |
835 | * stripping out padding. |
836 | */ |
837 | for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) { |
838 | if (bp[0] == '$' && bp[1] == '<') { |
839 | while (*bp && *bp != '>') { |
840 | ++bp; |
841 | } |
842 | } else |
843 | *dp++ = *bp; |
844 | } |
845 | *dp++ = '\0'; |
846 | |
847 | tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2); |
848 | } |
849 | |
850 | /* |
851 | * Note: ko=im and ko=ic both want to grab the `Insert' |
852 | * keycap. There's a kich1 but no ksmir, so the ic capability |
853 | * got mapped to kich1 and im to kIC to avoid a collision. |
854 | * If the description has im but not ic, hack kIC back to kich1. |
855 | */ |
856 | if (foundim && WANTED(key_ic)((tp-> Strings[77]) == (char *)0) && key_sictp-> Strings[200]) { |
857 | key_ictp-> Strings[77] = key_sictp-> Strings[200]; |
858 | key_sictp-> Strings[200] = ABSENT_STRING(char *)0; |
859 | } |
860 | } |
861 | |
862 | if (!has_base) { |
863 | if (!hard_copytp-> Booleans[7]) { |
864 | if (WANTED(key_backspace)((tp-> Strings[55]) == (char *)0)) |
865 | key_backspacetp-> Strings[55] = _nc_save_str(C_BS); |
866 | if (WANTED(key_left)((tp-> Strings[79]) == (char *)0)) |
867 | key_lefttp-> Strings[79] = _nc_save_str(C_BS); |
868 | if (WANTED(key_down)((tp-> Strings[61]) == (char *)0)) |
869 | key_downtp-> Strings[61] = _nc_save_str(C_LF); |
870 | } |
871 | } |
872 | |
873 | /* |
874 | * Translate XENIX forms characters. |
875 | */ |
876 | if (PRESENT(acs_ulcorner)(((tp-> Strings[400]) != (char *)0) && ((tp-> Strings [400]) != (char *)(-1))) || |
877 | PRESENT(acs_llcorner)(((tp-> Strings[401]) != (char *)0) && ((tp-> Strings [401]) != (char *)(-1))) || |
878 | PRESENT(acs_urcorner)(((tp-> Strings[402]) != (char *)0) && ((tp-> Strings [402]) != (char *)(-1))) || |
879 | PRESENT(acs_lrcorner)(((tp-> Strings[403]) != (char *)0) && ((tp-> Strings [403]) != (char *)(-1))) || |
880 | PRESENT(acs_ltee)(((tp-> Strings[404]) != (char *)0) && ((tp-> Strings [404]) != (char *)(-1))) || |
881 | PRESENT(acs_rtee)(((tp-> Strings[405]) != (char *)0) && ((tp-> Strings [405]) != (char *)(-1))) || |
882 | PRESENT(acs_btee)(((tp-> Strings[406]) != (char *)0) && ((tp-> Strings [406]) != (char *)(-1))) || |
883 | PRESENT(acs_ttee)(((tp-> Strings[407]) != (char *)0) && ((tp-> Strings [407]) != (char *)(-1))) || |
884 | PRESENT(acs_hline)(((tp-> Strings[408]) != (char *)0) && ((tp-> Strings [408]) != (char *)(-1))) || |
885 | PRESENT(acs_vline)(((tp-> Strings[409]) != (char *)0) && ((tp-> Strings [409]) != (char *)(-1))) || |
886 | PRESENT(acs_plus)(((tp-> Strings[410]) != (char *)0) && ((tp-> Strings [410]) != (char *)(-1)))) { |
887 | char buf2[MAX_TERMCAP_LENGTH1023]; |
888 | |
889 | _nc_str_init(&result, buf2, sizeof(buf2)); |
890 | _nc_safe_strcat(&result, acs_charstp-> Strings[146]); |
891 | |
892 | append_acs(&result, 'j', acs_lrcornertp-> Strings[403]); |
893 | append_acs(&result, 'k', acs_urcornertp-> Strings[402]); |
894 | append_acs(&result, 'l', acs_ulcornertp-> Strings[400]); |
895 | append_acs(&result, 'm', acs_llcornertp-> Strings[401]); |
896 | append_acs(&result, 'n', acs_plustp-> Strings[410]); |
897 | append_acs(&result, 'q', acs_hlinetp-> Strings[408]); |
898 | append_acs(&result, 't', acs_lteetp-> Strings[404]); |
899 | append_acs(&result, 'u', acs_rteetp-> Strings[405]); |
900 | append_acs(&result, 'v', acs_bteetp-> Strings[406]); |
901 | append_acs(&result, 'w', acs_tteetp-> Strings[407]); |
902 | append_acs(&result, 'x', acs_vlinetp-> Strings[409]); |
903 | |
904 | if (buf2[0]) { |
905 | acs_charstp-> Strings[146] = _nc_save_str(buf2); |
906 | _nc_warning("acsc string synthesized from XENIX capabilities"); |
907 | } |
908 | } else if (acs_charstp-> Strings[146] == 0 |
909 | && enter_alt_charset_modetp-> Strings[25] != 0 |
910 | && exit_alt_charset_modetp-> Strings[38] != 0) { |
911 | acs_charstp-> Strings[146] = _nc_save_str(VT_ACSC"``aaffggiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~"); |
912 | } |
913 | } |
914 | |
915 | static void |
916 | postprocess_terminfo(TERMTYPE *tp) |
917 | { |
918 | /* |
919 | * TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION |
920 | * ---------------------------------------------------------------------- |
921 | */ |
922 | |
923 | /* |
924 | * Translate AIX forms characters. |
925 | */ |
926 | if (PRESENT(box_chars_1)(((tp-> Strings[413]) != (char *)0) && ((tp-> Strings [413]) != (char *)(-1)))) { |
927 | char buf2[MAX_TERMCAP_LENGTH1023]; |
928 | string_desc result; |
929 | |
930 | _nc_str_init(&result, buf2, sizeof(buf2)); |
931 | _nc_safe_strcat(&result, acs_charstp-> Strings[146]); |
932 | |
933 | append_acs0(&result, 'l', box_chars_1tp-> Strings[413][0]); /* ACS_ULCORNER */ |
934 | append_acs0(&result, 'q', box_chars_1tp-> Strings[413][1]); /* ACS_HLINE */ |
935 | append_acs0(&result, 'k', box_chars_1tp-> Strings[413][2]); /* ACS_URCORNER */ |
936 | append_acs0(&result, 'x', box_chars_1tp-> Strings[413][3]); /* ACS_VLINE */ |
937 | append_acs0(&result, 'j', box_chars_1tp-> Strings[413][4]); /* ACS_LRCORNER */ |
938 | append_acs0(&result, 'm', box_chars_1tp-> Strings[413][5]); /* ACS_LLCORNER */ |
939 | append_acs0(&result, 'w', box_chars_1tp-> Strings[413][6]); /* ACS_TTEE */ |
940 | append_acs0(&result, 'u', box_chars_1tp-> Strings[413][7]); /* ACS_RTEE */ |
941 | append_acs0(&result, 'v', box_chars_1tp-> Strings[413][8]); /* ACS_BTEE */ |
942 | append_acs0(&result, 't', box_chars_1tp-> Strings[413][9]); /* ACS_LTEE */ |
943 | append_acs0(&result, 'n', box_chars_1tp-> Strings[413][10]); /* ACS_PLUS */ |
944 | |
945 | if (buf2[0]) { |
946 | acs_charstp-> Strings[146] = _nc_save_str(buf2); |
947 | _nc_warning("acsc string synthesized from AIX capabilities"); |
948 | box_chars_1tp-> Strings[413] = ABSENT_STRING(char *)0; |
949 | } |
950 | } |
951 | /* |
952 | * ---------------------------------------------------------------------- |
953 | */ |
954 | } |
955 | |
956 | /* |
957 | * Do a linear search through the terminfo tables to find a given full-name. |
958 | * We don't expect to do this often, so there's no hashing function. |
959 | * |
960 | * In effect, this scans through the 3 lists of full-names, and looks them |
961 | * up in _nc_info_table, which is organized so that the nte_index fields are |
962 | * sorted, but the nte_type fields are not necessarily grouped together. |
963 | */ |
964 | static struct name_table_entry const * |
965 | lookup_fullname(const char *find) |
966 | { |
967 | int state = -1; |
968 | |
969 | for (;;) { |
970 | int count = 0; |
971 | NCURSES_CONSTconst char *const *names; |
972 | |
973 | switch (++state) { |
974 | case BOOLEAN0: |
975 | names = boolfnames; |
976 | break; |
977 | case STRING2: |
978 | names = strfnames; |
979 | break; |
980 | case NUMBER1: |
981 | names = numfnames; |
982 | break; |
983 | default: |
984 | return NOTFOUND((struct name_table_entry *) 0); |
985 | } |
986 | |
987 | for (count = 0; names[count] != 0; count++) { |
988 | if (!strcmp(names[count], find)) { |
989 | struct name_table_entry const *entry_ptr = _nc_get_table(FALSE0); |
990 | while (entry_ptr->nte_type != state |
991 | || entry_ptr->nte_index != count) |
992 | entry_ptr++; |
993 | return entry_ptr; |
994 | } |
995 | } |
996 | } |
997 | } |
998 | |
999 | /* parse_entry.c ends here */ |