home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / program / termcap / tgetent.c < prev    next >
Encoding:
C/C++ Source or Header  |  1987-10-04  |  8.0 KB  |  325 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.  
  20. /*
  21.  *  LIBRARY FUNCTION
  22.  *
  23.  *    tgetent   load buffer with entry for specified terminal
  24.  *
  25.  *  KEY WORDS
  26.  *
  27.  *    termcap functions
  28.  *    utility routines
  29.  *
  30.  *  SYNOPSIS
  31.  *
  32.  *    int tgetent(bp,name)
  33.  *    char *bp;
  34.  *    char *name;
  35.  *
  36.  *  DESCRIPTION
  37.  *
  38.  *    Extracts the entry for terminal <name> from the termcap file
  39.  *    and places it in the character buffer <bp>.   It is currently
  40.  *    assumed that bp is at least 1024 characters.  If the entry in
  41.  *    the termcap file is larger than 1023 characters the excess
  42.  *    characters will be discarded and appropriate status will
  43.  *    be returned.
  44.  *
  45.  *    Also note that since bp is used by other termcap
  46.  *    routines, the storage associated with the termcap entry
  47.  *    cannot be freed until all termcap calls are completed.
  48.  *
  49.  *    Tgetent can be directed to look in a file other than
  50.  *    the default (/etc/termcap) by defining an environment
  51.  *    variable called TERMCAP to be the pathname of the desired
  52.  *    termcap file.  This is useful for debugging new entries.
  53.  *    NOTE: the pathname MUST begin with a '/' character.
  54.  *
  55.  *    Also, if the string assigned to TERMCAP does not begin with
  56.  *    a '/' and if the environment variable TERM matches <name> then
  57.  *    the string assigned to TERMCAP is copied to buffer <bp> 
  58.  *    instead of reading a termcap file.
  59.  *    
  60.  *  RETURNS
  61.  *
  62.  *    -1  if the termcap file cannot be opened
  63.  *     0  if no entry in termcap file matches <name>
  64.  *     1  if extraction is successful with no errors
  65.  *     2  if extraction is successful but entry truncated
  66.  *
  67.  *  SEE ALSO
  68.  *
  69.  *    tgetnum   extract numeric type capability
  70.  *    tgetflag  test boolean type capability
  71.  *    tgetstr   get string value of capability
  72.  *
  73.  *  AUTHOR
  74.  *
  75.  *    Fred Fish
  76.  *
  77.  */
  78.  
  79. #include <stdio.h>
  80.  
  81. #define TRUE 1
  82. #define FALSE 0
  83. #define BUFSIZE 1024            /* Assumed size of external buffer */
  84.  
  85. #define NO_FILE     -1            /* Returned if can't open file */
  86. #define NO_ENTRY  0            /* Returned if can't find entry */
  87. #define SUCCESS   1            /* Returned if entry found ok */
  88. #define TRUNCATED 2            /* Returned if entry found but trunc */
  89.  
  90. # ifdef DGK
  91. # define DEFAULT_ROOT "termcap"        /* name without path component */
  92.   FILE *fopenp();
  93. # endif
  94. # ifdef GEMDOS
  95. # define DEFAULT_FILE "\\etc\\termcap"
  96. # else
  97. # define DEFAULT_FILE "/etc/termcap"    /* default termcap filename */
  98. # endif
  99.  
  100. char *_tcpbuf;                /* Place to remember buffer pointer */
  101.  
  102. /*
  103.  *  PSEUDO CODE
  104.  *
  105.  *    Begin tgetent
  106.  *        Erase any previous buffer contents.
  107.  *        Remember the buffer pointer.
  108.  *        If termcap file is not found then
  109.  *        If buffer was filled anyway then
  110.  *            Return SUCCESS.
  111.  *        Else
  112.  *            Return NO_FILE.
  113.  *        End if
  114.  *        Else
  115.  *        While records left to process
  116.  *            If this is entry is what we want then
  117.  *            Close the termcap file.
  118.  *            If entry was truncated then
  119.  *                Return TRUNCATED status
  120.  *            Else
  121.  *                Return SUCCESS status.
  122.  *            End if
  123.  *            End if
  124.  *        End while
  125.  *        Return NO_ENTRY status.
  126.  *        End if
  127.  *    End tgetent
  128.  *            
  129.  */
  130.  
  131. int tgetent(bp,name)
  132. char *bp;                /* Pointer to buffer (1024 char min) */
  133. char *name;                /* Pointer to terminal entry to find */
  134. {
  135.     FILE *fp, *find_file();
  136.  
  137.     *bp = '\0';
  138.     _tcpbuf = bp;
  139.     if ((fp = find_file(bp)) == NULL) {
  140.     if (*bp != '\0') {
  141.         return(SUCCESS);
  142.     } else {
  143.         return(NO_FILE);
  144.     }
  145.     } else {
  146.     while (fgetlr(bp,BUFSIZE,fp)) {
  147.         if (gotcha(bp,name)) {
  148.         fclose(fp);
  149.         if (bp[strlen(bp)-1] != '\n') {
  150.             return(TRUNCATED);
  151.         } else {
  152.             return(SUCCESS);
  153.         }
  154.         }
  155.     }
  156.     return(NO_ENTRY);
  157.     }
  158. }
  159.  
  160. /*
  161.  *  INTERNAL FUNCTION
  162.  *
  163.  *    find_file    find the termcap file and open it if possible
  164.  *
  165.  *  KEY WORDS
  166.  *
  167.  *    internal functions
  168.  *    find_file
  169.  *
  170.  *  SYNOPSIS
  171.  *
  172.  *    static FILE *find_file(bp)
  173.  *    char *bp;
  174.  *
  175.  *  DESCRIPTION
  176.  *
  177.  *    Attempts to locate and open the termcap file.  Also handles
  178.  *    using the environment TERMCAP string as the actual buffer
  179.  *    (that's why bp has to be an input parameter).
  180.  *
  181.  *    If TERMCAP is defined an begins with a '/' character then
  182.  *    it is taken to be the pathname of the termcap file and
  183.  *    an attempt is made to open it.  If this fails then
  184.  *    the default termcap file is used instead.
  185.  *
  186.  *    If TERMCAP is defined but does not begin with a '/' then
  187.  *    it is assumed to be the actual buffer contents provided
  188.  *    that <name> matches the environment variable TERM.
  189.  *
  190.  *  BUGS
  191.  *
  192.  *    There is currently no way to be sure which termcap
  193.  *    file was opened since the default will always be
  194.  *    tried.
  195.  *
  196.  */
  197.  
  198. /*
  199.  *  PSEUDO CODE
  200.  *
  201.  *    Begin find_file
  202.  *        If there is a TERMCAP environment string then
  203.  *        If the string is not null then
  204.  *            If the string is a pathname then
  205.  *            If that file is opened successfully then
  206.  *                Return its pointer.
  207.  *            End if
  208.  *            Else
  209.  *            If there is a TERM environment string then
  210.  *                If TERM matches <name> then
  211.  *                Copy TERMCAP string to buffer.
  212.  *                Return NULL for no file.
  213.  *                End if
  214.  *            End if
  215.  *            End if
  216.  *        End if
  217.  *        End if
  218.  *        Open default termcap file and return results.
  219.  *    End find_file
  220.  *
  221.  */
  222.  
  223. static FILE *find_file(bp)
  224. char *bp;
  225. {
  226.     FILE *fp, *fopen();
  227.     char *cp, *ncp, *getenv();
  228.  
  229.     if ((cp = getenv("TERMCAP")) != NULL) {
  230.     if (*cp != '\0') {
  231.         if (*cp == '/' || *cp == '\\') {
  232.         if ((fp = fopen(cp,"r")) != NULL) {
  233.             return(fp);
  234.         }
  235.         } else {
  236.         if ((ncp = getenv("TERM")) != NULL) {
  237.             if (strcmp(cp,ncp) == 0) {
  238.             strcpy(bp,cp);
  239.             return((FILE *)NULL);
  240.             }
  241.         }
  242.         }
  243.     }
  244.     }
  245. # ifdef DGK
  246.     /* Try current directory, then /etc/termcap, then along the path
  247.      */
  248.     if (fp = fopen(DEFAULT_ROOT, "r"))
  249.         return fp;
  250.     else if (fp = fopen(DEFAULT_FILE, "r"))
  251.         return fp;
  252.     else
  253.         return fopenp(DEFAULT_ROOT, "r", NULL);
  254. # else
  255.     return(fopen(DEFAULT_FILE,"r"));
  256. # endif
  257. }
  258.  
  259. /*
  260.  *  INTERNAL FUNCTION
  261.  *
  262.  *    gotcha   test to see if entry is for specified terminal
  263.  *
  264.  *  SYNOPSIS
  265.  *
  266.  *    gotcha(bp,name)
  267.  *    char *bp;
  268.  *    char *name;
  269.  *
  270.  *  DESCRIPTION
  271.  *
  272.  *    Tests to see if the entry in buffer bp matches the terminal
  273.  *    specified by name.  Returns TRUE if match is detected, FALSE
  274.  *    otherwise.
  275.  *
  276.  */
  277.  
  278. /*
  279.  *  PSEUDO CODE
  280.  *
  281.  *    Begin gotcha
  282.  *        If buffer character is comment character then
  283.  *        Return FALSE since remainder is comment
  284.  *        Else
  285.  *        Initialize name scan pointer.
  286.  *        Compare name and buffer until end or mismatch.
  287.  *        If valid terminators for both name and buffer strings
  288.  *            Return TRUE since a match was found.
  289.  *        Else
  290.  *            Find next non-name character in buffer.
  291.  *            If not an alternate name separater character
  292.  *            Return FALSE since no more names to check.
  293.  *            Else
  294.  *            Test next name and return results.
  295.  *            End if
  296.  *        End if
  297.  *        End if
  298.  *    End gotcha
  299.  *
  300.  */
  301.  
  302. gotcha(bp,name)
  303. char *bp;
  304. char *name;
  305. {
  306.     char *np;
  307.  
  308.     if (*bp == '#') {
  309.     return(FALSE);
  310.     } else {
  311.     np = name;
  312.     while (*np == *bp && *np != '\0') {np++; bp++;}
  313.     if (*np == '\0' && (*bp == '\0' || *bp == '|' || *bp == ':')) {
  314.         return(TRUE);
  315.     } else {
  316.         while (*bp != '\0' && *bp != ':' && *bp != '|') {bp++;}
  317.         if (*bp != '|') {
  318.         return(FALSE);
  319.         } else {
  320.         return(gotcha(++bp,name));
  321.         }
  322.     }
  323.     }
  324. }
  325.