Back to index

tetex-bin  3.0
Classes | Defines | Functions | Variables
parse_entry.c File Reference
#include <curses.priv.h>
#include <ctype.h>
#include <tic.h>
#include <term_entry.h>
#include <parametrized.h>

Go to the source code of this file.

Classes

struct  assoc

Defines

#define __INTERNAL_CAPS_VISIBLE
#define BAD_TC_USAGE
#define WANTED(s)   ((s) == ABSENT_STRING)
#define PRESENT(s)   (((s) != ABSENT_STRING) && ((s) != CANCELLED_STRING))
#define CUR   tp->

Functions

static void postprocess_termcap (TERMTYPE *, bool)
static void postprocess_terminfo (TERMTYPE *)
static struct name_table_entrylookup_fullname (const char *name)
 _nc_parse_entry (struct entry *entryp, int literal, bool silent)
 _nc_capcmp (const char *s, const char *t)
static void append_acs0 (string_desc *dst, int code, int src)
static void append_acs (string_desc *dst, int code, char *src)

Variables

static assoc const ko_xlate []
static const char C_CR [] = "\r"
static const char C_LF [] = "\n"
static const char C_BS [] = "\b"
static const char C_HT [] = "\t"

Class Documentation

struct assoc

Definition at line 567 of file parse_entry.c.

Class Members
const char * from
const char * to

Define Documentation

Definition at line 44 of file parse_entry.c.

#define BAD_TC_USAGE
Value:
if (!bad_tc_usage) \
       { bad_tc_usage = TRUE; \
        _nc_warning("Legacy termcap allows only a trailing tc= clause"); }

Definition at line 199 of file parse_entry.c.

#define CUR   tp->

Definition at line 620 of file parse_entry.c.

#define PRESENT (   s)    (((s) != ABSENT_STRING) && ((s) != CANCELLED_STRING))

Definition at line 611 of file parse_entry.c.

#define WANTED (   s)    ((s) == ABSENT_STRING)

Definition at line 610 of file parse_entry.c.


Function Documentation

_nc_capcmp ( const char *  s,
const char *  t 
)

Definition at line 500 of file parse_entry.c.

{
    if (!s && !t)
       return (0);
    else if (!s || !t)
       return (1);

    for (;;) {
       if (s[0] == '$' && s[1] == '<') {
           for (s += 2;; s++)
              if (!(isdigit(UChar(*s))
                    || *s == '.'
                    || *s == '*'
                    || *s == '/'
                    || *s == '>'))
                  break;
       }

       if (t[0] == '$' && t[1] == '<') {
           for (t += 2;; t++)
              if (!(isdigit(UChar(*t))
                    || *t == '.'
                    || *t == '*'
                    || *t == '/'
                    || *t == '>'))
                  break;
       }

       /* we've now pushed s and t past any padding they were pointing at */

       if (*s == '\0' && *t == '\0')
           return (0);

       if (*s != *t)
           return (*t - *s);

       /* else *s == *t but one is not NUL, so continue */
       s++, t++;
    }
}

Here is the caller graph for this function:

_nc_parse_entry ( struct entry entryp,
int  literal,
bool  silent 
)

Definition at line 204 of file parse_entry.c.

