home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 184.lha / Edimap / lit_map.c < prev   
Encoding:
C/C++ Source or Header  |  1988-04-28  |  6.4 KB  |  239 lines
  1. /* Le fichier lit_map.c contient les routines de lecture écriture de
  2.  * la table de clavier
  3.  */
  4.  
  5. #include "edimap.h"
  6. #include "func.h"
  7.  
  8. #define HUNK_HEADER    0x3f3
  9. #define HUNK_CODE    0x3e9
  10. #define HUNK_RELOC32    0x3ec
  11. #define HUNK_END    0x3f2
  12.  
  13. #define TAILLE0_OFF 0x14
  14. #define CODE_OFF 0x18
  15. #define TAILLE1_OFF 0x1c
  16. #define FIX_OFF 0x20
  17. #define AdNOM_OFF 0x0c
  18. #define AdTABLE_OFF 0x0eL
  19. #define LKM 0x12
  20. #define STR_OFF 0x2a4
  21.  
  22. /*----------------------------------------------------*/
  23. /* on a dans un buffer filebuf le fichier table de clavier qui a été chargé
  24.  * et qui a pour longueur taille
  25.  */
  26. lit_table()
  27. {
  28.     ULONG *plong, code_size, pKeybase, longtab, nb_str, *deb_p_str;
  29.     UWORD *pword;
  30.  
  31.     plong = (ULONG *)filebuf;
  32.     if (*plong++ != HUNK_HEADER) return ERROR;
  33.     if (*plong++ != 0L) return ERROR;
  34.     if (*plong++ != 1L) return ERROR;
  35.     
  36.      plong = (ULONG *)(filebuf+CODE_OFF);
  37.     if (*plong++ != HUNK_CODE) return ERROR;
  38.     code_size = *plong++; /* taille du hunk en LONG */      
  39.     pbase = (UBYTE *)(plong);
  40.     pword = (UWORD *)(pbase + AdNOM_OFF);
  41. /*printf("pnom %lx",*pword);*/
  42.     pnom =  (UBYTE *)(pbase + *(pword++)); ++pword;
  43.  
  44. /*printf("pword %lx,ad lkmt %x\n",pword,*pword);*/
  45.     keymap.km_LoKeyMapTypes = (UBYTE *)(pbase + *pword++); ++pword;
  46.     keymap.km_LoKeyMap = (ULONG *)(pbase + *pword++); ++pword;
  47.     keymap.km_LoCapsable = (UBYTE *)(pbase + *pword++); ++pword;
  48.     keymap.km_LoRepeatable = (UBYTE *)(pbase + *pword++); ++pword;
  49.     keymap.km_HiKeyMapTypes = (UBYTE *)(pbase + *pword++); ++pword;
  50.     keymap.km_HiKeyMap = (ULONG *)(pbase + *pword++); ++pword;
  51.     keymap.km_HiCapsable = (UBYTE *)(pbase + *pword++); ++pword;
  52.     keymap.km_HiRepeatable = (UBYTE *)(pbase + *pword);
  53.  
  54. /*printf("pbase= %lx\n",pbase);*/
  55.  
  56.     longtab = code_size * 4;
  57.  
  58.     plong += code_size;
  59.  
  60.     if (*plong++ != HUNK_RELOC32) return ERROR;
  61. /*    pnb_str = (ULONG *)(pbase + longtab + 4);*/
  62.     nb_str = *plong++;
  63.     if (*plong++ != 0L) return ERROR;
  64.     deb_p_str = plong;
  65. /*printf("longtab %lx, nb_str %lx\n",longtab, nb_str);*/
  66. /*printf("pnb_str %lx,deb_p_str %lx\n",pnb_str,deb_p_str);*/
  67.     pKeybase = (UBYTE *)(keymap.km_LoKeyMap) - pbase;
  68.     init_p(deb_p_str,nb_str,pKeybase,buffer);
  69.  
  70.     return BON;
  71. }
  72. /*--------------------------------*/
  73. /* initialise la table des strings */
  74.  
  75. void init_p(p,nb,keybase,t)
  76. ULONG    *p,        /* debut de la table d'adresses a reloger */
  77.     nb,        /* nb d'adresses a reloger */
  78.     keybase;    /* position dans le fichier du debut des keys */
  79. struct P_String *t;    /* buffer des strings de taille P_SIZE (128) */
  80. {
  81.   int key, i;
  82.  
  83.     for(i=0; i<(nb-9); i++)
  84.     {   key = (*p - keybase)/4; /* numero de la touche concernee */
  85.     t[key].p = (UBYTE *)(*(APTR)(pbase + *p++)) ; /*off de l'adr du str */
  86.     buf_p[key].p = (ULONG)t[key].p + pbase; /* adr du str */
  87.     t[key].l = (UBYTE)key;    /* numero de la touche */
  88.     }
  89.     t = tri(t,P_SIZE);    /* on tri par numero */
  90.     for (key = 1; t[key].l; key++)
  91.     {  buf_p[t[key-1].l].l = t[key].p - t[key-1].p;
  92.     }
  93.     buf_p[t[key-1].l].l = (UBYTE *)(pnom - pbase) - t[key-1].p;
  94. }
  95. /*--------------------------------*/
  96. /* tri des adresses de strings */
  97.  
  98. struct P_String *tri(t,nb)
  99. struct P_String *t;
  100. int nb;
  101. {
  102.   struct P_String pr;
  103.   int i, ip, j, ik, l;
  104.  
  105.     ip = --nb;        /* décremente pour garder 0 a la fin */
  106.     while (ip >= 2)
  107.     {   ip /= 2; j = 0;
  108.         ik = nb - ip;
  109.     while (j < ik)
  110.     {  i = j;
  111.        while (i >= 0)
  112.        {   l = i + ip;
  113.            if (t[i].p <= t[l].p) break;
  114.            pr = t[i]; t[i] = t[l]; t[l] = pr;
  115.            i -= ip;
  116.        }
  117.        j++;
  118.     }
  119.     } 
  120.     while (!(t->p)) t++;  
  121.     return(t);
  122. }
  123. /*--------------------------------------------*/
  124. /* Création sur disque de la nouvelle table */
  125.  
  126. ecr_table(new_nom,new_table)
  127. char *new_nom, *new_table;
  128. {
  129.   struct FileHandle *fout;
  130.   ULONG *t_reloc;
  131.   ULONG l_nom, l, wpnom;
  132.   int i, l_reloc;
  133.   UBYTE *p_byte, *pbase;
  134.  
  135.     if ((fout = Open(new_nom,MODE_NEWFILE)) == NULL)
  136.     {  printf("Je ne peux ouvrir le fichier %s\n",new_nom); 
  137.        return ERROR;
  138.     }
  139.  
  140.     pbase = filebuf + FIX_OFF;
  141.     Write(fout,filebuf,78L); /* ecrit le meme debut que l'on modifiera */
  142.  
  143. /* le bloc qui suit est inutile car le même en fait */
  144. /*    mise_a_jour = 46L;
  145.     Seek(fout,mise_a_jour,OFFSET_BEGINNING)
  146.     p_byte = keymap.km_LoKeyMapTypes - pbase;
  147.     Write(fout,p_byte,4L);
  148.     p_byte = keymap.km_LoKeyMap - pbase;
  149.     Write(fout,p_byte,4L);
  150.     p_byte = keymap.km_LoCapsable - pbase;
  151.     Write(fout,p_byte,4L);
  152.     p_byte = keymap.km_LoRepeatable - pbase;
  153.     Write(fout,p_byte,4L);
  154.     p_byte = keymap.km_HiKeyMapTypes - pbase;
  155.     Write(fout,p_byte,4L);
  156.     p_byte = keymap.km_HiKeyMap - pbase;
  157.     Write(fout,p_byte,4L);
  158.     p_byte = keymap.km_HiCapsable - pbase;
  159.     Write(fout,p_byte,4L);
  160.     p_byte = keymap.km_HiRepeatable - pbase;
  161.  */
  162.     t_reloc = (ULONG *)buffer; /* reutilise buffer */   
  163.     l_reloc = ajust_table(t_reloc);
  164.     Write(fout,keymap.km_LoCapsable,8L);
  165.     Write(fout,keymap.km_HiCapsable,7L);
  166.     Write(fout,keymap.km_LoRepeatable,8L);
  167.     Write(fout,keymap.km_HiRepeatable,7L);
  168.     Write(fout,keymap.km_LoKeyMapTypes,64L);
  169.     Write(fout,keymap.km_HiKeyMapTypes,56L);
  170.     Write(fout,keymap.km_LoKeyMap,256L);
  171.     Write(fout,keymap.km_HiKeyMap,224L);
  172.  
  173.     for (i=0; i<P_SIZE; i++)
  174.     { if (buf_p[i].p) Write(fout,buf_p[i].p,(LONG)buf_p[i].l);
  175.     }
  176.  
  177.     l_nom = strlen(new_table);
  178.     Write(fout,new_table,l_nom+1);
  179.     
  180.     l = Seek(fout,0L,OFFSET_CURRENT); /* où est-on */
  181.     wpnom = (l + 3 - FIX_OFF)/4;
  182.     l = 4 - l%4;
  183.     l_nom = 0L;
  184.     if (l != 4) Write(fout,&l_nom,l); /* padding en long */
  185.  
  186.     Write(fout,t_reloc,l_reloc*4);
  187.  
  188.     l = HUNK_END;
  189.     Write(fout,&l,4L);
  190.  
  191.     Seek(fout,TAILLE0_OFF,OFFSET_BEGINING);
  192.     Write(fout,&wpnom,4L);
  193.     Seek(fout,TAILLE1_OFF,OFFSET_BEGINING);
  194.     if (Write(fout,&wpnom,4L) != 4)
  195.     { printf("pas de place sur le disque, fichier incomplet\n");
  196.       return ERROR;
  197.     }
  198.     Close(fout);
  199.     return BON;
  200.  
  201. }
  202. /*--------------------------------------------*/
  203. /* on crée la table de relocation finale */
  204.  
  205. ajust_table(t_reloc)
  206. ULONG *t_reloc;
  207. {
  208.     ULONG off_str = STR_OFF;
  209.     ULONG *p_Map;
  210.     LONG j=0;
  211.     int i;
  212.  
  213.     t_reloc[j++] = HUNK_RELOC32;
  214.     j++;
  215.     t_reloc[j++] = 0x00;
  216.     p_Map = (ULONG *)keymap.km_LoKeyMap;
  217.     for (i=0; i<P_SIZE; i++)
  218.     { if (buf_p[i].p)
  219.       { p_Map[i] = off_str;
  220.         off_str += buf_p[i].l;
  221.         t_reloc[j++] = 4*i + 0xc4;
  222.       }
  223.     }
  224.  
  225.     t_reloc[j++] = 0x2a;
  226.     t_reloc[j++] = 0x26;
  227.     t_reloc[j++] = 0x22;
  228.     t_reloc[j++] = 0x1e;
  229.     t_reloc[j++] = 0x1a;
  230.     t_reloc[j++] = 0x16;
  231.     t_reloc[j++] = 0x12;
  232.     t_reloc[j++] = 0x0e;
  233.     t_reloc[j++] = 0x0a;
  234.     t_reloc[j] = 0x00;
  235.     
  236.     t_reloc[1] = j-3;
  237.     return (j+1);
  238. }
  239.