home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / smapp100.zip / sm10.zip / smgdifid.c < prev    next >
C/C++ Source or Header  |  2000-05-14  |  8KB  |  268 lines
  1. /* ------------------------------------------------------------------------
  2.  *
  3.  *        File: smgdifid.c
  4.  *     Project: Source Mapper.
  5.  *     Created: October 19, 1992.
  6.  * Description: Kildekode for å samle liste over forskjellige
  7.  *              identifikatorer/elementer. 
  8.  *              Merk: Listen kan ikke bestå av fler enn 65535 elementer.
  9.  *
  10.  * Copyright (C) 2000 Leif-Erik Larsen.
  11.  * This file is part of the Source Mapper source package.
  12.  * Source Mapper is free software; you can redistribute it and/or modify
  13.  * it under the terms of the GNU General Public License as published
  14.  * by the Free Software Foundation, in version 2 as it comes in the
  15.  * "COPYING" file of the XWorkplace main distribution.
  16.  * This program is distributed in the hope that it will be useful,
  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.  * GNU General Public License for more details.
  20.  *
  21.  * ------------------------------------------------------------------------ */
  22.  
  23.  
  24.  
  25.  
  26. #include "smg.h"
  27.  
  28.  
  29.  
  30.  
  31. diffbTYPE diffb;
  32.  
  33.  
  34.  
  35.  
  36. int DiffBConstruct ( const char *fname, int idsize )
  37. /* Opprettet: Mandag 19. oktober 1992.
  38.    Parameter: "fname"  Navn til filen hvor forskjellige id'er skal lagres.
  39.               "idsize" St¢rrelsen til hvert element i listen (byte).
  40.    Retur    : E/O.
  41.    Beskriv  : Initierer den globale strukturen "diffb".
  42.               Strukturens fil åpnes.
  43. */
  44. {
  45.    unsigned long memfree;              /* Ledig RAM */
  46.  
  47.    /* Åpne den midlertidige filen: */
  48.    if ((diffb.file = FOpen (fname, "w+b")) == NULL)
  49.       RETERR (11, fname);              /* Failed on open temporary file! */
  50.  
  51.    /* Alloker hukommelse til buffer for lesing av enkle elementer: */
  52.    if ((diffb.buff_test = Alloc (idsize + 1)) == NULL)
  53.    {
  54.       FClose (diffb.file);
  55.       RETERR (14, NULL);               /* Out of memory! */
  56.    }
  57.  
  58.    /* Alloker hukommelse til buffer: */
  59.    memfree = MemLeft ();               /* Ledig RAM */
  60.    if (memfree < 4000)                 /* Minste ledig RAM for å bruke buffer*/
  61.    {
  62.       diffb.buff      = NULL;          /* Ingen buffer */
  63.       diffb.maxidbuff = 0;             /* Ingen elementer i buffer */
  64.       diffb.allinbuff = FALSE;         /* Ingen elementer i buffer */
  65.    }
  66.    else                                /* Tilstrekkelig ledig RAM */
  67.    {
  68.       if (memfree > 65535L * idsize)
  69.          memfree = 65535L * idsize;
  70.       diffb.buff = Alloc (memfree - 1000);
  71.       diffb.allinbuff = TRUE;          /* Alle elementer i buffer*/
  72.       diffb.maxidbuff = (uint16) ((memfree - 1000) / idsize);
  73.    }
  74.  
  75.    /* Forel¢pig ingen elementer i listen: */
  76.    diffb.cid     = 0;
  77.    diffb.cidbuff = 0;
  78.    diffb.cidfile = 0;
  79.  
  80.    diffb.idsize  = (uint16) idsize;
  81.  
  82.    return (OK);
  83. } /* DiffBConstruct (); */
  84.  
  85.  
  86.  
  87.  
  88. int DiffBClear ( void )
  89. {
  90.    char filename[MAXPATH];
  91.  
  92.    /* Recreate the file, to make it empty */
  93.    strcpy (filename, GetFNames (diffb.file));
  94.    FClose (diffb.file);
  95.    if ((diffb.file = FOpen (filename, "w+b")) == NULL)
  96.       RETERR (11, filename);           /* Failed on open temporary file! */
  97.  
  98.    /* Pretend buffer is now empty (contain none IDs) */
  99.    diffb.cid     = 0;
  100.    diffb.cidbuff = 0;
  101.    diffb.cidfile = 0;
  102.  
  103.    return (OK);
  104. }
  105.  
  106.  
  107.  
  108.  
  109. int DiffBDestruct ( void )
  110. /* Opprettet: Mandag 19. oktober 1992.
  111.    Parameter:
  112.    Retur    : E/O.
  113.    Beskriv  : Avslutter og resetter den globale strukturen "diffb".
  114.               Strukturens fil lukkes.
  115. */
  116. {
  117.    int ret = OK;                       /* Returkode */
  118.  
  119.    /* Plasser filpeker bakerst i filen: */
  120.    if (!FSeek (diffb.file, 0L, SEEK_END))
  121.    {
  122.       ret = ERROR;
  123.       goto END_ERR;
  124.    }
  125.  
  126.    /* Lagre elementene i buffer til filen: */
  127.    if (FWrite (diffb.buff, diffb.idsize, diffb.cidbuff, diffb.file) != diffb.cidbuff)
  128.       ret = ERROR;
  129.  
  130. END_ERR:
  131.  
  132.    FClose (diffb.file);
  133.  
  134.    /* Frigj¢r eventuellt allokert buffer: */
  135.    if (diffb.buff)
  136.       Free (diffb.buff);
  137.  
  138.    /* Frigj¢r allokert buffer for lesing av enkle elementer: */
  139.    Free (diffb.buff_test);
  140.  
  141.    diffb.maxidbuff = 0;
  142.    diffb.allinbuff = FALSE;
  143.    diffb.buff      = NULL;
  144.    diffb.cid       = 0;
  145.    diffb.cidbuff   = 0;
  146.    diffb.cidfile   = 0;
  147.    diffb.idsize    = 0;
  148.  
  149.    return (ret);
  150. } /* DiffBDestruct ();*/
  151.  
  152.  
  153.  
  154.  
  155. int DiffBAddId ( const char *id )
  156. /* Opprettet: Mandag 19. oktober 1992.
  157.    Parameter: "id" Navn som skal legges til listen over forskjellige id'er.
  158.    Retur    : E/O.
  159.    Beskriv  : Inkluderer oppgitt navn i listen over forskjellige navn.
  160.               Tester ikke om navnet finnes i listen fra f¢r.
  161. */
  162. {
  163.    /* Legg navn i buffer, hvis det er plass: */
  164.    if (diffb.cidbuff < diffb.maxidbuff)
  165.    {
  166.       memcpy (ADRESS (diffb.buff, diffb.cidbuff, diffb.idsize), id, diffb.idsize);
  167.       diffb.cidbuff++;                 /* Antall elementer i buffer */
  168.       diffb.cid++;                     /* Antall elementer totalt */
  169.       return (OK);                     /* Returner uten videre */
  170.    }
  171.  
  172.    /* Det er ikke plass i buffer. Legg navnet i filen: */
  173.    FSeek (diffb.file, 0L, SEEK_END);
  174.    if (FWrite (id, diffb.idsize, 1, diffb.file) != 1)
  175.       return (ERROR);
  176.    diffb.cid++;                        /* Antall elementer totalt */
  177.    diffb.cidfile++;                    /* Antall elementer i fil */
  178.    diffb.allinbuff = FALSE;            /* Ikke alle elementer er i buffer */
  179.  
  180.    return (OK);
  181. } /* DiffBAddId (); */
  182.  
  183.  
  184.  
  185.  
  186. int DiffBIfId ( const char *id, uint16 *answ )
  187. /* Opprettet: Mandag 19. oktober 1992.
  188.    Parameter: "id"   Navn som skal sjekkes om finnes i listen fra f¢r.
  189.               "answ" Returnerer 0 hvis id ikke finnes i listen.
  190.                      Ellers returneres indeks nummer til hvor i listen id
  191.                      ble funnet (1..).
  192.    Retur    : E/O.
  193.    Beskriv  : Tester om oppgitt navn finnes i listen fra f¢r.
  194. */
  195. {
  196.    uint16     c1 = 0;                  /* Counter 1 */
  197.    uint16     Index;
  198.    char huge *ptr = diffb.buff;
  199.  
  200.    *answ = 0;                          /* Standard at elementet ikke finnes */
  201.  
  202.    while (c1++ < diffb.cidbuff)        /* Test alle elementer i buffer */
  203.    {
  204.       if (strcmp (id, (char far *) ptr) == 0)
  205.       {
  206.          *answ = c1;                   /* Elementet finnes */
  207.          return (OK);
  208.       }
  209.       ptr += diffb.idsize;
  210.    }
  211.  
  212.    Index = (uint16) (c1 - 1);
  213.  
  214.    /* Hvis alle elementer er i buffer finnes ikke elementet: */
  215.    if (diffb.allinbuff)
  216.       return (OK);
  217.  
  218.    /* Plasser filpeker til start av fil: */
  219.    if (!FSeek (diffb.file, 0, SEEK_SET))
  220.       return (ERROR);
  221.  
  222.    /* Test i fil: */
  223.    for (c1=0; c1<diffb.cidfile; c1++)  /* Test alle elementer i fil */
  224.    {
  225.       Index++;                         /* Tell id-index */
  226.       if (FRead (diffb.buff_test, diffb.idsize, 1, diffb.file) != 1)
  227.          return (ERROR);
  228.       if (strcmp (id, diffb.buff_test) == 0)
  229.       {
  230.          *answ = Index;                /* Elementet finnes */
  231.          return (OK);
  232.       }
  233.    }
  234.  
  235.    return (OK);                        /* Elementet finnes ikke */
  236. } /* DiffBIfId (); */
  237.  
  238.  
  239.  
  240.  
  241. int DiffBGetId ( uint16 indx, char *id )
  242. /* Opprettet: Onsdag 12. mai 1992. 21:04.
  243.    Parameter: "indx" Indeks nummer til hvilken id som skal returneres (1..).
  244.               "id"   Returner spesifisert id i i denne buffer.
  245.    Retur    : E/O.
  246. */
  247. {
  248.    if (indx < 1 || indx > diffb.cid)
  249.       return (ERROR);
  250.  
  251.    if (indx <= diffb.cidbuff)          /* Hvis ¢nsket id ligger i buffer     */
  252.    {
  253.       memcpy (id, ADRESS (diffb.buff, indx - 1, diffb.idsize), diffb.idsize);
  254.       return (OK);
  255.    }
  256.  
  257.    indx -= (uint16) (diffb.cidbuff - 1); /* Konverter til indeks til fil */
  258.  
  259.    FSeek (diffb.file, (long) indx * diffb.idsize, SEEK_SET);
  260.    FRead (id, diffb.idsize, 1, diffb.file);
  261.  
  262.    if (errno != 0)
  263.       return (ERROR);
  264.  
  265.    return (OK);
  266. } /* DiffBGetId (); */
  267.  
  268.