{
    int token_type;
    struct name_table_entry const *entry_ptr;
    char *ptr, *base;
    bool bad_tc_usage = FALSE;

    token_type = _nc_get_token(silent);

    if (token_type == EOF)
       return (EOF);
    if (token_type != NAMES)
       _nc_err_abort("Entry does not start with terminal names in column one");

    _nc_init_entry(&entryp->tterm);

    entryp->cstart = _nc_comment_start;
    entryp->cend = _nc_comment_end;
    entryp->startline = _nc_start_line;
    DEBUG(2, ("Comment range is %ld to %ld", entryp->cstart, entryp->cend));

    /*
     * Strip off the 2-character termcap name, if present.  Originally termcap
     * used that as an indexing aid.  We can retain 2-character terminfo names,
     * but note that they would be lost if we translate to/from termcap.  This
     * feature is supposedly obsolete since "newer" BSD implementations do not
     * use it; however our reference for this feature is SunOS 4.x, which
     * implemented it.  Note that the resulting terminal type was never the
     * 2-character name, but was instead the first alias after that.
     */
    ptr = _nc_curr_token.tk_name;
    if (_nc_syntax == SYN_TERMCAP
#if NCURSES_XNAMES
       && !_nc_user_definable
#endif
       ) {
       if (ptr[2] == '|') {
           ptr += 3;
           _nc_curr_token.tk_name[2] = '\0';
       }
    }

    entryp->tterm.str_table = entryp->tterm.term_names = _nc_save_str(ptr);

    DEBUG(1, ("Starting '%s'", ptr));

    /*
     * We do this because the one-token lookahead in the parse loop
     * results in the terminal type getting prematurely set to correspond
     * to that of the next entry.
     */
    _nc_set_type(_nc_first_name(entryp->tterm.term_names));

    /* check for overly-long names and aliases */
    for (base = entryp->tterm.term_names; (ptr = strchr(base, '|')) != 0;
        base = ptr + 1) {
       if (ptr - base > MAX_ALIAS) {
           _nc_warning("%s `%.*s' may be too long",
                     (base == entryp->tterm.term_names)
                     ? "primary name"
                     : "alias",
                     (int) (ptr - base), base);
       }
    }

    entryp->nuses = 0;

    for (token_type = _nc_get_token(silent);
        token_type != EOF && token_type != NAMES;
        token_type = _nc_get_token(silent)) {
       bool is_use = (strcmp(_nc_curr_token.tk_name, "use") == 0);
       bool is_tc = !is_use && (strcmp(_nc_curr_token.tk_name, "tc") == 0);
       if (is_use || is_tc) {
           entryp->uses[entryp->nuses].name = _nc_save_str(_nc_curr_token.tk_valstring);
           entryp->uses[entryp->nuses].line = _nc_curr_line;
           entryp->nuses++;
           if (entryp->nuses > 1 && is_tc) {
              BAD_TC_USAGE
           }
       } else {
           /* normal token lookup */
           entry_ptr = _nc_find_entry(_nc_curr_token.tk_name,
                                   _nc_syntax ? _nc_cap_hash_table : _nc_info_hash_table);

           /*
            * Our kluge to handle aliasing.  The reason it's done
            * this ugly way, with a linear search, is so the hashing
            * machinery doesn't have to be made really complicated
            * (also we get better warnings this way).  No point in
            * making this case fast, aliased caps aren't common now
            * and will get rarer.
            */
           if (entry_ptr == NOTFOUND) {
              const struct alias *ap;

              if (_nc_syntax == SYN_TERMCAP) {
                  if (entryp->nuses != 0) {
                     BAD_TC_USAGE
                  }
                  for (ap = _nc_capalias_table; ap->from; ap++)
                     if (strcmp(ap->from, _nc_curr_token.tk_name) == 0) {
                         if (ap->to == (char *) 0) {
                            _nc_warning("%s (%s termcap extension) ignored",
                                       ap->from, ap->source);
                            goto nexttok;
                         }

                         entry_ptr = _nc_find_entry(ap->to, _nc_cap_hash_table);
                         if (entry_ptr && !silent)
                            _nc_warning("%s (%s termcap extension) aliased to %s",
                                       ap->from, ap->source, ap->to);
                         break;
                     }
              } else {      /* if (_nc_syntax == SYN_TERMINFO) */
                  for (ap = _nc_infoalias_table; ap->from; ap++)
                     if (strcmp(ap->from, _nc_curr_token.tk_name) == 0) {
                         if (ap->to == (char *) 0) {
                            _nc_warning("%s (%s terminfo extension) ignored",
                                       ap->from, ap->source);
                            goto nexttok;
                         }

                         entry_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);
                         if (entry_ptr && !silent)
                            _nc_warning("%s (%s terminfo extension) aliased to %s",
                                       ap->from, ap->source, ap->to);
                         break;
                     }

                  if (entry_ptr == NOTFOUND) {
                     entry_ptr = lookup_fullname(_nc_curr_token.tk_name);
                  }
              }
           }
#if NCURSES_XNAMES
           /*
            * If we have extended-names active, we will automatically
            * define a name based on its context.
            */
           if (entry_ptr == NOTFOUND
              && _nc_user_definable
              && (entry_ptr = _nc_extend_names(entryp,
                                           _nc_curr_token.tk_name,
                                           token_type)) != 0) {
              if (_nc_tracing >= DEBUG_LEVEL(1))
                  _nc_warning("extended capability '%s'", _nc_curr_token.tk_name);
           }
#endif /* NCURSES_XNAMES */

           /* can't find this cap name, not even as an alias */
           if (entry_ptr == NOTFOUND) {
              if (!silent)
                  _nc_warning("unknown capability '%s'",
                            _nc_curr_token.tk_name);
              continue;
           }

           /* deal with bad type/value combinations. */
           if (token_type != CANCEL && entry_ptr->nte_type != token_type) {
              /*
               * Nasty special cases here handle situations in which type
               * information can resolve name clashes.  Normal lookup
               * finds the last instance in the capability table of a
               * given name, regardless of type.  find_type_entry looks
               * for a first matching instance with given type.  So as
               * long as all ambiguous names occur in pairs of distinct
               * type, this will do the job.
               */

              /* tell max_attributes from arrow_key_map */
              if (token_type == NUMBER && !strcmp("ma", _nc_curr_token.tk_name))
                  entry_ptr = _nc_find_type_entry("ma", NUMBER,
                                              _nc_get_table(_nc_syntax
                                                          != 0));

              /* map terminfo's string MT to MT */
              else if (token_type == STRING && !strcmp("MT", _nc_curr_token.tk_name))
                  entry_ptr = _nc_find_type_entry("MT", STRING,
                                              _nc_get_table(_nc_syntax
                                                          != 0));

              /* treat strings without following "=" as empty strings */
              else if (token_type == BOOLEAN && entry_ptr->nte_type == STRING)
                  token_type = STRING;
              /* we couldn't recover; skip this token */
              else {
                  if (!silent) {
                     const char *type_name;
                     switch (entry_ptr->nte_type) {
                     case BOOLEAN:
                         type_name = "boolean";
                         break;
                     case STRING:
                         type_name = "string";
                         break;
                     case NUMBER:
                         type_name = "numeric";
                         break;
                     default:
                         type_name = "unknown";
                         break;
                     }
                     _nc_warning("wrong type used for %s capability '%s'",
                                type_name, _nc_curr_token.tk_name);
                  }
                  continue;
              }
           }

           /* now we know that the type/value combination is OK */
           switch (token_type) {
           case CANCEL:
              switch (entry_ptr->nte_type) {
              case BOOLEAN:
                  entryp->tterm.Booleans[entry_ptr->nte_index] = CANCELLED_BOOLEAN;
                  break;

              case NUMBER:
                  entryp->tterm.Numbers[entry_ptr->nte_index] = CANCELLED_NUMERIC;
                  break;

              case STRING:
                  entryp->tterm.Strings[entry_ptr->nte_index] = CANCELLED_STRING;
                  break;
              }
              break;

           case BOOLEAN:
              entryp->tterm.Booleans[entry_ptr->nte_index] = TRUE;
              break;

           case NUMBER:
              entryp->tterm.Numbers[entry_ptr->nte_index] =
                  _nc_curr_token.tk_valnumber;
              break;

           case STRING:
              ptr = _nc_curr_token.tk_valstring;
              if (_nc_syntax == SYN_TERMCAP)
                  ptr = _nc_captoinfo(_nc_curr_token.tk_name,
                                   ptr,
                                   parametrized[entry_ptr->nte_index]);
              entryp->tterm.Strings[entry_ptr->nte_index] = _nc_save_str(ptr);
              break;

           default:
              if (!silent)
                  _nc_warning("unknown token type");
              _nc_panic_mode((_nc_syntax == SYN_TERMCAP) ? ':' : ',');
              continue;
           }
       }                    /* end else cur_token.name != "use" */
      nexttok:
       continue;            /* cannot have a label w/o statement */
    }                       /* endwhile (not EOF and not NAMES) */

    _nc_push_token(token_type);
    _nc_set_type(_nc_first_name(entryp->tterm.term_names));

    /*
     * Try to deduce as much as possible from extension capabilities
     * (this includes obsolete BSD capabilities).  Sigh...it would be more
     * space-efficient to call this after use resolution, but it has
     * to be done before entry allocation is wrapped up.
     */
    if (!literal) {
       if (_nc_syntax == SYN_TERMCAP) {
           bool has_base_entry = FALSE;
           int i;

           /*
            * Don't insert defaults if this is a `+' entry meant only
            * for inclusion in other entries (not sure termcap ever
            * had these, actually).
            */
           if (strchr(entryp->tterm.term_names, '+'))
              has_base_entry = TRUE;
           else
              /*
               * Otherwise, look for a base entry that will already
               * have picked up defaults via translation.
               */
              for (i = 0; i < entryp->nuses; i++)
                  if (!strchr((char *) entryp->uses[i].name, '+'))
                     has_base_entry = TRUE;

           postprocess_termcap(&entryp->tterm, has_base_entry);
       } else
           postprocess_terminfo(&entryp->tterm);
    }
    _nc_wrap_entry(entryp, FALSE);

    return (OK);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void append_acs ( string_desc dst,
int  code,
char *  src 
) [static]

