home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / COMM / MISC / SRC26_2.ZIP / SRC / HKEYSET.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-07-05  |  6.3 KB  |  261 lines
  1. /* -*- c-mode -*-  -*- outline -*-
  2.  *
  3. ** hkeyset: hkey key table set program
  4.  *
  5.  * Author: HIRANO Satoshi
  6.  * (C) 1990  Halca Computer Science Laboratory  TM
  7.  *            University of Tokyo
  8.  *
  9.  * Edition History:
  10.  * 1.1 90/04/30 Halca.Hirano creation
  11.  *
  12.  * NOTE:
  13.  *
  14.  *    When Compile hkeyset.c, don't pack struct to word boundary!
  15.  *
  16.  * Desctiption:
  17.  *
  18.  *   'hkeyset' reads the setup file made by the terminal emulator
  19.  *    software 'hterm' then copies its key table to keyboard environment
  20.  *  regident software 'hkey'.
  21.  *
  22.  */
  23.  
  24. static char version[] = "$Header: hkeyset.cv  1.4  90/07/05 03:06:08  hirano  Exp $";
  25.  
  26. #include <stdio.h>
  27. #include <fcntl.h>
  28. #include <string.h>
  29. #include <stdlib.h>
  30. #include <io.h>
  31. #include "config.h"
  32. #include "hterm.h"
  33. #include "option.h"
  34. #include "default.h"
  35. #include "version.h"
  36. #include "hkey.h"
  37.  
  38. #include "keytab98.h"
  39.  
  40. /*
  41. ** global variables
  42.  */
  43. #undef    TEST
  44. #define COMPAT_VERSION    0
  45.  
  46. struct setups setups;
  47. char hkeyVersion[] = HKEY_MARK;
  48. char usage[] = "\
  49. hkeyset: set hkey keytable by hterm setup file\n\
  50. usage: hkeyset <hterm setup file>\n";
  51. struct SREGS segRegs;
  52. union REGS rg;
  53.  
  54. void loadSetup(char *path);
  55. u_char FAR *searchHkey(void);
  56. u_char FAR *copyTable(u_char FAR *to, u_char *from, int count);
  57. int cmp(char far *x,char *y);
  58.  
  59. /*
  60. ** main(int argc, char **argv)
  61.  *
  62.  * program entry point
  63.  */
  64. main(argc, argv)
  65. char **argv;
  66. {
  67.     char *path;
  68.     u_char FAR *at;
  69.  
  70.     *strchr(hkeyVersion, '$') = '\0';        /* remove '$' from hkey1.2$ */
  71.  
  72.     path = *++argv;
  73.     if (argc != 2 || *path == '-') {
  74.         fprintf(stderr, usage);
  75.         exit(1);
  76.     }
  77.  
  78.     if ((at = searchHkey()) == 0) {
  79.         fprintf(stderr, "hkeyset: %s not found in memory\n", hkeyVersion);
  80.         exit(1);
  81.     }
  82. #ifdef TEST
  83.     fprintf(stderr, "key table at $%lx\n", at);
  84. #endif
  85.     loadSetup(path);
  86.  
  87.     at = copyTable(at, keySwapTable, sizeof(keySwapTable));
  88.     at = copyTable(at, anoshiftbl, sizeof(anoshiftbl));
  89.     at = copyTable(at, actrltbl, sizeof(actrltbl));
  90.     at = copyTable(at, ashiftbl, sizeof(ashiftbl));
  91.     at = copyTable(at, akanatbl, sizeof(akanatbl));
  92.     at = copyTable(at, ashkanatbl, sizeof(ashkanatbl));
  93.     at = copyTable(at, pnoshiftbl, sizeof(anoshiftbl));
  94.     at = copyTable(at, pctrltbl, sizeof(actrltbl));
  95.     copyTable(at, pshiftbl, sizeof(ashiftbl));
  96.     fprintf(stderr, "hkeyset: %s key table is updated.\n", hkeyVersion);
  97. }
  98.  
  99. /*
  100. ** loadSetup(char *path)
  101.  *
  102.  * Load key table from setup file made by hterm into hkeyset internal table.
  103.  * Version number is also checked.
  104.  */
  105. static void loadSetup(path)
  106. char *path;
  107. {    
  108.     int fd;
  109.  
  110.     if ((fd = open(path, O_RDONLY|O_BINARY)) < 0) {
  111.         fprintf(stderr, "hkeyset: can't open %s\n", path);
  112.         exit(1);
  113.     }
  114.     if (read(fd, (char *)&setups, sizeof(setups)) != sizeof(setups) ||
  115.             strcmp(setups.ids, "wet semaphore")) {
  116.         close(fd);
  117.         fprintf(stderr, "hkeyset: '%s' is not hterm set-up.\n", path);
  118.         exit(1);
  119.     }
  120.     if (setups.version != VERSION || setups.revision != REVISION || setups.edition != EDITION) {
  121.         fprintf(stderr, "hkeyset: set-up '%s' version mismatch.\n", path);
  122.         fprintf(stderr, "%s was delived from hterm%d.%d.%d but setup file was made by hterm%d.%d.%d.\n",
  123.             hkeyVersion, VERSION, REVISION, EDITION, setups.version, setups.revision, setups.edition);
  124.         if (setups.version *1000 + setups.revision *100 +setups.edition*10 < 
  125.             COMPAT_VERSION) {
  126.             fprintf(stderr, "hkey is too old. The key table is not changed.\n");
  127.             exit(1);        /* incompatible set-up file    */
  128.         }
  129.         fprintf(stderr, "OK, let's try to change the key table.\n");
  130.     }
  131.     read(fd, (char *)keySwapTable, sizeof(keySwapTable));
  132.     read(fd, (char *)NORMALFunkey, sizeof(NORMALFunkey));
  133.     read(fd, (char *)SHIFTFunkey, sizeof(SHIFTFunkey));
  134.     read(fd, (char *)NORMALPad, sizeof(NORMALPad));
  135.     read(fd, (char *)APPLPad, sizeof(APPLPad));
  136.     read(fd, (char *)anoshiftbl, sizeof(anoshiftbl));
  137.     read(fd, (char *)actrltbl, sizeof(actrltbl));
  138.     read(fd, (char *)ashiftbl, sizeof(ashiftbl));
  139.     read(fd, (char *)akanatbl, sizeof(akanatbl));
  140.     read(fd, (char *)pnoshiftbl, sizeof(pnoshiftbl));
  141.     read(fd, (char *)pctrltbl, sizeof(pctrltbl));
  142.     read(fd, (char *)pshiftbl, sizeof(pshiftbl));
  143.     read(fd, (char *)pctrltbl, sizeof(pctrltbl));
  144. }    
  145.  
  146. /*
  147. ** static char FAR *searchHkey()
  148.  *
  149.  * search hkey and return its key table address
  150.  * If not found, return NO
  151.  */
  152. static u_char FAR *searchHkey()
  153. {
  154.     struct _mcb {            /* memory control block */
  155.         char mark;
  156.         /* don't pack to baundary */
  157.         u_short psp;
  158.         u_short size;        /* paragraph size    */
  159.     } FAR *mcb;
  160.     short FAR *topMcb;
  161.     char FAR *p;
  162.     int found;
  163.     long size;
  164.     int i;
  165.  
  166.     /*
  167.      * get internal work area address
  168.      */
  169.     rg.h.ah = 0x52;
  170.     int86x(0x21, &rg, &rg, &segRegs);
  171.  
  172.     /*
  173.      * make top of MCB chain
  174.      */
  175.     FP_SEG(topMcb) = segRegs.es;
  176.     FP_OFF(topMcb) = rg.x.bx - 2;        /* mcb points first MCB address    */
  177.     FP_SEG(mcb) = *topMcb;
  178.     FP_OFF(mcb) = 0;
  179.  
  180.     /*
  181.      * find hkey
  182.      */
  183.     for (;;) {
  184.         if (mcb->mark == 'Z')            /* last MCB        */
  185.             break;
  186.         if (mcb->mark != 'M')             /* illegal MCB    */
  187.             break;
  188. #ifdef TEST
  189.         fprintf(stderr, "$%lx\n", mcb);
  190. #endif
  191.         /*
  192.          * found legal MCB, test whether hkey
  193.          * hkey sets its program name in its psp area (<$110).
  194.          */
  195.         size = mcb->size * 16;
  196.         found = NO;
  197.         for (p = (char FAR *)mcb, i = 0x110; --i > 0; p++, --size) {
  198.             if (cmp(p, hkeyVersion)) {
  199.                 found = YES;
  200.                 break;
  201.             }
  202.         }
  203.         if (found) {
  204.             /*
  205.              * search hkey keyword
  206.              * key tables just follow the keyword.
  207.              */
  208. #ifdef TEST
  209.             fprintf(stderr, "hkey found\n");
  210. #endif
  211.             found = NO;
  212.             for (; --size > 0; p++) {
  213.                 if (cmp(p, KEYTAB_MARK)) {
  214.                     found = YES;
  215.                     break;
  216.                 }
  217.             }
  218.             if (found)
  219.                 return((char FAR *)(p+6));        /* return keytable address    */
  220.         }
  221.  
  222.         /*
  223.          * try next mcb
  224.          */            
  225.         FP_SEG(mcb) = FP_SEG(mcb) + mcb->size + 1;
  226.         FP_OFF(mcb) = 0;
  227.     }
  228.     return((char FAR *)NO);        /* not found    */
  229. }
  230.  
  231. /*
  232. ** static char FAR *copyTable(char FAR *to, char *from, int count)
  233.  *
  234.  * copy keytable 'from' to 'to'
  235.  */
  236. static u_char FAR *copyTable(to, from, count)
  237. u_char FAR *to;
  238. u_char *from;
  239. int count;
  240. {
  241. #ifndef TEST
  242.     while (--count >= 0)
  243.         *to++ = *from++;
  244. #endif
  245.     return(to);
  246. }
  247.  
  248. /*
  249. ** static int cmp(register char FAR *x, register char *y)
  250.  *
  251.  * compare string
  252.  */
  253. static int cmp(x, y)
  254. register char FAR *x;
  255. register char *y;
  256. {
  257.     while (*y && (*y++ == *x++))
  258.         ;
  259.     return(*y == 0);
  260. }
  261.