home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / simtel / emacs / src / srcdist.lbr / MECONFIG.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-13  |  7.9 KB  |  332 lines
  1. #include "stdio.h"
  2. #include "fcntl.h"
  3.  
  4. #define NEEDNAME 8
  5. int gotname;        /* we have to fine NEEDNAME names in ME.SYM */
  6.  
  7. #define    METACH    0x1B            /* M- prefix,   Control-[, ESC    */
  8. #define CMINUSCH 0x1c
  9.  
  10. #define    META    0x0200            /* Meta flag, or'ed in        */
  11. #define    CTLX    0x0400            /* ^X flag, or'ed in        */
  12.  
  13. typedef    struct
  14. {    short    k_code;            /* Key code            */
  15.     int    (*k_fp)();        /* Routine to handle it        */
  16. }    KEYTAB;
  17.  
  18. typedef struct
  19. {    short k_code;        /* same as KEYTAB */
  20.     char  ovcode;        /* which overlay. */
  21.     char ovparm;        /* which routine in overlay. */
  22. }    OVERTAB;
  23.  
  24. KEYTAB    * pMyKeytab;    /* where I will malloc() my version. */
  25. int myNKEYTAB;        /* contents of NKEYTAB from me.com */
  26. int pkeytab;        /* address of keytab[] in me.com */
  27. int pNKEYTAB;        /* address of NKEYTAB in me.com */
  28. char * NKname = "NKEYTAB_";    /* name of NKEYTAB in me.sym */
  29. char * KTname = "keytab_";    /* name of keytab[] in me.sym */
  30.  
  31. OVERTAB * pMyOvertab;
  32. int myNOVERTAB;
  33. int povertab;
  34. int pNOVERTAB;
  35. char * NOname = "NOVERTAB";
  36. char * OTname = "overtab_";
  37.  
  38. struct bitab
  39. {    /* built-in commands. */
  40.     char * bifname;        /* name in ME.SYM */
  41.     int (*biffunc)();    /* Address from ME.SYM */
  42.     char * biUECSname;    /* UECS name. */
  43.     int biUM;        /* UM/UECS mapping. */
  44.     int biUECS;        /* UECS number. */
  45. } bi [] =
  46. {    /* static initializers. */
  47.     {    "ctrlg_"  , 0, "CI-Abort-Cancel",  7, 11 },
  48.     {    "backchar", 0, "EC-Arrow-Left",    8, 80 },
  49.     {    "forwchar", 0, "EC-Arrow-Right",  12, 81 },
  50.     {    "linsert_", 0, "EC-Self_Insert",  -1, 245 },
  51.     {    "", 0, "", -1, -1 }
  52. };
  53.  
  54. struct ovlytab
  55. {    /* overlays to be mapped. */
  56.     char * ovUECSname;
  57.     int    ovUM;
  58.     char   xovnum;
  59.     char   xovparm;
  60.     int ovUECS;
  61. } ovly[] =
  62. {    /* and here they are! */
  63. #include "cfgnames.h"
  64.     {       "", -1, 0, 0, -1 }
  65. };
  66.  
  67. char symbuf[80];
  68. FILE * symf;
  69. int i;
  70. char * cp;
  71. int comfd;
  72. char * symname = "ME.SYM";
  73. char * comname = "ME.COM";
  74. long lspos;
  75. char * maptname =  "maptable.zme";
  76. int maptfd;
  77.  
  78. main()
  79. {
  80.     symf = fopen( symname, "r" );
  81.     if ( symf == NULL )
  82.     {    printf( "%s not found\n", symname );
  83. badex:        exit ( 1 );
  84.     }
  85.  
  86.     maptfd = open( maptname, O_RDONLY );
  87.     if ( maptfd < 0 )
  88.     {    printf( "%s not found\n", maptname );
  89.         goto badex;
  90.     }
  91.  
  92.     gotname = 0;
  93.     while ( gotname < NEEDNAME && fgets( symbuf, 79, symf ) != NULL )
  94.     {    i = strlen( symbuf ) -1;
  95.         while ( symbuf[i] == '\r' || symbuf[i] == '\n' )
  96.             symbuf[ i-- ] = 0;
  97.         cp = &symbuf[ 5 ];
  98.         for ( i = 0; bi[i].bifname[0]; i++)
  99.         {    if ( ! strcmp( cp, &bi[i].bifname[0] ))
  100.             {    cvout( &bi[i].biffunc );
  101.                 continue;
  102.             }
  103.         }
  104.         if ( ! strcmp( cp, KTname ))
  105.         {    cvout( &pkeytab );
  106.             continue;
  107.         }
  108.         if ( ! strcmp( cp, OTname ))
  109.         {    cvout( &povertab );
  110.             continue;
  111.         }
  112.         if ( ! strcmp( cp, NKname ))
  113.         {    cvout( &pNKEYTAB );
  114.             continue;
  115.         }
  116.         if ( ! strcmp( cp, NOname ))
  117.         {    cvout( &pNOVERTAB );
  118.             continue;
  119.         }
  120.     }
  121.     fclose( symf );
  122.     if ( gotname < NEEDNAME )
  123.     {    printf( "only %d out of %d names found in %s\n",
  124.             gotname, NEEDNAME, symname );
  125.         goto badex;
  126.     }
  127.     comfd = open( comname, O_RDWR );
  128.     if ( comfd < 0 )
  129.     {    printf( "%s not found\n", comname );
  130.         goto badex;
  131.     }
  132.  
  133.         /* We have opened the .COM file; now we need to
  134.         ** do some lpos() and read() operations: the purpose is
  135.         ** to get the number of entries for the KEYTAB and
  136.         ** OVERTAB arrays, then to read in the arrays from
  137.         ** the .COM file.
  138.         */
  139.  
  140.     dolseek( pNOVERTAB );    /* address in .COM of NOVERTAB */
  141.  
  142.     if ( read( comfd, &myNOVERTAB, 2 ) != 2 )
  143.     {    printf( "read myNOVERTAB fails\n" );
  144.         goto badex;
  145.     }    /* now we havew retrieved a value from .COM file. */
  146.  
  147.     if ( ( pMyOvertab = (OVERTAB *)malloc( sizeof(OVERTAB) * myNOVERTAB ))
  148.         == NULL )
  149.     {    printf( "failed: pMyOvertab = malloc( %d * %d )\n",
  150.             sizeof( OVERTAB ), myNOVERTAB );
  151.         goto badex;
  152.     }
  153.  
  154.     dolseek( povertab );
  155.  
  156.     if ( read( comfd, pMyOvertab, sizeof(OVERTAB) * myNOVERTAB ) !=
  157.         ( sizeof(OVERTAB) * myNOVERTAB ))
  158.     {    printf( " failed: read overlay dispatch table\n" );
  159.         goto badex;
  160.     }
  161.  
  162.     dolseek( pNKEYTAB );
  163.  
  164.     if ( read( comfd, &myNKEYTAB, 2 ) != 2 )
  165.     {    printf( "read myNKEYTAB fails\n" );
  166.         goto badex;
  167.     }
  168.  
  169.     if ( ( pMyKeytab = (KEYTAB *)malloc( sizeof(KEYTAB) * myNKEYTAB ))
  170.         == NULL )
  171.     {    printf( "failed: pMyKeytab = malloc( %d * %d )\n",
  172.             sizeof( KEYTAB ), myNKEYTAB );
  173.         goto badex;
  174.     }
  175.  
  176.     dolseek( pkeytab );
  177.  
  178.     if ( read( comfd, pMyKeytab, sizeof(KEYTAB) * myNKEYTAB ) !=
  179.         ( sizeof(KEYTAB) * myNKEYTAB ))
  180.     {    printf( " failed: read builtin dispatch table\n" );
  181.         goto badex;
  182.     }
  183.  
  184.     verify();
  185.     readmap();
  186.  
  187.     dolseek( povertab );
  188.  
  189.     if ( write( comfd, pMyOvertab, sizeof(OVERTAB) * myNOVERTAB ) !=
  190.         ( sizeof(OVERTAB) * myNOVERTAB ))
  191.     {    printf( "failed: write overlay dispatch table\n" );
  192.         goto badex;
  193.     }
  194.  
  195.     dolseek( pkeytab );
  196.  
  197.     if ( write( comfd, pMyKeytab, sizeof(KEYTAB) * myNKEYTAB ) !=
  198.         ( sizeof(KEYTAB) * myNKEYTAB ))
  199.     {    printf( " failed: write builtin dispatch table\n" );
  200.         goto badex;
  201.     }
  202.  
  203.     close( comfd );
  204.     exit ( 0 );
  205. }
  206.  
  207. dolseek( x )
  208. {    lspos = x - 0x100;
  209.     if ( lseek( comfd, lspos, 0 ) < 0L )
  210.     {    printf( "lseek failure %x\n", x );
  211.         exit ( 5 );
  212.     }
  213. }
  214.  
  215. char * hexd = "0123456789ABCDEF";
  216.  
  217. cvout( ip )
  218. int * ip;
  219. {    int ii, jj;
  220.     *ip = 0;
  221.     for ( ii = 0; ii < 4; ++ii )
  222.     {    *ip <<= 4;
  223.         for ( jj = 0; jj < 16; ++jj )
  224.         {    if ( symbuf[ii] == hexd[jj] )
  225.             {    *ip += jj ;
  226.                 break;
  227.             }
  228.         }
  229.     }
  230.     ++gotname;
  231. }
  232. verify()
  233. {    /* verify keytab. */
  234.     int bix, ktx;
  235.     for ( bix = 0; bix < 3; ++bix )
  236.     {    for ( ktx = 0; ktx < myNKEYTAB; ++ktx )
  237.         {    if ( pMyKeytab[ktx].k_fp == bi[bix].biffunc )
  238.                 goto foundit;
  239.         }
  240.         printf( "No match for UECS number %d\n", bi[bix].biUECS );
  241.         printf( "UECS Name: %s\n", bi[bix].biUECSname );
  242.         printf( "Function Name: %s\n", bi[bix].bifname );
  243.         printf( "Core Address: %x\n", pMyKeytab[ktx].k_fp );
  244.         printf( "Address From %s: %x\n", symname,
  245.             bi[bix].biffunc );
  246.         exit ( 1 );
  247. foundit:    continue;
  248.     }
  249.     printf( "Version Information Verified\n" );
  250. }
  251.  
  252. struct { int UECS; int key; } x;
  253.  
  254. int mapdone;
  255.  
  256. readmap()
  257. {    int x_entries;
  258.     mapdone = x_entries = 0;
  259.     while ( read( maptfd, &x, 4 ) == 4 )
  260.     {    if ( x.UECS == 0x1a1a ) break;
  261.         ++x_entries;
  262.         if ( x.UECS == 999 ) delkey();
  263.         else stashkey();
  264.     }
  265.     printf( "Read %d Mapping Entries\n", x_entries );
  266.     printf( "Succeeded in Mapping %d of them\n", mapdone );
  267.     printf( "\nShall we update the .COM file? " );
  268.     x_entries = getchar();
  269.     if ( x_entries != 'y' && x_entries != 'Y' )
  270.     {    printf( "\nSo long, then!\n" );
  271.         exit ( 0 );
  272.     }
  273. }
  274. stashkey()
  275. {    int bix, ktx;
  276.     for ( bix = 0; bi[bix].biUECS != -1; ++bix )
  277.     {    if ( x.UECS != bi[bix].biUECS )
  278.             continue;
  279.         for ( ktx = 0; ktx < myNKEYTAB; ++ktx )
  280.         {    if ( pMyKeytab[ktx].k_code != -1 )
  281.                 continue;
  282.             pMyKeytab[ktx].k_code = x.key;
  283.             pMyKeytab[ktx].k_fp = bi[bix].biffunc;
  284.             ++mapdone;
  285.             return;
  286.         }
  287.         printf( "Built-in table full, cannot map %s\n",
  288.             bi[bix].biUECSname );
  289.         return;
  290.     }
  291.     for ( bix = 0; ovly[bix].ovUECS != -1; ++bix )
  292.     {    if ( x.UECS != ovly[bix].ovUECS )
  293.             continue;
  294.         for ( ktx = 0; ktx < myNOVERTAB; ++ktx )
  295.         {    if ( pMyOvertab[ktx].k_code != -1 )
  296.                 continue;
  297.             pMyOvertab[ktx].k_code = x.key;
  298.             pMyOvertab[ktx].ovcode = ovly[bix].xovnum;
  299.             pMyOvertab[ktx].ovparm = ovly[bix].xovparm;
  300.             ++mapdone;
  301.             return;
  302.         }
  303.         printf( "Overlay table full, cannot map %s\n",
  304.             ovly[bix].ovUECSname );
  305.         return;
  306.     }
  307.     printf( "UECS function number %d is unknown to me.\n",
  308.         x.UECS );
  309. }
  310. delkey()
  311. {    int bix, ktx;
  312.     for ( bix = 0; bi[bix].biUECS != -1; ++bix )
  313.     {    for ( ktx = 0; ktx < myNKEYTAB; ++ktx )
  314.         {    if ( pMyKeytab[ktx].k_code != x.key )
  315.                 continue;
  316.             pMyKeytab[ktx].k_code = -1;
  317.             ++mapdone;
  318.             return;
  319.         }
  320.     }
  321.     for ( bix = 0; ovly[bix].ovUECS != -1; ++bix )
  322.     {    for ( ktx = 0; ktx < myNOVERTAB; ++ktx )
  323.         {    if ( pMyOvertab[ktx].k_code != x.key )
  324.                 continue;
  325.             pMyOvertab[ktx].k_code = -1;
  326.             ++mapdone;
  327.             return;
  328.         }
  329.     }
  330.     printf( "Key %04x was not mapped!\n", x.key );
  331. }
  332.