Definition at line 555 of file parse_entry.c.

{
    if (src != 0 && strlen(src) == 1) {
       append_acs0(dst, code, *src);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void append_acs0 ( string_desc dst,
int  code,
int  src 
) [static]

Definition at line 543 of file parse_entry.c.

{
    if (src != 0) {
       char temp[3];
       temp[0] = code;
       temp[1] = src;
       temp[2] = 0;
       _nc_safe_strcat(dst, temp);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static struct name_table_entry * lookup_fullname ( const char *  name) [static, read, abstract]

Definition at line 952 of file parse_entry.c.

{
    int state = -1;

    for (;;) {
       int count = 0;
       NCURSES_CONST char *const *names;

       switch (++state) {
       case BOOLEAN:
           names = boolfnames;
           break;
       case STRING:
           names = strfnames;
           break;
       case NUMBER:
           names = numfnames;
           break;
       default:
           return NOTFOUND;
       }

       for (count = 0; names[count] != 0; count++) {
           if (!strcmp(names[count], find)) {
              struct name_table_entry const *entry_ptr = _nc_get_table(FALSE);
              while (entry_ptr->nte_type != state
                     || entry_ptr->nte_index != count)
                  entry_ptr++;
              return entry_ptr;
           }
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void postprocess_termcap ( TERMTYPE *  tp,
bool  has_base 
) [static]

Definition at line 623 of file parse_entry.c.

{
    char buf[MAX_LINE * 2 + 2];
    string_desc result;

    /*
     * TERMCAP DEFAULTS AND OBSOLETE-CAPABILITY TRANSLATIONS
     *
     * This first part of the code is the functional inverse of the
     * fragment in capdefaults.c.
     * ----------------------------------------------------------------------
     */

    /* if there was a tc entry, assume we picked up defaults via that */
    if (!has_base) {
       if (WANTED(init_3string) && termcap_init2)
           init_3string = _nc_save_str(termcap_init2);

       if (WANTED(reset_2string) && termcap_reset)
           reset_2string = _nc_save_str(termcap_reset);

       if (WANTED(carriage_return)) {
           if (carriage_return_delay > 0) {
              sprintf(buf, "%s$<%d>", C_CR, carriage_return_delay);
              carriage_return = _nc_save_str(buf);
           } else
              carriage_return = _nc_save_str(C_CR);
       }
       if (WANTED(cursor_left)) {
           if (backspace_delay > 0) {
              sprintf(buf, "%s$<%d>", C_BS, backspace_delay);
              cursor_left = _nc_save_str(buf);
           } else if (backspaces_with_bs == 1)
              cursor_left = _nc_save_str(C_BS);
           else if (PRESENT(backspace_if_not_bs))
              cursor_left = backspace_if_not_bs;
       }
       /* vi doesn't use "do", but it does seems to use nl (or '\n') instead */
       if (WANTED(cursor_down)) {
           if (PRESENT(linefeed_if_not_lf))
              cursor_down = linefeed_if_not_lf;
           else if (linefeed_is_newline != 1) {
              if (new_line_delay > 0) {
                  sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
                  cursor_down = _nc_save_str(buf);
              } else
                  cursor_down = _nc_save_str(C_LF);
           }
       }
       if (WANTED(scroll_forward) && crt_no_scrolling != 1) {
           if (PRESENT(linefeed_if_not_lf))
              cursor_down = linefeed_if_not_lf;
           else if (linefeed_is_newline != 1) {
              if (new_line_delay > 0) {
                  sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
                  scroll_forward = _nc_save_str(buf);
              } else
                  scroll_forward = _nc_save_str(C_LF);
           }
       }
       if (WANTED(newline)) {
           if (linefeed_is_newline == 1) {
              if (new_line_delay > 0) {
                  sprintf(buf, "%s$<%d>", C_LF, new_line_delay);
                  newline = _nc_save_str(buf);
              } else
                  newline = _nc_save_str(C_LF);
           } else if (PRESENT(carriage_return) && PRESENT(scroll_forward)) {
              _nc_str_init(&result, buf, sizeof(buf));
              if (_nc_safe_strcat(&result, carriage_return)
                  && _nc_safe_strcat(&result, scroll_forward))
                  newline = _nc_save_str(buf);
           } else if (PRESENT(carriage_return) && PRESENT(cursor_down)) {
              _nc_str_init(&result, buf, sizeof(buf));
              if (_nc_safe_strcat(&result, carriage_return)
                  && _nc_safe_strcat(&result, cursor_down))
                  newline = _nc_save_str(buf);
           }
       }
    }

    /*
     * Inverse of capdefaults.c code ends here.
     * ----------------------------------------------------------------------
     *
     * TERMCAP-TO TERMINFO MAPPINGS FOR SOURCE TRANSLATION
     *
     * These translations will *not* be inverted by tgetent().
     */

    if (!has_base) {
       /*
        * We wait until now to decide if we've got a working cr because even
        * one that doesn't work can be used for newline. Unfortunately the
        * space allocated for it is wasted.
        */
       if (return_does_clr_eol == 1 || no_correctly_working_cr == 1)
           carriage_return = ABSENT_STRING;

       /*
        * Supposedly most termcap entries have ta now and '\t' is no longer a
        * default, but it doesn't seem to be true...
        */
       if (WANTED(tab)) {
           if (horizontal_tab_delay > 0) {
              sprintf(buf, "%s$<%d>", C_HT, horizontal_tab_delay);
              tab = _nc_save_str(buf);
           } else
              tab = _nc_save_str(C_HT);
       }
       if (init_tabs == ABSENT_NUMERIC && has_hardware_tabs == TRUE)
           init_tabs = 8;

       /*
        * Assume we can beep with ^G unless we're given bl@.
        */
       if (WANTED(bell))
           bell = _nc_save_str("\007");
    }

    /*
     * Translate the old termcap :pt: capability to it#8 + ht=\t
     */
    if (has_hardware_tabs == TRUE) {
       if (init_tabs != 8 && init_tabs != ABSENT_NUMERIC)
           _nc_warning("hardware tabs with a width other than 8: %d", init_tabs);
       else {
           if (tab && _nc_capcmp(tab, C_HT))
              _nc_warning("hardware tabs with a non-^I tab string %s",
                         _nc_visbuf(tab));
           else {
              if (WANTED(tab))
                  tab = _nc_save_str(C_HT);
              init_tabs = 8;
           }
       }
    }
    /*
     * Now translate the ko capability, if there is one.  This
     * isn't from mytinfo...
     */
    if (PRESENT(other_non_function_keys)) {
       char *base = other_non_function_keys;
       char *bp, *cp, *dp;
       struct name_table_entry const *from_ptr;
       struct name_table_entry const *to_ptr;
       assoc const *ap;
       char buf2[MAX_TERMINFO_LENGTH];
       bool foundim;

       /* we're going to use this for a special case later */
       dp = strchr(other_non_function_keys, 'i');
       foundim = (dp != 0) && (dp[1] == 'm');

       /* look at each comma-separated capability in the ko string... */
       for (base = other_non_function_keys;
            (cp = strchr(base, ',')) != 0;
            base = cp + 1) {
           size_t len = cp - base;

           for (ap = ko_xlate; ap->from; ap++)
              if (len == strlen(ap->from)
                  && strncmp(ap->from, base, len) == 0)
                  break;
           if (!ap->to) {
              _nc_warning("unknown capability `%.*s' in ko string",
                         (int) len, base);
              continue;
           } else if (ap->to == CANCELLED_STRING)       /* ignore it */
              continue;

           /* now we know we found a match in ko_table, so... */

           from_ptr = _nc_find_entry(ap->from, _nc_cap_hash_table);
           to_ptr = _nc_find_entry(ap->to, _nc_info_hash_table);

           if (!from_ptr || !to_ptr)      /* should never happen! */
              _nc_err_abort("ko translation table is invalid, I give up");

           if (WANTED(tp->Strings[from_ptr->nte_index])) {
              _nc_warning("no value for ko capability %s", ap->from);
              continue;
           }

           if (tp->Strings[to_ptr->nte_index]) {
              /* There's no point in warning about it if it's the same
               * string; that's just an inefficiency.
               */
              if (strcmp(
                           tp->Strings[from_ptr->nte_index],
                           tp->Strings[to_ptr->nte_index]) != 0)
                  _nc_warning("%s (%s) already has an explicit value %s, ignoring ko",
                            ap->to, ap->from,
                            _nc_visbuf(tp->Strings[to_ptr->nte_index]));
              continue;
           }

           /*
            * The magic moment -- copy the mapped key string over,
            * stripping out padding.
            */
           for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) {
              if (bp[0] == '$' && bp[1] == '<') {
                  while (*bp && *bp != '>') {
                     ++bp;
                  }
              } else
                  *dp++ = *bp;
           }
           *dp++ = '\0';

           tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
       }

       /*
        * Note: ko=im and ko=ic both want to grab the `Insert'
        * keycap.  There's a kich1 but no ksmir, so the ic capability
        * got mapped to kich1 and im to kIC to avoid a collision.
        * If the description has im but not ic, hack kIC back to kich1.
        */
       if (foundim && WANTED(key_ic) && key_sic) {
           key_ic = key_sic;
           key_sic = ABSENT_STRING;
       }
    }

    if (!has_base) {
       if (!hard_copy) {
           if (WANTED(key_backspace))
              key_backspace = _nc_save_str(C_BS);
           if (WANTED(key_left))
              key_left = _nc_save_str(C_BS);
           if (WANTED(key_down))
              key_down = _nc_save_str(C_LF);
       }
    }

    /*
     * Translate XENIX forms characters.
     */
    if (PRESENT(acs_ulcorner) ||
       PRESENT(acs_llcorner) ||
       PRESENT(acs_urcorner) ||
       PRESENT(acs_lrcorner) ||
       PRESENT(acs_ltee) ||
       PRESENT(acs_rtee) ||
       PRESENT(acs_btee) ||
       PRESENT(acs_ttee) ||
       PRESENT(acs_hline) ||
       PRESENT(acs_vline) ||
       PRESENT(acs_plus)) {
       char buf2[MAX_TERMCAP_LENGTH];

       _nc_str_init(&result, buf2, sizeof(buf2));
       _nc_safe_strcat(&result, acs_chars);

       append_acs(&result, 'j', acs_lrcorner);
       append_acs(&result, 'k', acs_urcorner);
       append_acs(&result, 'l', acs_ulcorner);
       append_acs(&result, 'm', acs_llcorner);
       append_acs(&result, 'n', acs_plus);
       append_acs(&result, 'q', acs_hline);
       append_acs(&result, 't', acs_ltee);
       append_acs(&result, 'u', acs_rtee);
       append_acs(&result, 'v', acs_btee);
       append_acs(&result, 'w', acs_ttee);
       append_acs(&result, 'x', acs_vline);

       if (buf2[0]) {
           acs_chars = _nc_save_str(buf2);
           _nc_warning("acsc string synthesized from XENIX capabilities");
       }
    } else if (acs_chars == 0
              && enter_alt_charset_mode != 0
              && exit_alt_charset_mode != 0) {
       acs_chars = _nc_save_str(VT_ACSC);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void postprocess_terminfo ( TERMTYPE *  tp) [static]

Definition at line 903 of file parse_entry.c.

{
    /*
     * TERMINFO-TO-TERMINFO MAPPINGS FOR SOURCE TRANSLATION
     * ----------------------------------------------------------------------
     */

    /*
     * Translate AIX forms characters.
     */
    if (PRESENT(box_chars_1)) {
       char buf2[MAX_TERMCAP_LENGTH];
       string_desc result;

       _nc_str_init(&result, buf2, sizeof(buf2));
       _nc_safe_strcat(&result, acs_chars);

       append_acs0(&result, 'l', box_chars_1[0]);       /* ACS_ULCORNER */
       append_acs0(&result, 'q', box_chars_1[1]);       /* ACS_HLINE */
       append_acs0(&result, 'k', box_chars_1[2]);       /* ACS_URCORNER */
       append_acs0(&result, 'x', box_chars_1[3]);       /* ACS_VLINE */
       append_acs0(&result, 'j', box_chars_1[4]);       /* ACS_LRCORNER */
       append_acs0(&result, 'm', box_chars_1[5]);       /* ACS_LLCORNER */
       append_acs0(&result, 'w', box_chars_1[6]);       /* ACS_TTEE */
       append_acs0(&result, 'u', box_chars_1[7]);       /* ACS_RTEE */
       append_acs0(&result, 'v', box_chars_1[8]);       /* ACS_BTEE */
       append_acs0(&result, 't', box_chars_1[9]);       /* ACS_LTEE */
       append_acs0(&result, 'n', box_chars_1[10]);      /* ACS_PLUS */

       if (buf2[0]) {
           acs_chars = _nc_save_str(buf2);
           _nc_warning("acsc string synthesized from AIX capabilities");
           box_chars_1 = ABSENT_STRING;
       }
    }
    /*
     * ----------------------------------------------------------------------
     */
}

Here is the call graph for this function:

Here is the caller graph for this function:


Variable Documentation

const char C_BS[] = "\b" [static]

Definition at line 603 of file parse_entry.c.

const char C_CR[] = "\r" [static]

Definition at line 601 of file parse_entry.c.

const char C_HT[] = "\t" [static]

Definition at line 604 of file parse_entry.c.

const char C_LF[] = "\n" [static]

Definition at line 602 of file parse_entry.c.

assoc const ko_xlate[] [static]
Initial value:
{
    {"al", "kil1"},         
    {"bt", "kcbt"},         
    {"cd", "ked"},          
    {"ce", "kel"},          
    {"cl", "kclr"},         
    {"ct", "tbc"},          
    {"dc", "kdch1"},        
    {"dl", "kdl1"},         
    {"do", "kcud1"},        
    {"ei", "krmir"},        
    {"ho", "khome"},        
    {"ic", "kich1"},        
    {"im", "kIC"},          
    {"le", "kcub1"},        
    {"nd", "kcuf1"},        
    {"nl", "kent"},         
    {"st", "khts"},         
    {"ta", CANCELLED_STRING},
    {"up", "kcuu1"},        
    {(char *) 0, (char *) 0},
}

Definition at line 571 of file parse_entry.c.