home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 410.lha / VAXterm_v2.4 / src / keymap.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-08  |  15.7 KB  |  381 lines
  1. #include <exec/types.h>
  2. #include <libraries/dos.h>
  3. #include <intuition/intuition.h>
  4. #include <devices/keymap.h>
  5. #include <proto/graphics.h>
  6.  
  7. #include "main.h"
  8. #include "keymap.h"
  9.  
  10. UBYTE ret[] = { 1,4,2,6,'\x0D','\x0A',SS3,'M' };
  11. UBYTE enter[] = { 2,4,1,6,SS3,'M','\x0D','\x0A' };
  12. csi_12(ccu,'A','2');
  13. csi_12(ccd,'B','5');
  14. csi_12(ccr,'C','6');
  15. csi_12(ccl,'D','4');
  16. ss3_12(acu,'A','2');
  17. ss3_12(acd,'B','5');
  18. ss3_12(acr,'C','6');
  19. ss3_12(acl,'D','4');
  20. UBYTE del[] = { 4,8,3,12,1,15,1,16,CSI,'2','9','~',CSI,'1','~',127,127 };
  21. UBYTE help[] = { 4,4,3,8,CSI,'2','8','~',CSI,'3','~' };
  22. csi_03(f1,0x8B,'2','3');
  23. csi_03(f2,0x8C,'2','4');
  24. csi_03(f3,0x93,'2','5');
  25. csi_03(f4,0x91,'2','6');
  26. csi_03(f5,0x92,'2','8');
  27. csi_33(f6,'1','7','2','9');
  28. css_31(f7,'1','8','3','1','P');
  29. css_31(f8,'1','9','3','2','Q');
  30. css_31(f9,'2','0','3','3','R');
  31. css_31(f10,'2','1','3','4','S');
  32. ss3_10(pf1,'P','[');
  33. ss3_10(pf2,'Q',']');
  34. ss3_10(pf3,'R','/');
  35. ss3_10(pf4,'S','*');
  36. ss3_10(nnum0,'0','p');
  37. ss3_10(nnum1,'1','q');
  38. ss3_10(nnum2,'2','r');
  39. ss3_10(nnum3,'3','s');
  40. ss3_10(nnum4,'4','t');
  41. ss3_10(nnum5,'5','u');
  42. ss3_10(nnum6,'6','v');
  43. ss3_10(nnum7,'7','w');
  44. ss3_10(nnum8,'8','x');
  45. ss3_10(nnum9,'9','y');
  46. ss3_10(nnumcomma,'+','l');
  47. ss3_10(nnumminus,'-','m');
  48. ss3_10(nnumperiod,'.','n');
  49. ss3_10(anum0,'p','0');
  50. ss3_10(anum1,'q','1');
  51. ss3_10(anum2,'r','2');
  52. ss3_10(anum3,'s','3');
  53. ss3_10(anum4,'t','4');
  54. ss3_10(anum5,'u','5');
  55. ss3_10(anum6,'v','6');
  56. ss3_10(anum7,'w','7');
  57. ss3_10(anum8,'x','8');
  58. ss3_10(anum9,'y','9');
  59. ss3_10(anumcomma,'l','+');
  60. ss3_10(anumminus,'m','-');
  61. ss3_10(anumperiod,'n','.');
  62.  
  63. UBYTE fkey[] = { 0,'f',0,'F',DPF_DEAD,DPF_R,DPF_DEAD,DPF_R,0,6,0,6,0,0x86,0,0x86 };
  64. UBYTE gkey[] = { 0,'g',0,'G',DPF_DEAD,DPF_L,DPF_DEAD,DPF_L,0,7,0,7,0,0x87,0,0x87 };
  65. UBYTE hkey[] = { 0,'h',0,'H',DPF_DEAD,DPF_H,DPF_DEAD,DPF_H,0,8,0,8,0,0x88,0,0x88 };
  66. UBYTE jkey[] = { 0,'j',0,'J',DPF_DEAD,DPF_A,DPF_DEAD,DPF_A,0,10,0,10,0,0x8A,0,0x8A };
  67. UBYTE kkey[] = { 0,'k',0,'K',DPF_DEAD,DPF_D,DPF_DEAD,DPF_D,0,11,0,11,0,0x8B,0,0x8B };
  68.  
  69. MKEY(akey,'\xe6','\xc6','a','\xe1','\xe0','\xe2','\xe3','\xe4','A','\xc1','\xc0','\xc2','\xc3','\xc4');
  70. MKEY(ekey,'\xa9','\xa9','e','\xe9','\xe8','\xea','e','\xeb','E','\xc9','\xc8','\xca','E','\xcb');
  71. MKEY(ikey,'\xa1','\xa6','i','\xed','\xec','\xee','i','\xef','I','\xcd','\xcc','\xce','I','\xcf');
  72. MKEY(okey,'\xf8','\xd8','o','o','\xf2','\xf4','\xf5','\xf6','O','O','\xd2','\xd4','\xd5','\xd6');
  73. MKEY(nkey,'\xad','\xaf','n','\xf1','n','n','n','n','N','\xd1','N','N','N','N');
  74. MKEY(ukey,'\xb5','\xb5','u','\xfa','\xf9','\xfb','u','\xfc','U','\xda','\xd9','\xdb','U','\xdc');
  75.  
  76. UBYTE aoacc[] = { DPF_DEAD,DPF_A,0,'\xb0' };
  77. UBYTE ahacc[] = { DPF_DEAD,DPF_A,DPF_DEAD,DPF_H };
  78. UBYTE rlacc[] = { DPF_DEAD,DPF_R,DPF_DEAD,DPF_L };
  79. UBYTE laacc[] = { DPF_DEAD,DPF_L,DPF_DEAD,DPF_A };
  80. UBYTE hdacc[] = { DPF_DEAD,DPF_H,DPF_DEAD,DPF_D };
  81. UBYTE lhacc[] = { DPF_DEAD,DPF_L,DPF_DEAD,DPF_H };
  82. UBYTE hlacc[] = { DPF_DEAD,DPF_H,DPF_DEAD,DPF_L };
  83. UBYTE dhacc[] = { DPF_DEAD,DPF_D,DPF_DEAD,DPF_H };
  84. UBYTE daacc[] = { DPF_DEAD,DPF_D,DPF_DEAD,DPF_A };
  85. UBYTE rdacc[] = { DPF_DEAD,DPF_R,DPF_DEAD,DPF_D };
  86. UBYTE caacc[] = { 0,'\xe7',DPF_DEAD,DPF_A };
  87. UBYTE ital8[] = { DPF_DEAD,DPF_H,0,'8' };
  88.  
  89. UBYTE lotypes[] = {
  90.     KCF_SHIFT|KCF_ALT,                              /* 0  ` */
  91.     KCF_SHIFT|KCF_ALT,                              /* 1  1 */
  92.     KCF_SHIFT|KCF_ALT,                              /* 2  2 */
  93.     KCF_SHIFT|KCF_ALT,                              /* 3  3 */
  94.     KCF_SHIFT|KCF_ALT,                              /* 4  4 */
  95.     KCF_SHIFT|KCF_CONTROL,                          /* 5  5 */
  96.     KCF_SHIFT|KCF_ALT,                              /* 6  6 */
  97.     KCF_SHIFT|KCF_ALT,                              /* 7  7 */
  98.     KCF_SHIFT|KCF_ALT,                              /* 8  8 */
  99.     KCF_SHIFT|KCF_ALT,                              /* 9  9 */
  100.     KCF_SHIFT|KCF_ALT,                              /* 10 0 */
  101.     KCF_SHIFT|KCF_ALT,                              /* 11 + */
  102.     KCF_SHIFT|KCF_ALT,                              /* 12 ' */
  103.     KCF_SHIFT|KCF_CONTROL,                          /* 13 \ */
  104.     0,                                              /* 14 */
  105.     KCF_SHIFT|KCF_STRING,                           /* 15 0N */
  106.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 16 q */
  107.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 17 w */
  108.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 18 e */
  109.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 19 r */
  110.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 20 t */
  111.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 21 y */
  112.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 22 u */
  113.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 23 i */
  114.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 24 o */
  115.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 25 p */
  116.     KCF_SHIFT|KCF_ALT,                              /* 26 [  */
  117.     KCF_SHIFT|KCF_ALT,                              /* 27 ] */
  118.     0,                                              /* 28 */
  119.     KCF_SHIFT|KCF_STRING,                           /* 29 1N */
  120.     KCF_SHIFT|KCF_STRING,                           /* 30 2N */
  121.     KCF_SHIFT|KCF_STRING,                           /* 31 3N */
  122.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 32 a */
  123.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 33 s */
  124.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 34 d */
  125.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 35 f */
  126.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 36 g */
  127.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 37 h */
  128.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 38 j */
  129.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 39 k */
  130.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 40 l */
  131.     KCF_SHIFT|KCF_ALT,                              /* 41 ö */
  132.     KCF_SHIFT|KCF_ALT,                              /* 42 ä */
  133.     KCF_SHIFT|KCF_ALT,                              /* 43 ' */
  134.     0,                                              /* 44 */
  135.     KCF_SHIFT|KCF_STRING,                           /* 45 4N */
  136.     KCF_SHIFT|KCF_STRING,                           /* 46 5N */
  137.     KCF_SHIFT|KCF_STRING,                           /* 47 6N */
  138.     KCF_SHIFT|KCF_ALT,                              /* 48 < */
  139.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 49 z */
  140.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 50 x */
  141.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 51 c */
  142.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 52 v */
  143.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 53 b */
  144.     KCF_SHIFT|KCF_CONTROL|KCF_ALT|KCF_DEAD,         /* 54 n */
  145.     KCF_SHIFT|KCF_CONTROL|KCF_ALT,                  /* 55 m */
  146.     KCF_SHIFT|KCF_ALT,                              /* 56 , */
  147.     KCF_SHIFT|KCF_ALT,                              /* 57 . */
  148.     KCF_SHIFT|KCF_ALT,                              /* 58 - */
  149.     0,                                              /* 59 */
  150.     KCF_SHIFT|KCF_STRING,                           /* 60 .N */
  151.     KCF_SHIFT|KCF_STRING,                           /* 61 7N */
  152.     KCF_SHIFT|KCF_STRING,                           /* 62 8N */
  153.     KCF_SHIFT|KCF_STRING };                         /* 63 9N */
  154.  
  155. ULONG *lokeymap[] = {
  156.     KEY('~','`','~','`'),           /* 0  ` */
  157.     KEY('!','1','!','1'),           /* 1  1 */
  158.     KEY('\xb0','2','@','2'),        /* 2  2 */
  159.     KEY('£','3','#','3'),           /* 3  3 */
  160.     KEY('$','4','$','4'),           /* 4  4 */
  161.     KEY('\x1e','\x1d','%','5'),     /* 5  5 */
  162.     KEY('^','6','^','6'),           /* 6  6 */
  163.     KEY('&','7','&','7'),           /* 7  7 */
  164.     KEY('*','8','*','8'),           /* 8  8 */
  165.     KEY('(','9','(','9'),           /* 9  9 */
  166.     KEY(')','0',')','0'),           /* 10 0 */
  167.     KEY('_','-','_','-'),           /* 11 + */
  168.     KEY('+','=','+','='),           /* 12 ' */
  169.     KEY(28,28,'|','\\'),            /* 13 \ */
  170.     NULKEY,                         /* 14 */
  171.     STR(&nnum0),                    /* 15 0N */
  172.     KEY('\xc5','\xe5','Q','q'),     /* 16 q */
  173.     KEY('\xb0','\xb0','W','w'),     /* 17 w */
  174.     STR(&ekey),                     /* 18 e */
  175.     KEY('\xae','\xae','R','r'),     /* 19 r */
  176.     KEY('\xde','\xfe','T','t'),     /* 20 t */
  177.     KEY('\xa5','\xa4','Y','y'),     /* 21 y */
  178.     STR(&ukey),                     /* 22 u */
  179.     STR(&ikey),                     /* 23 i */
  180.     STR(&okey),                     /* 24 o */
  181.     KEY('\xb6','\xb6','P','p'),     /* 25 p */
  182.     KEY('{','[','{','['),           /* 26 [  */
  183.     KEY('}',']','}',']'),           /* 27 ] */
  184.     NULKEY,                         /* 28 */
  185.     STR(&nnum1),                    /* 29 1N */
  186.     STR(&nnum2),                    /* 30 2N */
  187.     STR(&nnum3),                    /* 31 3N */
  188.     STR(&akey),                     /* 32 a */
  189.     KEY('\xa7','\xdf','S','s'),     /* 33 s */
  190.     KEY('\xd0','\xf0','D','d'),     /* 34 d */
  191.     STR(&fkey),                     /* 35 f */
  192.     STR(&gkey),                     /* 36 g */
  193.     STR(&hkey),                     /* 37 h */
  194.     STR(&jkey),                     /* 38 j */
  195.     STR(&kkey),                     /* 39 k */
  196.     KEY('\xa3','\xa3','L','l'),     /* 40 l */
  197.     KEY(':',';',':',';'),           /* 41 ö */
  198.     KEY('"','\x27','"','\x27'),     /* 42 ä */
  199.     KEY('|','\\','|','\\'),         /* 43 ' */
  200.     NULKEY,                         /* 44 */
  201.     STR(&nnum4),                    /* 45 4N */
  202.     STR(&nnum5),                    /* 46 5N */
  203.     STR(&nnum6),                    /* 47 6N */
  204.     KEY('\xbb','\xab','>','<'),     /* 48 < */
  205.     KEY('\xac','\xb1','Z','z'),     /* 49 z */
  206.     KEY('\xf7','\xd7','X','x'),     /* 50 x */
  207.     KEY('\xc7','\xe7','C','c'),     /* 51 c */
  208.     KEY('\xfd','\xaa','V','v'),     /* 52 v */
  209.     KEY('\xff','\xba','B','b'),     /* 53 b */
  210.     STR(&nkey),                     /* 54 n */
  211.     KEY('\xbf','\xb8','M','m'),     /* 55 m */
  212.     KEY(',',',',',',','),           /* 56 , */
  213.     KEY('.','.','.','.'),           /* 57 . */
  214.     KEY('?','/','?','/'),           /* 58 - */
  215.     NULKEY,                         /* 59 */
  216.     STR(&nnumperiod),               /* 60 .N */
  217.     STR(&nnum7),                    /* 61 7N */
  218.     STR(&nnum8),                    /* 62 8N */
  219.     STR(&nnum9) };                  /* 63 9N */
  220.  
  221. UBYTE locapsaple[] = { 0,0,0xFF,0x03,0xFF,0x07,0xFE,0 };
  222. UBYTE lorepeatable[] = { 0xFF,0x3F,0xFF,0x0F,0xFF,0x0F,0xFF,0x07 };
  223.  
  224. UBYTE hitypes[] = {
  225.     KCF_CONTROL,                    /* 64 SPC */
  226.     KC_NOQUAL,                      /* 65 BS */
  227.     KC_NOQUAL,                      /* 66 TAB */
  228.     KCF_STRING,                     /* 67 ENT */
  229.     KCF_STRING,                     /* 68 RET */
  230.     KC_NOQUAL,                      /* 69 ESC */
  231.     KCF_STRING|KCF_SHIFT|KCF_ALT,   /* 70 DEL */
  232.     0,                              /* 71 */
  233.     0,                              /* 72 */
  234.     0,                              /* 73 */
  235.     KCF_STRING|KCF_SHIFT,           /* 74 -N */
  236.     0,                              /* 75 */
  237.     KCF_STRING|KCF_SHIFT,           /* 76 UP */
  238.     KCF_STRING|KCF_SHIFT,           /* 77 DOWN */
  239.     KCF_STRING|KCF_SHIFT,           /* 78 FORWARD */
  240.     KCF_STRING|KCF_SHIFT,           /* 79 BACKWARD */
  241.     KCF_STRING|KCF_SHIFT,           /* 80 F1 */
  242.     KCF_STRING|KCF_SHIFT,           /* 81 F2 */
  243.     KCF_STRING|KCF_SHIFT,           /* 82 F3 */
  244.     KCF_STRING|KCF_SHIFT,           /* 83 F4 */
  245.     KCF_STRING|KCF_SHIFT,           /* 84 F5 */
  246.     KCF_STRING|KCF_SHIFT,           /* 85 F6 */
  247.     KCF_STRING|KCF_SHIFT|KCF_ALT,   /* 86 F7 */
  248.     KCF_STRING|KCF_SHIFT|KCF_ALT,   /* 87 F8 */
  249.     KCF_STRING|KCF_SHIFT|KCF_ALT,   /* 88 F9 */
  250.     KCF_STRING|KCF_SHIFT|KCF_ALT,   /* 89 F10 */
  251.     KCF_STRING|KCF_SHIFT,           /* 90 PF1 */
  252.     KCF_STRING|KCF_SHIFT,           /* 91 PF2 */
  253.     KCF_STRING|KCF_SHIFT,           /* 92 PF3 */
  254.     KCF_STRING|KCF_SHIFT,           /* 93 PF4 */
  255.     KCF_STRING|KCF_SHIFT,           /* 94 ,N (+) */
  256.     KCF_STRING|KCF_SHIFT,           /* 95 HELP */
  257.     KCF_NOP,                        /* 96 L SHIFT */
  258.     KCF_NOP,                        /* 97 R SHIFT */
  259.     KCF_NOP,                        /* 98 CAPS LOCK */
  260.     KCF_NOP,                        /* 99 CONTROL */
  261.     KCF_NOP,                        /* 100 L ALT */
  262.     KCF_NOP,                        /* 101 R ALT */
  263.     KCF_NOP,                        /* 102 L AMIGA */
  264.     KCF_NOP };                      /* 103 R AMIGA */
  265.  
  266. ULONG *hikeymap[] = {
  267.     KEY(0,0,0,' '),                 /* 64 SPC */
  268.     KEY(0,0,0,127),                 /* 65 BS */
  269.     KEY(0,0,0,9),                   /* 66 TAB */
  270.     STR(ret),                       /* 67 ENT */
  271.     STR(ret),                       /* 68 RET */
  272.     KEY(0,0,0,27),                  /* 69 ESC */
  273.     STR(del),                       /* 70 DEL */
  274.     NULKEY,                         /* 71 */
  275.     NULKEY,                         /* 72 */
  276.     NULKEY,                         /* 73 */
  277.     STR(&nnumminus),                /* 74 -N */
  278.     NULKEY,                         /* 75 */
  279.     STR(&ccu),                      /* 76 UP */
  280.     STR(&ccd),                      /* 77 DOWN */
  281.     STR(&ccr),                      /* 78 FORWARD */
  282.     STR(&ccl),                      /* 79 BACKWARD */
  283.     STR(&f1),                       /* 80 F1 */
  284.     STR(&f2),                       /* 81 F2 */
  285.     STR(&f3),                       /* 82 F3 */
  286.     STR(&f4),                       /* 83 F4 */
  287.     STR(&f5),                       /* 84 F5 */
  288.     STR(&f6),                       /* 85 F6 */
  289.     STR(&f7),                       /* 86 F7 */
  290.     STR(&f8),                       /* 87 F8 */
  291.     STR(&f9),                       /* 88 F9 */
  292.     STR(&f10),                      /* 89 F10 */
  293.     STR(&pf1),                      /* 90 PF1 */
  294.     STR(&pf2),                      /* 91 PF2 */
  295.     STR(&pf3),                      /* 92 PF3 */
  296.     STR(&pf4),                      /* 93 PF4 */
  297.     STR(&nnumcomma),                /* 94 ,N (+) */
  298.     STR(help),                      /* 95 HELP */
  299.     NULKEY,                         /* 96 L SHIFT */
  300.     NULKEY,                         /* 97 R SHIFT */
  301.     NULKEY,                         /* 98 CAPS LOCK */
  302.     NULKEY,                         /* 99 CONTROL */
  303.     NULKEY,                         /* 100 L ALT */
  304.     NULKEY,                         /* 101 R ALT */
  305.     NULKEY,                         /* 102 L AMIGA */
  306.     NULKEY };                       /* 103 R AMIGA */
  307.  
  308. UBYTE hicapsaple[] = { 0,0,0,0,0,0,0,0 };
  309. UBYTE hirepeatable[] = { 0x47,0xF4,0,0x40,0,0,0,0 };
  310.  
  311. struct KeyMap keymap = {
  312.     lotypes,(ULONG *)lokeymap,locapsaple,lorepeatable,
  313.     hitypes,(ULONG *)hikeymap,hicapsaple,hirepeatable };
  314.  
  315. entermode(int set)
  316. {
  317. if (set) {
  318.     ret[0] = 2;
  319.     enter[2] = 2;
  320.     }
  321. else {
  322.     ret[0] = 1;
  323.     enter[2] = 1;
  324.     }
  325. return(0);
  326. }
  327.  
  328. keypadmode(int set)
  329. {
  330. if (set) {
  331.     lokeymap[15] = STR(&anum0);
  332.     lokeymap[29] = STR(&anum1);
  333.     lokeymap[30] = STR(&anum2);
  334.     lokeymap[31] = STR(&anum3);
  335.     lokeymap[45] = STR(&anum4);
  336.     lokeymap[46] = STR(&anum5);
  337.     lokeymap[47] = STR(&anum6);
  338.     lokeymap[60] = STR(&anumperiod);
  339.     lokeymap[61] = STR(&anum7);
  340.     lokeymap[62] = STR(&anum8);
  341.     lokeymap[63] = STR(&anum9);
  342.     hikeymap[3]  = STR(enter);
  343.     hikeymap[10] = STR(&anumminus);
  344.     hikeymap[30] = STR(&anumcomma);
  345.     }
  346. else {
  347.     lokeymap[15] = STR(&nnum0);
  348.     lokeymap[29] = STR(&nnum1);
  349.     lokeymap[30] = STR(&nnum2);
  350.     lokeymap[31] = STR(&nnum3);
  351.     lokeymap[45] = STR(&nnum4);
  352.     lokeymap[46] = STR(&nnum5);
  353.     lokeymap[47] = STR(&nnum6);
  354.     lokeymap[60] = STR(&nnumperiod);
  355.     lokeymap[61] = STR(&nnum7);
  356.     lokeymap[62] = STR(&nnum8);
  357.     lokeymap[63] = STR(&nnum9);
  358.     hikeymap[3]  = STR(ret);
  359.     hikeymap[10] = STR(&nnumminus);
  360.     hikeymap[30] = STR(&nnumcomma);
  361.     }
  362. return(0);
  363. }
  364.  
  365. cursormode(int set)
  366. {
  367. if (set) {
  368.     hikeymap[12] = STR(&ccu);
  369.     hikeymap[13] = STR(&ccd);
  370.     hikeymap[14] = STR(&ccr);
  371.     hikeymap[15] = STR(&ccl);
  372.     }
  373. else {
  374.     hikeymap[12] = STR(&acu);
  375.     hikeymap[13] = STR(&acd);
  376.     hikeymap[14] = STR(&acr);
  377.     hikeymap[15] = STR(&acl);
  378.     }
  379. return(0);
  380. }
  381.