Return to map3270.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / tn3270

Annotation of 43BSD/ucb/tn3270/map3270.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     Copyright 1984, 1985 by the Regents of the University of
        !             3:  *     California and by Gregory Glenn Minshall.
        !             4:  *
        !             5:  *     Permission to use, copy, modify, and distribute these
        !             6:  *     programs and their documentation for any purpose and
        !             7:  *     without fee is hereby granted, provided that this
        !             8:  *     copyright and permission appear on all copies and
        !             9:  *     supporting documentation, the name of the Regents of
        !            10:  *     the University of California not be used in advertising
        !            11:  *     or publicity pertaining to distribution of the programs
        !            12:  *     without specific prior permission, and notice be given in
        !            13:  *     supporting documentation that copying and distribution is
        !            14:  *     by permission of the Regents of the University of California
        !            15:  *     and by Gregory Glenn Minshall.  Neither the Regents of the
        !            16:  *     University of California nor Gregory Glenn Minshall make
        !            17:  *     representations about the suitability of this software
        !            18:  *     for any purpose.  It is provided "as is" without
        !            19:  *     express or implied warranty.
        !            20:  */
        !            21: 
        !            22: 
        !            23: #ifndef        LINT
        !            24: static char sccsid[] = "@(#)map3270.c  2.5";
        !            25: #endif /* LINT */
        !            26: 
        !            27: /*     This program reads a description file, somewhat like /etc/termcap,
        !            28:     that describes the mapping between the current terminals keyboard and
        !            29:     a 3270 keyboard.
        !            30:  */
        !            31: #ifdef DOCUMENTATION_ONLY
        !            32: /* here is a sample (very small) entry...
        !            33: 
        !            34:        # this table is sensitive to position on a line.  In particular,
        !            35:        # a terminal definition for a terminal is terminated whenever a
        !            36:        # (non-comment) line beginning in column one is found.
        !            37:        #
        !            38:        # this is an entry to map tvi924 to 3270 keys...
        !            39:        v8|tvi924|924|televideo model 924 {
        !            40:                pfk1 =  '\E1';
        !            41:                pfk2 =  '\E2';
        !            42:                clear = '^z';           # clear the screen
        !            43:        }
        !            44:  */
        !            45: #endif /* DOCUMENTATION_ONLY */
        !            46: 
        !            47: #include <stdio.h>
        !            48: #include <ctype.h>
        !            49: #include <curses.h>
        !            50: 
        !            51: #define IsPrint(c)     (isprint(c) || ((c) == ' '))
        !            52: 
        !            53: #define LETS_SEE_ASCII
        !            54: #include "m4.out"
        !            55: 
        !            56: #include "state.h"
        !            57: 
        !            58: /* this is the list of types returned by the lex processor */
        !            59: #define LEX_CHAR       TC_HIGHEST              /* plain unadorned character */
        !            60: #define        LEX_ESCAPED     LEX_CHAR+1              /* escaped with \ */
        !            61: #define LEX_CARETED    LEX_ESCAPED+1           /* escaped with ^ */
        !            62: #define LEX_END_OF_FILE        LEX_CARETED+1           /* end of file encountered */
        !            63: #define LEX_ILLEGAL    LEX_END_OF_FILE+1       /* trailing escape character */
        !            64: 
        !            65: /* the following is part of our character set dependancy... */
        !            66: #define        ESCAPE          0x1b
        !            67: #define        TAB             0x09
        !            68: #define NEWLINE                0x0a
        !            69: #define        CARRIAGE_RETURN 0x0d
        !            70: 
        !            71: typedef struct {
        !            72:     int type;          /* LEX_* - type of character */
        !            73:     int value;         /* character this was */
        !            74: } lexicon;
        !            75: 
        !            76: typedef struct {
        !            77:     int                length;         /* length of character string */
        !            78:     char       array[500];     /* character string */
        !            79: } stringWithLength;
        !            80: 
        !            81: #define panic(s)       { fprintf(stderr, s); exit(1); }
        !            82: 
        !            83: static state firstentry = { 0, TC_NULL, 0, 0 };
        !            84: static state *headOfQueue = &firstentry;
        !            85: 
        !            86: /* the following is a primitive adm3a table, to be used when nothing
        !            87:  * else seems to be avaliable.
        !            88:  */
        !            89: 
        !            90: #ifdef DEBUG
        !            91: static int debug = 0;          /* debug flag (for debuggin tables) */
        !            92: #endif /* DEBUG */
        !            93: 
        !            94: static int doPaste = 1;                        /* should we have side effects */
        !            95: static char usePointer;                        /* use pointer, or file */
        !            96: static FILE *ourFile;
        !            97: static char *environPointer = 0;       /* if non-zero, point to input
        !            98:                                         * string in core.
        !            99:                                         */
        !           100: static char keys3a[] =
        !           101: #include "default.map3270"             /* Define the default default */
        !           102:                        ;
        !           103: 
        !           104: static int     Empty = 1,              /* is the unget lifo empty? */
        !           105:                Full = 0;               /* is the unget lifo full? */
        !           106: static lexicon lifo[200];              /* character stack for parser */
        !           107: static int     rp = 0,                 /* read pointer into lifo */
        !           108:                wp = 0;                 /* write pointer into lifo */
        !           109: 
        !           110: static int
        !           111: GetC()
        !           112: {
        !           113:     int character;
        !           114: 
        !           115:     if (usePointer) {
        !           116:        if (*environPointer) {
        !           117:            character = 0xff&*environPointer++;
        !           118:        } else {
        !           119:            character = EOF;
        !           120:        }
        !           121:     } else {
        !           122:        character = getc(ourFile);
        !           123:     }
        !           124:     return(character);
        !           125: }
        !           126: 
        !           127: static lexicon
        !           128: Get()
        !           129: {
        !           130:     lexicon c;
        !           131:     register lexicon *pC = &c;
        !           132:     register int character;
        !           133: 
        !           134:     if (!Empty) {
        !           135:        *pC = lifo[rp];
        !           136:        rp++;
        !           137:        if (rp == sizeof lifo/sizeof (lexicon)) {
        !           138:            rp = 0;
        !           139:        }
        !           140:        if (rp == wp) {
        !           141:            Empty = 1;
        !           142:        }
        !           143:        Full = 0;
        !           144:     } else {
        !           145:        character = GetC();
        !           146:        switch (character) {
        !           147:        case EOF:
        !           148:            pC->type = LEX_END_OF_FILE;
        !           149:            break;
        !           150:        case '^':
        !           151:            character = GetC();
        !           152:            if (!IsPrint(character)) {
        !           153:                pC->type = LEX_ILLEGAL;
        !           154:            } else {
        !           155:                pC->type = LEX_CARETED;
        !           156:                if (character == '?') {
        !           157:                    character |= 0x40;  /* rubout */
        !           158:                } else {
        !           159:                    character &= 0x1f;
        !           160:                }
        !           161:            }
        !           162:            break;
        !           163:        case '\\':
        !           164:            character = GetC();
        !           165:            if (!IsPrint(character)) {
        !           166:                pC->type = LEX_ILLEGAL;
        !           167:            } else {
        !           168:                pC->type = LEX_ESCAPED;
        !           169:                switch (character) {
        !           170:                case 'E': case 'e':
        !           171:                    character = ESCAPE;
        !           172:                    break;
        !           173:                case 't':
        !           174:                    character = TAB;
        !           175:                    break;
        !           176:                case 'n':
        !           177:                    character = NEWLINE;
        !           178:                    break;
        !           179:                case 'r':
        !           180:                    character = CARRIAGE_RETURN;
        !           181:                    break;
        !           182:                default:
        !           183:                    pC->type = LEX_ILLEGAL;
        !           184:                    break;
        !           185:                }
        !           186:            }
        !           187:            break;
        !           188:        default:
        !           189:            if ((IsPrint(character)) || isspace(character)) {
        !           190:                pC->type = LEX_CHAR;
        !           191:            } else {
        !           192:                pC->type = LEX_ILLEGAL;
        !           193:            }
        !           194:            break;
        !           195:        }
        !           196:        pC->value = character;
        !           197:     }
        !           198:     return(*pC);
        !           199: }
        !           200: 
        !           201: static
        !           202: UnGet(c)
        !           203: lexicon c;                     /* character to unget */
        !           204: {
        !           205:     if (Full) {
        !           206:        fprintf(stderr, "attempt to put too many characters in lifo\n");
        !           207:        panic("map3270");
        !           208:        /* NOTREACHED */
        !           209:     } else {
        !           210:        lifo[wp] = c;
        !           211:        wp++;
        !           212:        if (wp == sizeof lifo/sizeof (lexicon)) {
        !           213:            wp = 0;
        !           214:        }
        !           215:        if (wp == rp) {
        !           216:            Full = 1;
        !           217:        }
        !           218:        Empty = 0;
        !           219:     }
        !           220: }
        !           221: 
        !           222: /* compare two strings, ignoring case */
        !           223: 
        !           224: ustrcmp(string1, string2)
        !           225: register char *string1;
        !           226: register char *string2;
        !           227: {
        !           228:     register int c1, c2;
        !           229: 
        !           230:     while (c1 = (unsigned char) *string1++) {
        !           231:        if (isupper(c1)) {
        !           232:            c1 = tolower(c1);
        !           233:        }
        !           234:        if (isupper(c2 = (unsigned char) *string2++)) {
        !           235:            c2 = tolower(c2);
        !           236:        }
        !           237:        if (c1 < c2) {
        !           238:            return(-1);
        !           239:        } else if (c1 > c2) {
        !           240:            return(1);
        !           241:        }
        !           242:     }
        !           243:     if (*string2) {
        !           244:        return(-1);
        !           245:     } else {
        !           246:        return(0);
        !           247:     }
        !           248: }
        !           249: 
        !           250: 
        !           251: static stringWithLength *
        !           252: GetQuotedString()
        !           253: {
        !           254:     lexicon lex;
        !           255:     static stringWithLength output;    /* where return value is held */
        !           256:     char *pointer = output.array;
        !           257: 
        !           258:     lex = Get();
        !           259:     if ((lex.type != LEX_CHAR) || (lex.value != '\'')) {
        !           260:        UnGet(lex);
        !           261:        return(0);
        !           262:     }
        !           263:     while (1) {
        !           264:        lex = Get();
        !           265:        if ((lex.type == LEX_CHAR) && (lex.value == '\'')) {
        !           266:            break;
        !           267:        }
        !           268:        if ((lex.type == LEX_CHAR) && !IsPrint(lex.value)) {
        !           269:            UnGet(lex);
        !           270:            return(0);          /* illegal character in quoted string */
        !           271:        }
        !           272:        if (pointer >= output.array+sizeof output.array) {
        !           273:            return(0);          /* too long */
        !           274:        }
        !           275:        *pointer++ = lex.value;
        !           276:     }
        !           277:     output.length = pointer-output.array;
        !           278:     return(&output);
        !           279: }
        !           280: 
        !           281: #ifdef NOTUSED
        !           282: static stringWithLength *
        !           283: GetCharString()
        !           284: {
        !           285:     lexicon lex;
        !           286:     static stringWithLength output;
        !           287:     char *pointer = output.array;
        !           288: 
        !           289:     lex = Get();
        !           290: 
        !           291:     while ((lex.type == LEX_CHAR) &&
        !           292:                        !isspace(lex.value) && (lex.value != '=')) {
        !           293:        *pointer++ = lex.value;
        !           294:        lex = Get();
        !           295:        if (pointer >= output.array + sizeof output.array) {
        !           296:            return(0);          /* too long */
        !           297:        }
        !           298:     }
        !           299:     UnGet(lex);
        !           300:     output.length = pointer-output.array;
        !           301:     return(&output);
        !           302: }
        !           303: #endif /* NOTUSED */
        !           304: 
        !           305: static
        !           306: GetCharacter(character)
        !           307: int    character;              /* desired character */
        !           308: {
        !           309:     lexicon lex;
        !           310: 
        !           311:     lex = Get();
        !           312: 
        !           313:     if ((lex.type != LEX_CHAR) || (lex.value != character)) {
        !           314:        UnGet(lex);
        !           315:        return(0);
        !           316:     }
        !           317:     return(1);
        !           318: }
        !           319: 
        !           320: #ifdef NOTUSED
        !           321: static
        !           322: GetString(string)
        !           323: char   *string;                /* string to get */
        !           324: {
        !           325:     lexicon lex;
        !           326: 
        !           327:     while (*string) {
        !           328:        lex = Get();
        !           329:        if ((lex.type != LEX_CHAR) || (lex.value != *string&0xff)) {
        !           330:            UnGet(lex);
        !           331:            return(0);          /* XXX restore to state on entry */
        !           332:        }
        !           333:        string++;
        !           334:     }
        !           335:     return(1);
        !           336: }
        !           337: #endif /* NOTUSED */
        !           338: 
        !           339: 
        !           340: static stringWithLength *
        !           341: GetAlphaMericString()
        !           342: {
        !           343:     lexicon lex;
        !           344:     static stringWithLength output;
        !           345:     char *pointer = output.array;
        !           346: #   define     IsAlnum(c)      (isalnum(c) || (c == '_')|| (c == '-'))
        !           347: 
        !           348:     lex = Get();
        !           349: 
        !           350:     if ((lex.type != LEX_CHAR) || !IsAlnum(lex.value)) {
        !           351:        UnGet(lex);
        !           352:        return(0);
        !           353:     }
        !           354: 
        !           355:     while ((lex.type == LEX_CHAR) && IsAlnum(lex.value)) {
        !           356:        *pointer++ = lex.value;
        !           357:        lex = Get();
        !           358:     }
        !           359:     UnGet(lex);
        !           360:     *pointer = 0;
        !           361:     output.length = pointer-output.array;
        !           362:     return(&output);
        !           363: }
        !           364: 
        !           365: 
        !           366: /* eat up characters until a new line, or end of file.  returns terminating
        !           367:        character.
        !           368:  */
        !           369: 
        !           370: static lexicon
        !           371: EatToNL()
        !           372: {
        !           373:     lexicon lex;
        !           374: 
        !           375:     lex = Get();
        !           376: 
        !           377:     while (!((lex.type != LEX_ESCAPED) && (lex.value == '\n')) &&
        !           378:                                (!(lex.type == LEX_END_OF_FILE))) {
        !           379:        lex = Get();
        !           380:     }
        !           381:     if (lex.type != LEX_END_OF_FILE) {
        !           382:        return(Get());
        !           383:     } else {
        !           384:        return(lex);
        !           385:     }
        !           386: }
        !           387: 
        !           388: 
        !           389: static void
        !           390: GetWS()
        !           391: {
        !           392:     lexicon lex;
        !           393: 
        !           394:     lex = Get();
        !           395: 
        !           396:     while ((lex.type == LEX_CHAR) &&
        !           397:                        (isspace(lex.value) || (lex.value == '#'))) {
        !           398:        if (lex.value == '#') {
        !           399:            lex = EatToNL();
        !           400:        } else {
        !           401:            lex = Get();
        !           402:        }
        !           403:     }
        !           404:     UnGet(lex);
        !           405: }
        !           406: 
        !           407: static void
        !           408: FreeState(pState)
        !           409: state *pState;
        !           410: {
        !           411:     free((char *)pState);
        !           412: }
        !           413: 
        !           414: 
        !           415: static state *
        !           416: GetState()
        !           417: {
        !           418:     state *pState;
        !           419:     char *malloc();
        !           420: 
        !           421:     pState = (state *) malloc(sizeof *pState);
        !           422: 
        !           423:     pState->result = TC_NULL;
        !           424:     pState->next = 0;
        !           425: 
        !           426:     return(pState);
        !           427: }
        !           428: 
        !           429: 
        !           430: static state *
        !           431: FindMatchAtThisLevel(pState, character)
        !           432: state  *pState;
        !           433: int    character;
        !           434: {
        !           435:     while (pState) {
        !           436:        if (pState->match == character) {
        !           437:            return(pState);
        !           438:        }
        !           439:        pState = pState->next;
        !           440:     }
        !           441:     return(0);
        !           442: }
        !           443: 
        !           444: 
        !           445: static state *
        !           446: PasteEntry(head, string, count, identifier)
        !           447: state                  *head;          /* points to who should point here... */
        !           448: char                   *string;        /* which characters to paste */
        !           449: int                    count;          /* number of character to do */
        !           450: char                   *identifier;    /* for error messages */
        !           451: {
        !           452:     state *pState, *other;
        !           453: 
        !           454:     if (!doPaste) {            /* flag to not have any side effects */
        !           455:        return((state *)1);
        !           456:     }
        !           457:     if (!count) {
        !           458:        return(head);   /* return pointer to the parent */
        !           459:     }
        !           460:     if ((head->result != TC_NULL) && (head->result != TC_GOTO)) {
        !           461:        /* this means that a previously defined sequence is an initial
        !           462:         * part of this one.
        !           463:         */
        !           464:        fprintf(stderr, "Conflicting entries found when scanning %s\n",
        !           465:                identifier);
        !           466:        return(0);
        !           467:     }
        !           468: #   ifdef      DEBUG
        !           469:        if (debug) {
        !           470:            fprintf(stderr, "%s", unctrl(*string));
        !           471:        }
        !           472: #   endif      /* DEBUG */
        !           473:     pState = GetState();
        !           474:     pState->match = *string;
        !           475:     if (head->result == TC_NULL) {
        !           476:        head->result = TC_GOTO;
        !           477:        head->address = pState;
        !           478:        other = pState;
        !           479:     } else {           /* search for same character */
        !           480:        if (other = FindMatchAtThisLevel(head->address, *string)) {
        !           481:            FreeState(pState);
        !           482:        } else {
        !           483:            pState->next = head->address;
        !           484:            head->address = pState;
        !           485:            other = pState;
        !           486:        }
        !           487:     }
        !           488:     return(PasteEntry(other, string+1, count-1, identifier));
        !           489: }
        !           490: 
        !           491: static
        !           492: GetInput(tc, identifier)
        !           493: int tc;
        !           494: char *identifier;              /* entry being parsed (for error messages) */
        !           495: {
        !           496:     stringWithLength *outputString;
        !           497:     state *head;
        !           498:     state fakeQueue;
        !           499: 
        !           500:     if (doPaste) {
        !           501:        head = headOfQueue;     /* always points to level above this one */
        !           502:     } else {
        !           503:        head = &fakeQueue;      /* don't have any side effects... */
        !           504:     }
        !           505: 
        !           506:     if (!(outputString = GetQuotedString())) {
        !           507:        return(0);
        !           508:     } else if (IsPrint(outputString->array[0])) {
        !           509:        fprintf(stderr,
        !           510:         "first character of sequence for %s is not a control type character\n",
        !           511:                identifier);
        !           512:        return(0);
        !           513:     } else {
        !           514:        if (!(head = PasteEntry(head, outputString->array,
        !           515:                                outputString->length, identifier))) {
        !           516:            return(0);
        !           517:        }
        !           518:        GetWS();
        !           519:        while (outputString = GetQuotedString()) {
        !           520:            if (!(head = PasteEntry(head, outputString->array, outputString->length, identifier))) {
        !           521:                return(0);
        !           522:            }
        !           523:            GetWS();
        !           524:        }
        !           525:     }
        !           526:     if (!doPaste) {
        !           527:        return(1);
        !           528:     }
        !           529:     if ((head->result != TC_NULL) && (head->result != tc)) {
        !           530:        /* this means that this sequence is an initial part
        !           531:         * of a previously defined one.
        !           532:         */
        !           533:        fprintf(stderr, "Conflicting entries found when scanning %s\n",
        !           534:                identifier);
        !           535:        return(0);
        !           536:     } else {
        !           537:        head->result = tc;
        !           538:        return(1);              /* done */
        !           539:     }
        !           540: }
        !           541: 
        !           542: static
        !           543: GetTc(string)
        !           544: char *string;
        !           545: {
        !           546:     register TC_Ascii_t *Tc;
        !           547: 
        !           548:     for (Tc = TC_Ascii;
        !           549:                Tc < TC_Ascii+sizeof TC_Ascii/sizeof (TC_Ascii_t); Tc++) {
        !           550:        if (!ustrcmp(string, Tc->tc_name)) {
        !           551: #          ifdef       DEBUG
        !           552:                if (debug) {
        !           553:                    fprintf(stderr, "%s = ", Tc->tc_name);
        !           554:                }
        !           555: #          endif       /* DEBUG */
        !           556:            return(Tc->tc_value&0xff);
        !           557:        }
        !           558:     }
        !           559:     return(0);
        !           560: }
        !           561: static
        !           562: GetDefinition()
        !           563: {
        !           564:     stringWithLength *string;
        !           565:     int Tc;
        !           566: 
        !           567:     GetWS();
        !           568:     if (!(string = GetAlphaMericString())) {
        !           569:        return(0);
        !           570:     }
        !           571:     string->array[string->length] = 0;
        !           572:     if (doPaste) {
        !           573:        if (!(Tc = GetTc(string->array))) {
        !           574:            fprintf(stderr, "%s: unknown 3270 key identifier\n", string->array);
        !           575:            return(0);
        !           576:        }
        !           577:        if (Tc < TC_LOWEST_USER) {
        !           578:            fprintf(stderr, "%s is not allowed to be specified by a user.\n",
        !           579:                        string->array);
        !           580:            return(0);
        !           581:        }
        !           582:     } else {
        !           583:        Tc = TC_LOWEST_USER;
        !           584:     }
        !           585:     GetWS();
        !           586:     if (!GetCharacter('=')) {
        !           587:        fprintf(stderr,
        !           588:                "Required equal sign after 3270 key identifier %s missing\n",
        !           589:                        string->array);
        !           590:        return(0);
        !           591:     }
        !           592:     GetWS();
        !           593:     if (!GetInput(Tc, string->array)) {
        !           594:        fprintf(stderr, "Missing definition part for 3270 key %s\n",
        !           595:                                string->array);
        !           596:        return(0);
        !           597:     } else {
        !           598:        GetWS();
        !           599:        while (GetCharacter('|')) {
        !           600: #          ifdef       DEBUG
        !           601:                if (debug) {
        !           602:                    fprintf(stderr, " or ");
        !           603:                }
        !           604: #          endif       /* DEBUG */
        !           605:            GetWS();
        !           606:            if (!GetInput(Tc, string->array)) {
        !           607:                fprintf(stderr, "Missing definition part for 3270 key %s\n",
        !           608:                                        string->array);
        !           609:                return(0);
        !           610:            }
        !           611:            GetWS();
        !           612:        }
        !           613:     }
        !           614:     GetWS();
        !           615:     if (!GetCharacter(';')) {
        !           616:        fprintf(stderr, "Missing semi-colon for 3270 key %s\n", string->array);
        !           617:        return(0);
        !           618:     }
        !           619: #   ifdef      DEBUG
        !           620:        if (debug) {
        !           621:            fprintf(stderr, ";\n");
        !           622:        }
        !           623: #   endif      /* DEBUG */
        !           624:     return(1);
        !           625: }
        !           626: 
        !           627: 
        !           628: static
        !           629: GetDefinitions()
        !           630: {
        !           631:     if (!GetDefinition()) {
        !           632:        return(0);
        !           633:     } else {
        !           634:        while (GetDefinition()) {
        !           635:            ;
        !           636:        }
        !           637:     }
        !           638:     return(1);
        !           639: }
        !           640: 
        !           641: static
        !           642: GetBegin()
        !           643: {
        !           644:     GetWS();
        !           645:     if (!GetCharacter('{')) {
        !           646:        return(0);
        !           647:     }
        !           648:     return(1);
        !           649: }
        !           650: 
        !           651: static
        !           652: GetEnd()
        !           653: {
        !           654:     GetWS();
        !           655:     if (!GetCharacter('}')) {
        !           656:        return(0);
        !           657:     }
        !           658:     return(1);
        !           659: }
        !           660: 
        !           661: static
        !           662: GetName()
        !           663: {
        !           664:     if (!GetAlphaMericString()) {
        !           665:        return(0);
        !           666:     }
        !           667:     GetWS();
        !           668:     while (GetAlphaMericString()) {
        !           669:        GetWS();
        !           670:     }
        !           671:     return(1);
        !           672: }
        !           673: 
        !           674: static
        !           675: GetNames()
        !           676: {
        !           677:     GetWS();
        !           678:     if (!GetName()) {
        !           679:        return(0);
        !           680:     } else {
        !           681:        GetWS();
        !           682:         while (GetCharacter('|')) {
        !           683:            GetWS();
        !           684:            if (!GetName()) {
        !           685:                return(0);
        !           686:            }
        !           687:        }
        !           688:     }
        !           689:     return(1);
        !           690: }
        !           691: 
        !           692: static
        !           693: GetEntry0()
        !           694: {
        !           695:     if (!GetBegin()) {
        !           696:        fprintf(stderr, "no '{'\n");
        !           697:        return(0);
        !           698:     } else if (!GetDefinitions()) {
        !           699:        fprintf(stderr, "unable to parse the definitions\n");
        !           700:        return(0);
        !           701:     } else if (!GetEnd()) {
        !           702:        fprintf(stderr, "no '}'\n");
        !           703:        return(0);
        !           704:     } else {
        !           705:        /* done */
        !           706:        return(1);
        !           707:     }
        !           708: }
        !           709: 
        !           710: 
        !           711: static
        !           712: GetEntry()
        !           713: {
        !           714:     if (!GetNames()) {
        !           715:        fprintf(stderr, "illegal name field in entry\n");
        !           716:        return(0);
        !           717:     } else {
        !           718:        return(GetEntry0());
        !           719:     }
        !           720: }
        !           721: 
        !           722: /* position ourselves within a given filename to the entry for the current
        !           723:  *     TERM variable
        !           724:  */
        !           725: 
        !           726: Position(filename, termPointer)
        !           727: char *filename;
        !           728: char *termPointer;
        !           729: {
        !           730:     lexicon lex;
        !           731:     stringWithLength *name = 0;
        !           732:     stringWithLength *oldName;
        !           733: #   define     Return(x) {doPaste = 1; return(x);}
        !           734: 
        !           735:     doPaste = 0;
        !           736: 
        !           737:     if ((ourFile = fopen(filename, "r")) == NULL) {
        !           738:        fprintf(stderr, "Unable to open file %s\n", filename);
        !           739:        Return(0);
        !           740:     }
        !           741:     lex = Get();
        !           742:     while (lex.type != LEX_END_OF_FILE) {
        !           743:        UnGet(lex);
        !           744:        /* now, find an entry that is our type. */
        !           745:        GetWS();
        !           746:        oldName = name;
        !           747:        if (name = GetAlphaMericString()) {
        !           748:            if (!ustrcmp(name->array, termPointer)) {
        !           749:                /* need to make sure there is a name here... */
        !           750:                lex.type = LEX_CHAR;
        !           751:                lex.value = 'a';
        !           752:                UnGet(lex);
        !           753:                Return(1);
        !           754:            }
        !           755:        } else if (GetCharacter('|')) {
        !           756:            ;           /* more names coming */
        !           757:        } else {
        !           758:            lex = Get();
        !           759:            UnGet(lex);
        !           760:            if (lex.type != LEX_END_OF_FILE) {
        !           761:                    if (!GetEntry0()) { /* start of an entry */
        !           762:                        fprintf(stderr, "error was in entry for %s in file %s\n",
        !           763:                            (oldName)? oldName->array:"(unknown)", filename);
        !           764:                    Return(0);
        !           765:                }
        !           766:            }
        !           767:        }
        !           768:        lex = Get();
        !           769:     }
        !           770:     fprintf(stderr, "Unable to find entry for %s in file %s\n", termPointer,
        !           771:                    filename);
        !           772:     Return(0);
        !           773: }
        !           774: /* InitControl - our interface to the outside.  What we should
        !           775:     do is figure out terminal type, set up file pointer (or string
        !           776:     pointer), etc.
        !           777:  */
        !           778: 
        !           779: state *
        !           780: InitControl()
        !           781: {
        !           782:     char *getenv();
        !           783:     int GotIt;
        !           784:     char *termPointer;
        !           785: 
        !           786:     environPointer = getenv("MAP3270");
        !           787: 
        !           788:     if ((!environPointer) || (*environPointer == '/')) {
        !           789:        usePointer = 0;
        !           790:        GotIt = 0;
        !           791: 
        !           792:        termPointer = getenv("TERM");
        !           793:        if (!termPointer) {
        !           794:            fprintf(stderr,
        !           795:                        "TERM environment variable (that defines the kind of terminal you are using)\n");
        !           796:            fprintf(stderr,
        !           797:                        "is not set.  To set it, say 'setenv TERM <type>'\n");
        !           798:        } else {
        !           799:            if (environPointer) {
        !           800:                GotIt = Position(environPointer, termPointer);
        !           801:            }
        !           802:            if (!GotIt) {
        !           803:                GotIt = Position("/etc/map3270", termPointer);
        !           804:            }
        !           805:        }
        !           806:        if (!GotIt) {
        !           807:            if (environPointer) {
        !           808:                GotIt = Position(environPointer, "unknown");
        !           809:            }
        !           810:            if (!GotIt) {
        !           811:                GotIt = Position("/etc/map3270", "unknown");
        !           812:            }
        !           813:        }
        !           814:        if (!GotIt) {
        !           815:            fprintf(stderr, "Using default key mappings.\n");
        !           816:            environPointer = keys3a;    /* use incore table */
        !           817:            usePointer = 1;             /* flag use of non-file */
        !           818:        }
        !           819:     } else {
        !           820:        usePointer = 1;
        !           821:     }
        !           822:     (void) GetEntry();
        !           823:     return(firstentry.address);
        !           824: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.