home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / C / DMAKE37S.ZIP / DMAKE / STATE.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-05-06  |  5.4 KB  |  228 lines
  1. /* RCS      -- $Header: /u2/dvadura/src/generic/dmake/src/RCS/state.c,v 1.1 91/05/06 15:23:31 dvadura Exp $
  2. -- SYNOPSIS -- .KEEP_STATE state file management
  3. -- 
  4. -- DESCRIPTION
  5. --     Three routines to interface to the .KEEP_STATE state file.
  6. --
  7. --        Read_state()    - reads the state file if any.
  8. --        Write_state()    - writes the state file.
  9. --
  10. --        Check_state(cp,how) - checks an entry returns 0 or 1
  11. --                      and updates the entry.
  12. --
  13. -- AUTHOR
  14. --      Dennis Vadura, dvadura@watdragon.uwaterloo.ca
  15. --      CS DEPT, University of Waterloo, Waterloo, Ont., Canada
  16. --
  17. -- COPYRIGHT
  18. --      Copyright (c) 1990 by Dennis Vadura.  All rights reserved.
  19. -- 
  20. --      This program is free software; you can redistribute it and/or
  21. --      modify it under the terms of the GNU General Public License
  22. --      (version 1), as published by the Free Software Foundation, and
  23. --      found in the file 'LICENSE' included with this distribution.
  24. -- 
  25. --      This program is distributed in the hope that it will be useful,
  26. --      but WITHOUT ANY WARRANTY; without even the implied warrant of
  27. --      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28. --      GNU General Public License for more details.
  29. -- 
  30. --      You should have received a copy of the GNU General Public License
  31. --      along with this program;  if not, write to the Free Software
  32. --      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  33. --
  34. -- LOG
  35. --     $Log:    state.c,v $
  36.  * Revision 1.1  91/05/06  15:23:31  dvadura
  37.  * dmake Release Version 3.7
  38.  * 
  39. */
  40.  
  41. #include "extern.h"
  42.  
  43. typedef struct se {
  44.    char        *st_name;        /* name of cell        */
  45.    uint32    st_nkey;        /* name hash key    */
  46.    int        st_count;        /* how count for how    */
  47.    uint32    st_dkey;        /* directory hash key    */
  48.    uint32    st_key;            /* hash key        */
  49.    struct se    *st_next;
  50. } KSTATE, *KSTATEPTR;
  51.  
  52. static KSTATEPTR _st_head  = NIL(KSTATE);
  53. static KSTATEPTR _st_tail  = NIL(KSTATE);
  54. static int       _st_upd   = FALSE;
  55. static char     *_st_file  = NIL(char);
  56.  
  57. static int  _my_fgets ANSI((char *, int, FILE *));
  58.  
  59. PUBLIC void
  60. Read_state()
  61. {
  62.    char *buf;
  63.    char sizeb[20];
  64.    int  size;
  65.    FILE *fp;
  66.    KSTATEPTR sp;
  67.  
  68.    if( (fp = Search_file(".KEEP_STATE", &_st_file)) != NIL(FILE) ) {
  69.       if( _my_fgets( sizeb, 20, fp ) ) {
  70.      size = atol(sizeb);
  71.      buf = MALLOC(size+2, char);
  72.  
  73.      while( _my_fgets(buf, size, fp) != NULL ) {
  74.         TALLOC(sp, 1, KSTATE);
  75.         sp->st_name = _strdup(buf);
  76.         (void) Hash(buf, &sp->st_nkey);
  77.  
  78.         if( _my_fgets(buf, size, fp) ) sp->st_count = atoi(buf);
  79.         if( _my_fgets(buf, size, fp) ) sp->st_dkey   = (uint32) atol(buf);
  80.  
  81.         if( _my_fgets(buf, size, fp) )
  82.            sp->st_key = (uint32) atol(buf);
  83.         else {
  84.            FREE(sp);
  85.            break;
  86.         }
  87.  
  88.         if( _st_head == NIL(KSTATE) )
  89.            _st_head = sp;
  90.         else
  91.            _st_tail->st_next = sp;
  92.  
  93.         _st_tail = sp;
  94.      }
  95.  
  96.      FREE(buf);
  97.       }
  98.  
  99.       Closefile(fp);
  100.    }
  101. }
  102.  
  103.  
  104. PUBLIC void
  105. Write_state()
  106. {
  107.    static int in_write = 0;
  108.    register KSTATEPTR sp;
  109.    FILE *fp;
  110.  
  111.    if( !_st_upd || !_st_file || (_st_file && !*_st_file) ||
  112.        Trace || in_write ) return;
  113.  
  114.    in_write++;
  115.    if( (fp = Openfile(_st_file, TRUE, TRUE)) != NIL(FILE) ) {
  116.       int maxlen = 0;
  117.       int tmplen;
  118.  
  119.       for( sp = _st_head; sp; sp=sp->st_next )
  120.      if( (tmplen = strlen(sp->st_name)) > maxlen )
  121.         maxlen = tmplen;
  122.  
  123.       /* A nice arbitrary minimum size */
  124.       if( maxlen < 20 ) maxlen = 20;
  125.       fprintf( fp, "%d\n", maxlen );
  126.  
  127.       for( sp = _st_head; sp; sp=sp->st_next ) {
  128.      uint16 hv;
  129.      uint32 hk;
  130.  
  131.      if( Search_table(Defs, sp->st_name, &hv, &hk) ) {
  132.         fprintf( fp, "%s\n",  sp->st_name   );
  133.         fprintf( fp, "%d\n",  sp->st_count );
  134.         fprintf( fp, "%lu\n", sp->st_dkey   );
  135.         fprintf( fp, "%lu\n", sp->st_key    );
  136.      }
  137.       }
  138.  
  139.       Closefile();
  140.    }
  141.    else
  142.       Fatal("Cannot open STATE file %s", _st_file);
  143.  
  144.    in_write = 0;
  145. }
  146.  
  147.  
  148. PUBLIC int
  149. Check_state( cp, recipes, maxrcp )
  150. CELLPTR cp;
  151. STRINGPTR *recipes;
  152. int  maxrcp;
  153. {
  154.    KSTATEPTR  st;
  155.    STRINGPTR sp;
  156.    int    i;
  157.    uint32 thkey;
  158.    uint32 hkey;
  159.    uint32 nkey;
  160.    uint32 dkey;
  161.    int    update = FALSE;
  162.  
  163.    if(    strcmp(cp->CE_NAME,".REMOVE") == 0
  164.        || (cp->ce_attr & (A_PHONY|A_NOSTATE)) )
  165.       return(FALSE);
  166.  
  167.    (void) Hash( cp->CE_NAME, &nkey ); thkey = nkey + (uint32) cp->ce_count;
  168.    (void) Hash( Pwd,  &dkey ); thkey += dkey;
  169.  
  170.    Suppress_temp_file = TRUE;
  171.    for( i=0 ; i<maxrcp; i++ )
  172.       for(sp=recipes[i]; sp != NIL(STRING); sp=sp->st_next ) {
  173.      char *cmnd = Expand(sp->st_string);
  174.  
  175.      (void) Hash(cmnd, &hkey); thkey += hkey;
  176.      FREE(cmnd);
  177.       }
  178.    Suppress_temp_file = FALSE;
  179.  
  180.    for( st=_st_head; st != NIL(KSTATE); st=st->st_next ) {
  181.       if(    st->st_nkey   == nkey
  182.       && st->st_dkey   == dkey
  183.       && st->st_count  == cp->ce_count
  184.       && !strcmp(cp->CE_NAME, st->st_name) )
  185.      break;
  186.    }
  187.  
  188.    if( st == NIL(KSTATE) ) {
  189.       KSTATEPTR nst;
  190.  
  191.       TALLOC(nst, 1, KSTATE);
  192.       nst->st_name = cp->CE_NAME;
  193.       nst->st_nkey = nkey;
  194.       nst->st_dkey = dkey;
  195.       nst->st_key  = thkey;
  196.       nst->st_count = cp->ce_count;
  197.  
  198.       if( _st_head == NIL(KSTATE) )
  199.      _st_head = nst;
  200.       else
  201.      _st_tail->st_next = nst;
  202.  
  203.       _st_tail = nst;
  204.       _st_upd  = TRUE;
  205.    }
  206.    else if( st->st_key != thkey ) {
  207.       st->st_key = thkey;
  208.       _st_upd = update = TRUE;
  209.    }
  210.  
  211.    return(st != NIL(KSTATE) && update);
  212. }
  213.  
  214.  
  215. static int
  216. _my_fgets(buf, size, fp)
  217. char *buf;
  218. int  size;
  219. FILE *fp;
  220. {
  221.    char *p;
  222.  
  223.    if( fgets(buf, size, fp) == NULL ) return(0);
  224.  
  225.    if( (p=strrchr(buf,'\n')) != NIL(char) ) *p='\0';
  226.    return(1);
  227. }
  228.