home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / EDITOR / MG2A_SRC.ZIP / TERMLIB / TGETENT.C < prev    next >
Encoding:
C/C++ Source or Header  |  1988-08-23  |  12.5 KB  |  467 lines
  1. /************************************************************************
  2.  *                                      *
  3.  *              Copyright (c) 1982, Fred Fish              *
  4.  *              All Rights Reserved                  *
  5.  *                                      *
  6.  *    This software and/or documentation is released for public          *
  7.  *    distribution for personal, non-commercial use only.          *
  8.  *    Limited rights to use, modify, and redistribute are hereby      *
  9.  *    granted for non-commercial purposes, provided that all          *
  10.  *    copyright notices remain intact and all changes are clearly     *
  11.  *    documented.  The author makes no warranty of any kind with      *
  12.  *    respect to this product and explicitly disclaims any implied    *
  13.  *    warranties of merchantability or fitness for any particular     *
  14.  *    purpose.                                  *
  15.  *                                      *
  16.  ************************************************************************
  17.  */
  18. /*
  19.  * Modified:
  20.  *    30-Apr-86 Mic Kaczmarczik ...!ihnp4!seismo!ut-sally!ut-ngp!mic
  21.  *        Instead of using VAX C getenv("TERM"), which does not
  22.  *        return the value of logical name "TERM", translate the
  23.  *        logical name by hand.
  24.  *    11-Oct-86 Mic Kaczmarczik ...!ihnp4!seismo!ut-sally!ut-ngp!mic
  25.  *        Support tc capability to allow the library to use standard
  26.  *        termcaps.  Rewrote tgetent to look for tc capability
  27.  *        and add new terminal definition to the caller's buffer.
  28.  *        This makes it rather possible to overflow the caller's
  29.  *        buffer, but the library doesn't make any claim that it
  30.  *        won't overwrite the buffer anyway...
  31.  *    27-Jan-88 Bob Larson  blarson@ecla.usc.edu
  32.  *        Add primos (__50SERIES) support.
  33.  *    1-Feb-88  Sandra Loosemore  (sandra@cs.utah.edu)
  34.  *          Change default termcap file for VMS to be the same place
  35.  *          that GNU puts it.
  36.  *    23-Apr-88 Bob Larson
  37.  *          merge primos and vms changes
  38.  */
  39.  
  40.  
  41.  
  42. /*
  43.  *  LIBRARY FUNCTION
  44.  *
  45.  *    tgetent    load buffer with entry for specified terminal
  46.  *
  47.  *  KEY WORDS
  48.  *
  49.  *    termcap functions
  50.  *    utility routines
  51.  *
  52.  *  SYNOPSIS
  53.  *
  54.  *    int tgetent(bp,name)
  55.  *    char *bp;
  56.  *    char *name;
  57.  *
  58.  *  DESCRIPTION
  59.  *
  60.  *    Extracts the entry for terminal <name> from the termcap file
  61.  *    and places it in the character buffer <bp>.   It is currently
  62.  *    assumed that bp is at least 1024 characters.  If the entry in
  63.  *    the termcap file is larger than 1023 characters the excess
  64.  *    characters will be discarded and appropriate status will
  65.  *    be returned.
  66.  *
  67.  *    Also note that since bp is used by other termcap
  68.  *    routines, the storage associated with the termcap entry
  69.  *    cannot be freed until all termcap calls are completed.
  70.  *
  71.  *    Tgetent can be directed to look in a file other than
  72.  *    the default (/etc/termcap) by defining an environment
  73.  *    variable called TERMCAP to be the pathname of the desired
  74.  *    termcap file.  This is useful for debugging new entries.
  75.  *    NOTE: the pathname MUST begin with a '/' character.
  76.  *
  77.  *    Also, if the string assigned to TERMCAP does not begin with
  78.  *    a '/' and if the environment variable TERM matches <name> then
  79.  *    the string assigned to TERMCAP is copied to buffer <bp>
  80.  *    instead of reading a termcap file.
  81.  *
  82.  *  RETURNS
  83.  *
  84.  *    -1  if the termcap file cannot be opened
  85.  *     0  if no entry in termcap file matches <name>
  86.  *     1  if extraction is successful with no errors
  87.  *     2  if extraction is successful but entry truncated
  88.  *
  89.  *  SEE ALSO
  90.  *
  91.  *    tgetnum    extract numeric type capability
  92.  *    tgetflag    test boolean type capability
  93.  *    tgetstr    get string value of capability
  94.  *
  95.  *  AUTHOR
  96.  *
  97.  *    Fred Fish
  98.  *
  99.  */
  100.  
  101. #include <stdio.h>
  102.  
  103. #define TRUE 1
  104. #define FALSE 0
  105. #define BUFSIZE 1024              /* Assumed size of external buffer */
  106.  
  107. #define NO_FILE           -1              /* Returned if can't open file */
  108. #define NO_ENTRY  0              /* Returned if can't find entry */
  109. #define SUCCESS      1              /* Returned if entry found ok */
  110. #define TRUNCATED 2              /* Returned if entry found but trunc */
  111.  
  112. #ifdef __50SERIES
  113. #define DEFAULT_FILE "mg*>termcap"
  114. #else
  115. #define DEFAULT_FILE "/etc/termcap"   /* default termcap filename */
  116. #ifdef          VAXC
  117. #define          index strchr
  118. #endif
  119. #endif
  120.  
  121. char *_tcpbuf;                  /* Place to remember buffer pointer */
  122. FILE *fp;                  /* Termcap file              */
  123. static FILE *find_file();
  124. extern char *index();
  125.  
  126. /*
  127.  *  PSEUDO CODE
  128.  *
  129.  *    Begin tgetent
  130.  *      Erase any previous buffer contents.
  131.  *      Remember the buffer pointer.
  132.  *      If termcap file is not found then
  133.  *          If buffer was filled anyway then
  134.  *          Return SUCCESS.
  135.  *          Else
  136.  *          Return NO_FILE.
  137.  *          End if
  138.  *      Else
  139.  *          Find entry associated with name
  140.  *          While an entry was found and limit not reached
  141.  *          If no tc capability found Then
  142.  *              Exit while loop with status = SUCCESS
  143.  *          Else
  144.  *              Call getent to get entry indicated by tc=
  145.  *              If entry not found then
  146.  *                  Exit loop with status != SUCCESS
  147.  *              End if
  148.  *              Concatenate entry into buffer
  149.  *          End If
  150.  *          End while
  151.  *      End if
  152.  *      Close termcap file
  153.  *      Return status code
  154.  *    End tgetent
  155.  *
  156.  */
  157.  
  158. static int getent();
  159.  
  160. int tgetent(bp,name)
  161. char *bp;
  162. char *name;
  163. {
  164.       char    *tc, *tcbufp, tcbuf[80], termbuf[BUFSIZE], *tgetstr();
  165.       char    *bufp, *cp;          /* current start of buffer      */
  166.       int     limit = 10;          /* maximum nesting          */
  167.       int     status;              /* return from getent()          */
  168.  
  169.       *bp = '\0';              /* clear buffer              */
  170.       _tcpbuf = bp;              /* save base of buffer          */
  171.  
  172.       /* Look for termcap file.     If NULL, find_file may have found a  */
  173.       /* a valid termcap string in the environment variable TERMCAP.  */
  174.       /* If non-null, attempt to find the entry in the termcap file   */
  175.  
  176.       if ((fp = find_file(bp)) == NULL) {
  177.           if (*bp != NULL)
  178.               return(SUCCESS);
  179.           else
  180.               return(NO_FILE);
  181.       }
  182.       status = getent(bp, name);/* look for main entry          */
  183.  
  184.       /* Start looking for tc capabilities in the termcap.  If
  185.        * found, concatenate the entry for the new terminal to the
  186.        * current buffer and try again.    To avoid infinite loops,
  187.        * allow only 10 loops through this process.
  188.        */
  189.       while ((status == SUCCESS) && limit--) {
  190.           /* look for tc capability.  If none found, exit loop    */
  191.           tcbufp = tcbuf;
  192.           if (((tc = tgetstr("tc",&tcbufp)) == NULL)
  193.             || (*tc == '\0')) {
  194.               status = SUCCESS;/* no more tc= entries */
  195.               break;
  196.           }
  197.  
  198.           /* Attempt to get next entry. Exit loop if unsuccessful */
  199.           if ((status = getent(termbuf, tcbuf)) != SUCCESS)
  200.               break;
  201.  
  202.           /* Copy new entry into buffer, right at "tc="          */
  203.           for (bufp = bp; *bufp; bufp++)          /* find tc=     */
  204.               if ((*bufp=='t') && (bufp[1]=='c') && (bufp[2]=='='))
  205.                   break;
  206.           if ((cp = index(termbuf,':')) == NULL)
  207.               cp = termbuf;
  208.           strcpy(bufp, cp + 1);
  209.       }
  210.  
  211.       /* close termcap file and return the status     */
  212.       fclose(fp);
  213.       return status;
  214. }
  215.  
  216.  
  217.  
  218.  
  219. /*
  220.  *  INTERNAL FUNCTION
  221.  *
  222.  *    getent    find termcap entry in termcap file
  223.  *
  224.  *  KEY WORDS
  225.  *
  226.  *    internal functions
  227.  *    getent
  228.  *
  229.  *  SYNOPSIS
  230.  *
  231.  *    static int getent(bp,name)
  232.  *    char *bp;
  233.  *    char *name;
  234.  *
  235.  *  DESCRIPTION
  236.  *
  237.  *    Getent is called by tgetent each time tgetent attempts to
  238.  *    read a capability from the termcap database file.     Places
  239.  *    the entry in the buffer pointed to by bp
  240.  *
  241.  *
  242.  *  PSEUDOCODE
  243.  *
  244.  *    Begin Getent
  245.  *      Seek to beginning of termcap file
  246.  *      Clear buffer
  247.  *      While records left to process
  248.  *          If this is entry is what we want then
  249.  *          If entry was truncated then
  250.  *              Return TRUNCATED status
  251.  *          Else
  252.  *              Return SUCCESS status.
  253.  *          End if
  254.  *          End if
  255.  *      End while
  256.  *      Return NO_ENTRY status.
  257.  *    End
  258.  */
  259.  
  260. static int getent(bp,name)
  261. char *bp;                  /* Pointer to buffer (1024 char min) */
  262. char *name;                  /* Pointer to terminal entry to find */
  263. {
  264.       *bp = '\0';              /* clear buffer              */
  265.       lseek(fileno(fp), 0L, 0l);      /* rewind termcap file          */
  266.  
  267.       while (fgetlr(bp,BUFSIZE,fp)) {
  268.           if (gotcha(bp,name)) {
  269.               if (bp[strlen(bp)-1] != '\n') {
  270.                   return(TRUNCATED);
  271.               } else {
  272.                   return(SUCCESS);
  273.               }
  274.           }
  275.       }
  276.       return(NO_ENTRY);
  277. }
  278.  
  279.  
  280.  
  281. /*
  282.  *  INTERNAL FUNCTION
  283.  *
  284.  *    find_file       find the termcap file and open it if possible
  285.  *
  286.  *  KEY WORDS
  287.  *
  288.  *    internal functions
  289.  *    find_file
  290.  *
  291.  *  SYNOPSIS
  292.  *
  293.  *    static FILE *find_file(bp)
  294.  *    char *bp;
  295.  *
  296.  *  DESCRIPTION
  297.  *
  298.  *    Attempts to locate and open the termcap file.  Also handles
  299.  *    using the environment TERMCAP string as the actual buffer
  300.  *    (that's why bp has to be an input parameter).
  301.  *
  302.  *    If TERMCAP is defined an begins with a '/' character then
  303.  *    it is taken to be the pathname of the termcap file and
  304.  *    an attempt is made to open it.  If this fails then
  305.  *    the default termcap file is used instead.
  306.  *
  307.  *    If TERMCAP is defined but does not begin with a '/' then
  308.  *    it is assumed to be the actual buffer contents provided
  309.  *    that <name> matches the environment variable TERM.
  310.  *
  311.  *  BUGS
  312.  *
  313.  *    There is currently no way to be sure which termcap
  314.  *    file was opened since the default will always be
  315.  *    tried.
  316.  *
  317.  */
  318.  
  319.  
  320.  
  321. /*
  322.  *  PSEUDO CODE
  323.  *
  324.  *    Begin find_file
  325.  *      If there is a TERMCAP environment string then
  326.  *          If the string is not null then
  327.  *          If the string is a pathname then
  328.  *              If that file is opened successfully then
  329.  *              Return its pointer.
  330.  *              End if
  331.  *          Else
  332.  *              If there is a TERM environment string then
  333.  *              If TERM matches <name> then
  334.  *                  Copy TERMCAP string to buffer.
  335.  *                  Return NULL for no file.
  336.  *              End if
  337.  *              End if
  338.  *          End if
  339.  *          End if
  340.  *      End if
  341.  *      Open default termcap file and return results.
  342.  *    End find_file
  343.  *
  344.  */
  345. #ifdef          __50SERIES
  346. static FILE *find_file(bp)
  347. char *bp;
  348. {
  349.     char *cp;
  350.     char *gvget();
  351.  
  352.     if((cp = gvget(".TERMCAP")) != NULL && *cp)
  353.     return fopen(cp, "r");
  354.     if((cp = gvget(".TERMCAP$")) != NULL && *cp)
  355.     return fopen(cp, "r");
  356.     return fopen(DEFAULT_FILE, "r");
  357. }
  358. #else
  359. #ifdef          VAXC
  360. char *trnlnm();
  361. #endif
  362.  
  363. static FILE *find_file(bp)
  364. char *bp;
  365. {
  366.     FILE *fp, *fopen();
  367.     char *cp, *ncp, *getenv(), vmsname[132];
  368.  
  369.     if ((cp = getenv("TERMCAP")) != NULL) {
  370.       if (*cp != NULL) {
  371.       if (*cp == '/') {
  372.           if ((fp = fopen(cp,"r")) != NULL) {
  373.           return(fp);
  374.           }
  375.       } else {
  376. #ifdef VAXC
  377.           if ((ncp = trnlnm("TERM")) != NULL) {
  378. #else
  379.           if ((ncp = getenv("TERM")) != NULL) {
  380. #endif
  381.           if (strcmp(cp,ncp) == 0) {
  382.               strcpy(bp,cp);
  383.               return((FILE *)NULL);
  384.           }
  385.           }
  386.       }
  387.       }
  388.     }
  389. #ifdef VAXC
  390.     if ((fp = fopen("emacs_library:[etc]termcap.dat","r")) != NULL)
  391.     return(fp);
  392. #endif
  393.     return(fopen(DEFAULT_FILE,"r"));
  394. }
  395. #endif /* __50SERIES */
  396.  
  397.  
  398.  
  399. /*
  400.  *  INTERNAL FUNCTION
  401.  *
  402.  *    gotcha   test to see if entry is for specified terminal
  403.  *
  404.  *  SYNOPSIS
  405.  *
  406.  *    gotcha(bp,name)
  407.  *    char *bp;
  408.  *    char *name;
  409.  *
  410.  *  DESCRIPTION
  411.  *
  412.  *    Tests to see if the entry in buffer bp matches the terminal
  413.  *    specified by name.  Returns TRUE if match is detected, FALSE
  414.  *    otherwise.
  415.  *
  416.  */
  417.  
  418.  
  419.  
  420. /*
  421.  *  PSEUDO CODE
  422.  *
  423.  *    Begin gotcha
  424.  *      If buffer character is comment character then
  425.  *          Return FALSE since remainder is comment
  426.  *      Else
  427.  *          Initialize name scan pointer.
  428.  *          Compare name and buffer until end or mismatch.
  429.  *          If valid terminators for both name and buffer strings
  430.  *          Return TRUE since a match was found.
  431.  *          Else
  432.  *          Find next non-name character in buffer.
  433.  *          If not an alternate name separater character
  434.  *              Return FALSE since no more names to check.
  435.  *          Else
  436.  *              Test next name and return results.
  437.  *          End if
  438.  *          End if
  439.  *      End if
  440.  *    End gotcha
  441.  *
  442.  */
  443.  
  444. gotcha(bp,name)
  445. char *bp;
  446. char *name;
  447. {
  448.     char *np;
  449.  
  450.     if (*bp == '#') {
  451.       return(FALSE);
  452.     } else {
  453.       np = name;
  454.       while (*np == *bp && *np != NULL) {np++; bp++;}
  455.       if (*np == NULL && (*bp == NULL || *bp == '|' || *bp == ':')) {
  456.       return(TRUE);
  457.       } else {
  458.       while (*bp != NULL && *bp != ':' && *bp != '|') {bp++;}
  459.       if (*bp != '|') {
  460.           return(FALSE);
  461.       } else {
  462.           return(gotcha(++bp,name));
  463.       }
  464.       }
  465.     }
  466. }
  467.