home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / OSK / EFFO / forum7.lzh / C / FKEYS / fkeys.c < prev    next >
C/C++ Source or Header  |  1988-10-04  |  10KB  |  548 lines
  1. # include <stdio.h>
  2. # define U(x) x
  3. # define NLSTATE yyprevious=YYNEWLINE
  4. # define BEGIN yybgin = yysvec + 1 +
  5. # define INITIAL 0
  6. # define YYLERR yysvec
  7. # define YYSTATE (yyestate-yysvec-1)
  8. # define YYOPTIM 1
  9. # define YYLMAX 200
  10. # define output(c) putc(c,yyout)
  11. # define input() (((yytchar=yysptr>yysbuf?U(*--yysptr):getc(yyin))==13?(yylineno++,yytchar):yytchar)==EOF?0:yytchar)
  12. # define unput(c) {yytchar= (c);if(yytchar=='\n')yylineno--;*yysptr++=yytchar;}
  13. # define yymore() (yymorfg=1)
  14. # define ECHO fprintf(yyout, "%s",yytext)
  15. # define REJECT { nstr = yyreject(); goto yyfussy;}
  16. int yyleng; extern char yytext[];
  17. int yymorfg;
  18. extern char *yysptr, yysbuf[];
  19. int yytchar;
  20. FILE *yyin ={stdin}, *yyout ={stdout};
  21. extern int yylineno;
  22. struct yysvf { 
  23.     struct yywork *yystoff;
  24.     struct yysvf *yyother;
  25.     int *yystops;};
  26. struct yysvf *yyestate;
  27. extern struct yysvf yysvec[], *yybgin;
  28. /*  fkeys              ein Program um bei VT220-kompatiblen Terminals die Funktionstasten zu belegen */
  29. /*                                                                                                  */
  30. /*   Uwe Simon        2.10.88                                                                          */
  31.  
  32. #include <ctype.h>
  33. #define OK      10
  34. #define ERROR 11
  35. #define LOCK  12
  36. #define CLEAR 13
  37.  
  38. int key_tab[] = { 17,18,19,20,21,23,24,25,26,28,29,31,32,33,34};
  39.  
  40. char *handle_back(p)
  41. char *p;
  42. {
  43.     char c;
  44.     char h;
  45.     
  46.     p++;
  47.     h=toupper(*p);
  48.     p++;
  49.     if(isxdigit(h))
  50.     {
  51.         c=(h>='A')?h-'A'+10:h-'0';
  52.         h=toupper(*p);
  53.         if(isxdigit(h))
  54.         {
  55.             p++;
  56.             c = c<<4;
  57.             c |= (h>='A')?h-'A'+10:h-'0';
  58.         }
  59.     }
  60.     else
  61.     {
  62.         switch(toupper(h))
  63.         {
  64.             case 'N':
  65.                 c='\n';
  66.                 break;
  67.             
  68.             case 'T':
  69.                 c='\t';
  70.                 break;
  71.             
  72.             default:
  73.                 c=*p;
  74.                 break;
  75.         }
  76.     }
  77.     printf("%02x",c);
  78.     return(p);
  79.     
  80. }
  81.  
  82. char *handle_char(p)
  83. char *p;
  84. {
  85.     if(*p == '\\')
  86.         p=handle_back(p);
  87.     else
  88.     {
  89.         printf("%02x",*p);
  90.         p++;
  91.     }
  92.     return(p);
  93. }
  94.  
  95.  
  96. handle(s)
  97. char *s;
  98. {
  99.         int        key_nr;
  100.         int        nr;
  101.         char    *p;
  102.         
  103.         key_nr=atoi(s);   
  104.         p=index(s,'=');
  105.         p++;
  106.         printf("Key %d:%s\n",key_nr,p);
  107.         if((key_nr>=6) && (key_nr<=20))
  108.             nr=key_tab[key_nr-6];
  109.         else
  110.             nr=0;
  111.             
  112.         if(nr == 0)
  113.         {
  114.             printf("illegal Key-number %d\n",key_nr);
  115.             return;
  116.         }
  117.         
  118.         printf("%cP1;1|%d/",0x1b,nr);
  119.         while(*p && (*p != '\n'))
  120.             p= handle_char(p);
  121.             
  122.         printf("%c\\",0x1b);
  123.         fflush(stdout);
  124. }
  125.  
  126. line_nr(n)
  127. int n;
  128. {
  129.     printf("Line %d:",n);
  130. }
  131.  
  132.  
  133. usage()
  134. {
  135.     fprintf(stderr,"Syntax: fkeys [<path>]\n");
  136.     fprintf(stderr,"Function:set User-Defined Keys on VT220 Terminals\n");
  137.     fprintf(stderr,"Options: none\n");
  138.     exit(0);
  139. }
  140.  
  141.  
  142. yywrap()
  143. {
  144.     return(feof(stdin));
  145. }
  146.  
  147. main(argc, argv)
  148. int argc;
  149. char *argv[];
  150. {
  151.     int h;
  152.     int line=1;
  153.     
  154.     if(argc > 1)
  155.     {
  156.         if(strcmp(argv[1], "-?") == 0)
  157.             usage();
  158.             
  159.         if(freopen(argv[1],"r", stdin) == NULL) 
  160.         {
  161.             fprintf(stderr,"can't open %s\n", argv[1]);
  162.             exit(1);
  163.         }
  164.     }
  165.     cleareof(stdin);
  166.     
  167.     while(h=yylex())
  168.     {
  169.         switch(h)
  170.         {
  171.             case OK:
  172.                 handle(yytext);
  173.                 break;
  174.                 
  175.             case LOCK:
  176.                 printf("lock\n");
  177.                 printf("%cP1;0|%c\\",0x1b,0x1b);
  178.                 break;
  179.                 
  180.             case CLEAR:
  181.                 printf("clear\n");
  182.                 printf("%cP0;1|%c\\",0x1b,0x1b);
  183.                 break;
  184.             
  185.             default:
  186.                 line_nr(line);
  187.                 printf("Syntax-Error\n");
  188.                 break;
  189.         }
  190.         line++;
  191.     }
  192. }
  193. # define YYNEWLINE 13
  194. yylex(){
  195. int nstr; extern int yyprevious;
  196. while((nstr = yylook()) >= 0)
  197. yyfussy: switch(nstr){
  198. case 0:
  199. if(yywrap()) return(0); break;
  200. case 1:
  201.         ;
  202. break;
  203. case 2:
  204.     ;
  205. break;
  206. case 3:
  207.         return(CLEAR);
  208. break;
  209. case 4:
  210.         return(LOCK);
  211. break;
  212. case 5:
  213. return(OK);
  214. break;
  215. case 6:
  216. ;
  217. break;
  218. case -1:
  219. break;
  220. default:
  221. fprintf(yyout,"bad switch yylook %d",nstr);
  222. } return(0); }
  223. /* end of yylex */
  224. int yyvstop[] ={
  225. 0,
  226.  
  227. 1,
  228. 0,
  229.  
  230. 1,
  231. 0,
  232.  
  233. 6,
  234. 0,
  235.  
  236. 1,
  237. 0,
  238.  
  239. -2,
  240. 0,
  241.  
  242. 2,
  243. 0,
  244.  
  245. -5,
  246. 0,
  247.  
  248. 5,
  249. 0,
  250.  
  251. 4,
  252. 0,
  253.  
  254. 3,
  255. 0,
  256. 0};
  257. # define YYTYPE char
  258. struct yywork { YYTYPE verify, advance; } yycrank[] ={
  259. 0,0,    0,0,    0,0,    0,0,    
  260. 0,0,    0,0,    0,0,    0,0,    
  261. 0,0,    0,0,    0,0,    0,0,    
  262. 0,0,    0,0,    1,3,    0,0,    
  263. 0,0,    0,0,    0,0,    0,0,    
  264. 0,0,    0,0,    0,0,    0,0,    
  265. 0,0,    0,0,    0,0,    0,0,    
  266. 0,0,    0,0,    0,0,    0,0,    
  267. 0,0,    1,4,    4,4,    0,0,    
  268. 1,5,    0,0,    0,0,    0,0,    
  269. 0,0,    0,0,    0,0,    0,0,    
  270. 0,0,    0,0,    0,0,    0,0,    
  271. 0,0,    1,6,    1,6,    1,6,    
  272. 1,6,    1,6,    1,6,    1,6,    
  273. 1,6,    1,6,    1,6,    5,0,    
  274. 5,0,    5,0,    5,0,    5,0,    
  275. 5,0,    5,0,    5,0,    5,0,    
  276. 5,0,    5,0,    5,0,    5,9,    
  277. 5,0,    5,0,    5,0,    5,0,    
  278. 5,0,    5,0,    5,0,    5,0,    
  279. 5,0,    5,0,    5,0,    5,0,    
  280. 5,0,    5,0,    5,0,    5,0,    
  281. 5,0,    5,0,    5,5,    5,5,    
  282. 0,0,    0,0,    0,0,    0,0,    
  283. 0,0,    0,0,    0,0,    0,0,    
  284. 1,7,    0,0,    0,0,    0,0,    
  285. 0,0,    0,0,    5,5,    0,0,    
  286. 0,0,    1,8,    6,6,    6,6,    
  287. 6,6,    6,6,    6,6,    6,6,    
  288. 6,6,    6,6,    6,6,    6,6,    
  289. 7,11,    8,12,    0,0,    6,10,    
  290. 10,0,    10,0,    10,0,    10,0,    
  291. 10,0,    10,0,    10,0,    10,0,    
  292. 10,0,    10,0,    10,0,    10,0,    
  293. 10,13,    10,0,    10,0,    10,0,    
  294. 10,0,    10,0,    10,0,    10,0,    
  295. 10,0,    10,0,    10,0,    10,0,    
  296. 10,0,    10,0,    10,0,    10,0,    
  297. 10,0,    10,0,    10,0,    10,10,    
  298. 10,10,    11,14,    12,15,    14,16,    
  299. 15,17,    16,18,    0,0,    0,0,    
  300. 0,0,    0,0,    0,0,    0,0,    
  301. 0,0,    0,0,    0,0,    10,10,    
  302. 0,0,    0,0,    0,0,    0,0,    
  303. 0,0,    0,0,    0,0,    0,0,    
  304. 0,0,    0,0,    0,0,    0,0,    
  305. 0,0,    5,0,    0,0,    0,0,    
  306. 0,0,    0,0,    0,0,    0,0,    
  307. 0,0,    0,0,    0,0,    0,0,    
  308. 0,0,    0,0,    0,0,    0,0,    
  309. 0,0,    0,0,    0,0,    0,0,    
  310. 0,0,    0,0,    0,0,    0,0,    
  311. 0,0,    0,0,    0,0,    0,0,    
  312. 0,0,    0,0,    0,0,    0,0,    
  313. 0,0,    0,0,    0,0,    0,0,    
  314. 0,0,    0,0,    0,0,    0,0,    
  315. 0,0,    0,0,    0,0,    0,0,    
  316. 0,0,    0,0,    0,0,    0,0,    
  317. 0,0,    0,0,    0,0,    0,0,    
  318. 0,0,    0,0,    0,0,    0,0,    
  319. 0,0,    0,0,    0,0,    0,0,    
  320. 0,0,    0,0,    0,0,    0,0,    
  321. 0,0,    0,0,    10,0,    0,0,    
  322. 0,0};
  323. struct yysvf yysvec[] ={
  324. 0,    0,    0,
  325. yycrank+1,    0,        yyvstop+1,
  326. yycrank+0,    yysvec+1,    yyvstop+3,
  327. yycrank+0,    0,        yyvstop+5,
  328. yycrank+2,    0,        yyvstop+7,
  329. yycrank+-58,    0,        yyvstop+9,
  330. yycrank+62,    0,        0,    
  331. yycrank+12,    0,        0,    
  332. yycrank+10,    0,        0,    
  333. yycrank+0,    0,        yyvstop+11,
  334. yycrank+-123,    0,        yyvstop+13,
  335. yycrank+56,    0,        0,    
  336. yycrank+59,    0,        0,    
  337. yycrank+0,    0,        yyvstop+15,
  338. yycrank+62,    0,        0,    
  339. yycrank+53,    0,        0,    
  340. yycrank+47,    0,        0,    
  341. yycrank+0,    0,        yyvstop+17,
  342. yycrank+0,    0,        yyvstop+19,
  343. 0,    0,    0};
  344. struct yywork *yytop = yycrank+250;
  345. struct yysvf *yybgin = yysvec+1;
  346. char yymatch[] ={
  347. 00  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  348. 01  ,01  ,01  ,01  ,01  ,015 ,01  ,01  ,
  349. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  350. 01  ,01  ,01  ,01  ,01  ,01  ,01  ,01  ,
  351. 040 ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  352. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  353. '0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,'0' ,
  354. '0' ,'0' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  355. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  356. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  357. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  358. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  359. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  360. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  361. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,
  362. '!' ,'!' ,'!' ,'!' ,'!' ,'!' ,'!' ,01  ,
  363. 0};
  364. char yyextra[] ={
  365. 0,0,1,0,0,1,0,0,
  366. 0};
  367. /*    ncform    4.1    83/08/11    */
  368.  
  369. int yylineno =1;
  370. # define YYU(x) x
  371. # define NLSTATE yyprevious=YYNEWLINE
  372. char yytext[YYLMAX];
  373. struct yysvf *yylstate [YYLMAX], **yylsp, **yyolsp;
  374. char yysbuf[YYLMAX];
  375. char *yysptr = yysbuf;
  376. int *yyfnd;
  377. extern struct yysvf *yyestate;
  378. int yyprevious = YYNEWLINE;
  379. yylook(){
  380.     register struct yysvf *yystate, **lsp;
  381.     register struct yywork *yyt;
  382.     struct yysvf *yyz;
  383.     int yych;
  384.     struct yywork *yyr;
  385. # ifdef LEXDEBUG
  386.     int debug;
  387. # endif
  388.     char *yylastch;
  389.     /* start off machines */
  390. # ifdef LEXDEBUG
  391.     debug = 0;
  392. # endif
  393.     if (!yymorfg)
  394.         yylastch = yytext;
  395.     else {
  396.         yymorfg=0;
  397.         yylastch = yytext+yyleng;
  398.         }
  399.     for(;;){
  400.         lsp = yylstate;
  401.         yyestate = yystate = yybgin;
  402.         if (yyprevious==YYNEWLINE) yystate++;
  403.         for (;;){
  404. # ifdef LEXDEBUG
  405.             if(debug)fprintf(yyout,"state %d\n",yystate-yysvec-1);
  406. # endif
  407.             yyt = yystate->yystoff;
  408.             if(yyt == yycrank){        /* may not be any transitions */
  409.                 yyz = yystate->yyother;
  410.                 if(yyz == 0)break;
  411.                 if(yyz->yystoff == yycrank)break;
  412.                 }
  413.             *yylastch++ = yych = input();
  414.         tryagain:
  415. # ifdef LEXDEBUG
  416.             if(debug){
  417.                 fprintf(yyout,"char ");
  418.                 allprint(yych);
  419.                 putchar('\n');
  420.                 }
  421. # endif
  422.             yyr = yyt;
  423.             if ( (int)yyt > (int)yycrank){
  424.                 yyt = yyr + yych;
  425.                 if (yyt <= yytop && yyt->verify+yysvec == yystate){
  426.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  427.                         {unput(*--yylastch);break;}
  428.                     *lsp++ = yystate = yyt->advance+yysvec;
  429.                     goto contin;
  430.                     }
  431.                 }
  432. # ifdef YYOPTIM
  433.             else if((int)yyt < (int)yycrank) {        /* r < yycrank */
  434.                 yyt = yyr = yycrank+(yycrank-yyt);
  435. # ifdef LEXDEBUG
  436.                 if(debug)fprintf(yyout,"compressed state\n");
  437. # endif
  438.                 yyt = yyt + yych;
  439.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  440.                     if(yyt->advance+yysvec == YYLERR)    /* error transitions */
  441.                         {unput(*--yylastch);break;}
  442.                     *lsp++ = yystate = yyt->advance+yysvec;
  443.                     goto contin;
  444.                     }
  445.                 yyt = yyr + YYU(yymatch[yych]);
  446. # ifdef LEXDEBUG
  447.                 if(debug){
  448.                     fprintf(yyout,"try fall back character ");
  449.                     allprint(YYU(yymatch[yych]));
  450.                     putchar('\n');
  451.                     }
  452. # endif
  453.                 if(yyt <= yytop && yyt->verify+yysvec == yystate){
  454.                     if(yyt->advance+yysvec == YYLERR)    /* error transition */
  455.                         {unput(*--yylastch);break;}
  456.                     *lsp++ = yystate = yyt->advance+yysvec;
  457.                     goto contin;
  458.                     }
  459.                 }
  460.             if ((yystate = yystate->yyother) && (yyt= yystate->yystoff) != yycrank){
  461. # ifdef LEXDEBUG
  462.                 if(debug)fprintf(yyout,"fall back to state %d\n",yystate-yysvec-1);
  463. # endif
  464.                 goto tryagain;
  465.                 }
  466. # endif
  467.             else
  468.                 {unput(*--yylastch);break;}
  469.         contin:
  470. # ifdef LEXDEBUG
  471.             if(debug){
  472.                 fprintf(yyout,"state %d char ",yystate-yysvec-1);
  473.                 allprint(yych);
  474.                 putchar('\n');
  475.                 }
  476. # endif
  477.             ;
  478.             }
  479. # ifdef LEXDEBUG
  480.         if(debug){
  481.             fprintf(yyout,"stopped at %d with ",*(lsp-1)-yysvec-1);
  482.             allprint(yych);
  483.             putchar('\n');
  484.             }
  485. # endif
  486.         while (lsp-- > yylstate){
  487.             *yylastch-- = 0;
  488.             if (*lsp != 0 && (yyfnd= (*lsp)->yystops) && *yyfnd > 0){
  489.                 yyolsp = lsp;
  490.                 if(yyextra[*yyfnd]){        /* must backup */
  491.                     while(yyback((*lsp)->yystops,-*yyfnd) != 1 && lsp > yylstate){
  492.                         lsp--;
  493.                         unput(*yylastch--);
  494.                         }
  495.                     }
  496.                 yyprevious = YYU(*yylastch);
  497.                 yylsp = lsp;
  498.                 yyleng = yylastch-yytext+1;
  499.                 yytext[yyleng] = 0;
  500. # ifdef LEXDEBUG
  501.                 if(debug){
  502.                     fprintf(yyout,"\nmatch ");
  503.                     sprint(yytext);
  504.                     fprintf(yyout," action %d\n",*yyfnd);
  505.                     }
  506. # endif
  507.                 return(*yyfnd++);
  508.                 }
  509.             unput(*yylastch);
  510.             }
  511.         if (yytext[0] == 0  /* && feof(yyin) */)
  512.             {
  513.             yysptr=yysbuf;
  514.             return(0);
  515.             }
  516.         yyprevious = yytext[0] = input();
  517.         if (yyprevious>0)
  518.             output(yyprevious);
  519.         yylastch=yytext;
  520. # ifdef LEXDEBUG
  521.         if(debug)putchar('\n');
  522. # endif
  523.         }
  524.     }
  525. yyback(p, m)
  526.     int *p;
  527. {
  528. if (p==0) return(0);
  529. while (*p)
  530.     {
  531.     if (*p++ == m)
  532.         return(1);
  533.     }
  534. return(0);
  535. }
  536.     /* the following are only used in the lex library */
  537. yyinput(){
  538.     return(input());
  539.     }
  540. yyoutput(c)
  541.   int c; {
  542.     output(c);
  543.     }
  544. yyunput(c)
  545.    int c; {
  546.     unput(c);
  547.     }
  548.