home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / TELECOM / stg_v4.lzh / trm.c < prev    next >
C/C++ Source or Header  |  1994-11-13  |  9KB  |  446 lines
  1. /*
  2.  * termcap routines
  3.  * Copyright (c) 1990 by Scott Griepentrog
  4.  *
  5.  * 90/??/?? StG initial version, incompatible calls
  6.  * 91/04/08 StG updated for compat w/orig termlib & msdos
  7.  * 91/07/18 StG re-installed into new DB9 library
  8.  * 91/07/28 StG cleaned up variable names, coding
  9.  *
  10.  * Functions defined:
  11.  * _TrmName(pcBuf,pcName)     - internal function to search for terminal name
  12.  * _Trm(pcName)               - call to load termcap info (ERR=not found)
  13.  * char * _TrmString(pcCode)  - returns string for given code (0=not found)
  14.  * int _TrmNumber(pcCode)     - returns numeric value for given code (0=none)
  15.  * char * _TrmConvert(pcFix)  - returns string converted from contol sequences
  16.  * char * _TrmGoXY(iX,iY)     - returns string to do cursor motion to position
  17.  * _TrmWrite(hPath,pcBuf)     - converts and writes string to path
  18.  * _TrmWrCode(hPath,pcCode)   - sends converted code to path
  19.  * _TrmWrXY(hPath,iX,iY)      - sends cursor motion to path
  20.  *
  21. */
  22.  
  23. #define ERR (-1)
  24.  
  25. #include "db9.h"
  26. #include "trm.h"
  27. #include "stglib.h" /* PrJ - 94/11/13 */
  28.  
  29. extern int errno;
  30.  
  31. #define TERMFILE "termcap"
  32.  
  33. #ifdef OSK
  34. #define TERMDIR1 "/dd/sys/"
  35. #define TERMDIR2 "/h0/sys/"
  36. #define TERMDIR3 "/d0/sys/"
  37. #define OPENOPTS 1
  38. #endif
  39.  
  40. #ifdef __MSDOS__
  41. #define TERMDIR1 "C:\\SYS\\"
  42. #define OPENOPTS O_RDONLY
  43. #else
  44. char *malloc();
  45. #endif
  46.  
  47. #ifdef _UNIX
  48. #include <fcntl.h>
  49. #define TERMDIR1 "/etc/"
  50. #define OPENOPTS O_RDONLY
  51. #define readln fastln
  52. #endif
  53.  
  54. #ifndef OPENOPTS
  55. #define OPENOPTS 1
  56. #endif
  57.  
  58. #define MAXTRMBUF 256
  59.  
  60. char _TrmBuf[MAXTRMBUF];
  61. int _TrmLen=0;
  62.  
  63. struct sTrmCap
  64. {
  65.     struct sTrmCap *psNext;
  66.     short wCode;
  67.     short nNumber;
  68.     char *pcString;
  69. };
  70.  
  71. struct sTrmCap *_psTermRoot=0;
  72. char *_Trm_CM=0;
  73. int _Trm_LI=0;
  74. int _Trm_CO=0;
  75.  
  76. /* internal function to find terminal name in entry */
  77. int
  78. _TrmName(pcBuf,pcName)
  79. char *pcBuf,*pcName;
  80. {
  81.     char *p;
  82.  
  83. nxtstr:
  84.     p=pcName;
  85.  
  86.     while (*pcBuf && *pcBuf!='|' && *pcBuf==*p)
  87.     {
  88.         pcBuf++;
  89.         p++;
  90.     }
  91.     if (*pcBuf=='|' && !*p) return(0);
  92.     if (*pcBuf==':' && !*p) return(0);
  93.  
  94.     while (*pcBuf && *pcBuf!='|') pcBuf++;
  95.     if (!*pcBuf)
  96.         return(ERR);
  97.  
  98.     pcBuf++;
  99.     goto nxtstr;
  100. }
  101.  
  102. /* locate and load terminal definition */
  103. _Trm(pcName)
  104. char *pcName;
  105. {
  106.     int hFile;
  107.     int iTemp;
  108.     char *pcTemp;
  109.     struct sTrmCap *_psTerm;
  110.  
  111.     if (!pcName)
  112.     {
  113.         errno=DE_NOTERM;
  114.         return(ERR);
  115.     }
  116.  
  117.     while (_psTermRoot)
  118.     {
  119.         _psTerm=_psTermRoot;
  120.         free(_psTermRoot);
  121.         _psTermRoot=_psTerm->psNext;
  122.     }
  123.     _Trm_CM=0;
  124.     _Trm_LI=_Trm_CO=0;
  125.  
  126.     strcpy(_TrmBuf,TERMFILE);
  127.     hFile=open(_TrmBuf,OPENOPTS);
  128.     if (hFile!=ERR)
  129.         goto trmagn;
  130.  
  131. #ifdef TERMDIR1
  132.     strcpy(_TrmBuf,TERMDIR1);
  133.     strcat(_TrmBuf,TERMFILE);
  134.     hFile=open(_TrmBuf,OPENOPTS);
  135.     if (hFile!=ERR)
  136.         goto trmagn;
  137. #ifdef TERMDIR2
  138.     strcpy(_TrmBuf,TERMDIR2);
  139.     strcat(_TrmBuf,TERMFILE);
  140.     hFile=open(_TrmBuf,OPENOPTS);
  141.     if (hFile!=ERR)
  142.         goto trmagn;
  143. #ifdef TERMDIR3
  144.     strcpy(_TrmBuf,TERMDIR3);
  145.     strcat(_TrmBuf,TERMFILE);
  146.     hFile=open(_TrmBuf,OPENOPTS);
  147.     if (hFile!=ERR)
  148.         goto trmagn;
  149. #endif
  150. #endif
  151. #endif
  152.  
  153. /*
  154.     writeln(2,"ERROR: cant open termcap file: ",31);
  155. #ifdef TERMDIR1
  156.     writeln(2,TERMDIR1,strlen(TERMDIR1));
  157. #endif
  158.     writeln(2,TERMFILE,strlen(TERMFILE));
  159.     writeln(2,"\n",1);
  160.     exit(errno);
  161. */
  162.     return(ERR);
  163.  
  164.  
  165. trmagn:
  166.     while ((iTemp=readln(hFile,_TrmBuf,MAXTRMBUF))>0)
  167.     {
  168.         *(_TrmBuf+iTemp-1)=0;
  169.         if (!*_TrmBuf || *_TrmBuf=='#') continue;
  170.  
  171.         if (!_TrmName(_TrmBuf,pcName)) goto trmfnd;
  172.     }
  173. trmerr:
  174.     close(hFile);
  175.     errno=DE_TERMNF;
  176.     return(ERR);
  177.  
  178. trmred:
  179.     iTemp=readln(hFile,_TrmBuf,MAXTRMBUF);
  180.     if (iTemp<=0) goto trmerr;
  181.     *(_TrmBuf+iTemp-1)=0;
  182.  
  183. trmfnd:
  184.     pcTemp=_TrmBuf;
  185.     while (*pcTemp && *pcTemp!=':') pcTemp++;
  186.     if (*pcTemp) pcTemp++;
  187.  
  188. trmnxt:
  189.     if (!*pcTemp) goto trmok;
  190.     if (*pcTemp=='\\') goto trmred;
  191.  
  192.     iTemp=0;
  193.     while (*pcTemp && *pcTemp!=':')
  194.     {
  195.         iTemp++;
  196.         pcTemp++;
  197.     }
  198.  
  199.     if (iTemp<2) goto trmerr;
  200.     pcTemp-=iTemp;
  201.  
  202.     _psTerm=(struct sTrmCap *)malloc(sizeof(*_psTerm));
  203.     if (!_psTerm) goto trmerr;
  204.     _psTerm->nNumber=0;
  205.     _psTerm->pcString=0;
  206. /*     _psTerm->wCode=*(short *)pcTemp;  - causes addr trap on move.w (a0),4(a1) ?!? */
  207.     _psTerm->wCode=(*pcTemp<<8)|*(pcTemp+1);
  208.     pcTemp+=2;
  209.     iTemp-=2;
  210.  
  211.     if (!iTemp) _psTerm->nNumber=1;
  212.     else if (*pcTemp=='#') _psTerm->nNumber=atoi(pcTemp+1);
  213.     else if (*pcTemp!='=') goto trmerr;
  214.     else
  215.     {
  216.         if (_psTerm->wCode==0x7463)
  217.         {
  218.             *(pcTemp+iTemp)=0;
  219.             pcName=malloc(strlen(pcTemp));
  220.             strcpy(pcName,pcTemp+1);
  221.             free(_psTerm);
  222.             lseek(hFile,0L,0);
  223.             goto trmagn;
  224.         }
  225.         _psTerm->pcString=malloc(iTemp);
  226.         if (!_psTerm->pcString) goto trmerr;
  227.         strncpy(_psTerm->pcString,pcTemp+1,iTemp-1);
  228.         *(_psTerm->pcString+iTemp-1)=0;
  229.  
  230.     }
  231.  
  232.     if (_psTerm->wCode==0x636d) _Trm_CM=_psTerm->pcString;
  233.     if (_psTerm->wCode==0x6c69) _Trm_LI=_psTerm->nNumber;
  234.     if (_psTerm->wCode==0x636f) _Trm_CO=_psTerm->nNumber;
  235.  
  236.     pcTemp+=iTemp;
  237.     if (*pcTemp) pcTemp++;
  238.  
  239.     _psTerm->psNext=_psTermRoot;
  240.     _psTermRoot=_psTerm;
  241.  
  242.     goto trmnxt;
  243.  
  244. trmok:
  245.     close(hFile);
  246.     return(0);
  247. }
  248.  
  249. /* return pointer to string for code */
  250. char *
  251. _TrmString(pcCode)
  252. char *pcCode;
  253. {
  254.     struct sTrmCap *_psTerm;
  255.  
  256.     _psTerm=_psTermRoot;
  257.     while (_psTerm)
  258.     {
  259. /*        if (*(short *)pcCode==_psTerm->wCode) break;  arg!! */
  260.         if ( (((*pcCode)<<8)|*(pcCode+1))==_psTerm->wCode) break;
  261.         _psTerm=_psTerm->psNext;
  262.     }
  263.     if (_psTerm) return(_psTerm->pcString);
  264.     return(0);
  265. }
  266.  
  267. /* return integer value for code */
  268. int
  269. _TrmNumber(pcCode)
  270. char *pcCode;
  271. {
  272.     struct sTrmCap *_psTerm;
  273.  
  274.     _psTerm=_psTermRoot;
  275.     while (_psTerm)
  276.     {
  277. /*         if (*(short *)pcCode==_psTerm->wCode) break; */
  278.         if ( (((*pcCode)<<8)|*(pcCode+1))==_psTerm->wCode) break;
  279.         _psTerm=_psTerm->psNext;
  280.     }
  281.     if (_psTerm) return(_psTerm->nNumber);
  282.     return(0);
  283. }
  284.  
  285.  
  286. /* process coded string to real escape sequences */
  287. char *
  288. _TrmConvert(pcFix)
  289. char *pcFix;
  290. {
  291.     char *pcTemp;
  292.  
  293.     if (!pcFix) return(0);
  294.     while (*pcFix && *pcFix>='0' && *pcFix<='9') pcFix++;
  295.     if (*pcFix=='.') pcFix++;
  296.     while (*pcFix && *pcFix>='0' && *pcFix<='9') pcFix++;
  297.     if (*pcFix=='*') pcFix++;
  298.  
  299.     pcTemp=_TrmBuf;
  300.     while (*pcFix)
  301.     {
  302.         if (*pcFix=='\\')
  303.         {
  304.             switch (*++pcFix)
  305.             {
  306.             case 'E': *pcTemp++=0x1b; break;
  307.             case 'n': *pcTemp++=0x0a; break;
  308.             case 'r': *pcTemp++=0x0d; break;
  309.             case 't': *pcTemp++=0x09; break;
  310.             case 'b': *pcTemp++=0x08; break;
  311.             case 'f': *pcTemp++=0x0c; break;
  312.  
  313.             case '0':
  314.             case '1':
  315.             case '2':
  316.             case '3':
  317.                 *pcTemp=*pcFix-'0';
  318.                 if (*(pcFix+1)>='0' && *(pcFix+1)<='7')
  319.                 {
  320.                     (*pcTemp)<<=3;
  321.                     *pcTemp+=(*++pcFix)-'0';
  322.                     if (*(pcFix+1)>='0' && *(pcFix+1)<='7')
  323.                     {
  324.                         (*(unsigned char *)pcTemp)<<=3;
  325.                         (*(unsigned char *)pcTemp)+=(*++pcFix)-'0';
  326.                     }
  327.                 }
  328.                 pcTemp++;
  329.                 break;
  330.  
  331.             default: *pcTemp++=*pcFix;
  332.             }
  333.         }
  334.         else
  335.         {
  336.             if (*pcFix=='^' && pcFix[1])
  337.                 *pcTemp++=(*++pcFix)-'@';
  338.             else
  339.                 *pcTemp++=*pcFix;
  340.         }
  341.         pcFix++;
  342.     }
  343.     *pcTemp=0;
  344.     _TrmLen=pcTemp-_TrmBuf;
  345.  
  346.     return(_TrmBuf);
  347. }
  348.  
  349. char *
  350. _TrmGoXY(iX,iY)
  351. int iX,iY;
  352. {
  353.     char *pcCM,*pcTemp;
  354.     int iTemp;
  355.  
  356.     if (iX<0) iX+=(_Trm_CO?_Trm_CO:80);
  357.     if (iY<0) iY+=(_Trm_LI?_Trm_LI:24);
  358.  
  359.     pcCM=_Trm_CM;
  360.     if (!pcCM)
  361.         return(0);
  362.  
  363.     pcTemp=_TrmBuf;
  364.     while (*pcCM)
  365.     {
  366.         if (*pcCM=='%')
  367.         {
  368.             switch (*++pcCM)
  369.             {
  370.             case 'i': iX+=1; iY+=1; break;
  371.             case '.': *pcTemp++=iY; iTemp=iX; iX=iY; iY=iTemp; break;
  372.             case '+': *pcTemp++=iY+(*++pcCM); iTemp=iX; iX=iY; iY=iTemp; break;
  373.             case '3':
  374.                 if (iY<100) *pcTemp++='0';
  375.             case '2':
  376.                 if (iY<10) *pcTemp++='0';
  377.             case 'd':
  378.                 if (iY>99) *pcTemp++='0'+iY/100;
  379.                 if (iY>9) *pcTemp++='0'+(iY/10)%10;
  380.                 *pcTemp++='0'+iY%10;
  381.             case 'r': iTemp=iX; iX=iY; iY=iTemp; break;
  382.             default: *pcTemp++=*pcCM;
  383.             }
  384.         }
  385.         else
  386.         if (*pcCM=='\\')
  387.         {
  388.             switch (*++pcCM)
  389.             {
  390.             case 'E': *pcTemp++=0x1b; break;
  391.             case 'n': *pcTemp++=0x0a; break;
  392.             case 'r': *pcTemp++=0x0d; break;
  393.             case 't': *pcTemp++=0x09; break;
  394.             case 'b': *pcTemp++=0x08; break;
  395.             case 'f': *pcTemp++=0x0c; break;
  396.             case '0': *pcTemp=0;
  397.             case '1': *pcTemp=0x40;
  398.             case '2': *pcTemp=0x00;
  399.             case '3': *pcTemp=0x40;
  400.                 *pcTemp|=((*++pcCM)&7)<<3;
  401.                 *pcTemp|=(*++pcCM)&7;
  402.                 break;
  403.             default: *pcTemp++=*pcCM;
  404.             }
  405.         }
  406.         else
  407.             if (*pcCM=='^' && pcCM[1]) 
  408.                 *pcTemp++=(*++pcCM)-'@';
  409.             else
  410.                 *pcTemp++=*pcCM;
  411.         pcCM++;
  412.     }
  413.     *pcTemp=0;
  414.     _TrmLen=pcTemp-_TrmBuf;
  415.  
  416.     return(_TrmBuf);
  417. }
  418.  
  419. /* write unconverted string */
  420. _TrmWrite(hPath,pcBuf)
  421. int hPath;
  422. char *pcBuf;
  423. {
  424.     _TrmConvert(pcBuf);
  425.     write(hPath,_TrmBuf,_TrmLen);
  426.     return(0);
  427. }
  428.  
  429. _TrmWrCode(hPath,pcCode)
  430. int hPath;
  431. char *pcCode;
  432. {
  433.     _TrmConvert(_TrmString(pcCode));
  434.     write(hPath,_TrmBuf,_TrmLen);
  435.     return(0);
  436. }
  437.  
  438. /* write sequence to goto x,y */
  439. _TrmWrXY(hPath,iX,iY)
  440. int hPath,iX,iY;
  441. {
  442.     _TrmConvert(_TrmGoXY(iX,iY));
  443.     write(hPath,_TrmBuf,_TrmLen);
  444.     return(0);
  445. }
  446.