---

file.h

Go to the documentation of this file.

/************ file.h **************
$Revision: 1.2 $
$Author: pbergen $
$Date: 2001/05/13 21:56:03 $
***********************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#ifndef _FILE_H_
#define _FILE_H_

#define MAXLINES 256

#define MAXDEPEND 512

#define MAXINCLUDEPATHS 2048

#define EXCLUDELISTS 3


#define EXTUNKNOWN 0

#define EXTH       1

#define EXTCPP     2

#define EXTOBJ     3

#include "makeutilities.h"

static class File *fileRoot=NULL;

class File
{
 public:
  File(const char *fname)
    {
      ageChecked=false;
      rebuild=false;
      scanned=false;
      compiled=false;
      dotted=false;
      subDotted=false;
      objected=false;
      included=false;
      tagged=false;
      hasClass=true;
      hFileCount=0;
      cppFileCount=0;

      for(int i=0;i<EXCLUDELISTS;i++)
        {
          excluded[i]=false;
        }
       
      objFile=NULL;
      fullName=NULL;
      fileName=NULL;
      dotName=NULL;
      path=NULL;
      next=NULL;

      fullName=MakeUtilities::getStrCopy(fname);

      if (!getStats())
        {
          extension=EXTUNKNOWN;
          disectFilename();
          if (extension==EXTUNKNOWN)
            {
              delete [] path;
              path=NULL;
              delete [] fileName;
              fileName=NULL;
            }
          else
            {
              objFile=NULL;
              for(int i=0;i<MAXDEPEND;i++)
                {
                  hFile[i]=NULL;
                  cppFile[i]=NULL;
                }
              guess();
            }
        }
    }

  ~File()
    {
      delete [] fullName;
      /* No need since it is part of path! */
      // delete [] fileName; 
      delete [] path;
      delete next;
    }

   void setGraphExcluded(int n, bool state)
     {
        if (n<EXCLUDELISTS)
          {
             excluded[n]=state;
          }
     }
   
  const char *getFileName(void)
    {
      return fileName;
    }

  const char *getPath(void)
    {
      return path;
    }

  const char *getFullName(void)
    {
      return fullName;
    }

  File *getNext()
    {
      return next;
    }

  int getExtension(void)
    {
      return extension;
    }

  File *addNextFile(File *file)
    {
      if (file)
        {
          if (next)
            {
              file->next=next;
            }
          next=file;
        }
      return file;
    }

  void resolveDependencies(void)
    {
      bool classDef=false;
      if (!scanned)
        {
          if (extension==EXTH || extension==EXTCPP)
            {
              char buf[MAXLINES],*p,*q;
              int line=0;
              FILE *fin=fopen(fullName,"r");
              if (fin)
                {
                  while (fgets(buf,MAXLINES,fin))
                    {
                      line++;
                      if (!strncmp(buf,"#include",8))
                        {
                          p=strchr(buf+9,'\"');
                          if (p)
                            {
                              q=strchr(p+1,'\"');
                              if (q)
                                {
                                  *q=0;
                                  addDependency(getFileNoPath(p+1));
                                }
                            }
                          else
                            {
                              p=strchr(buf+9,'<');
                              if (p)
                                {
                                  q=strchr(p+1,'>');
                                  if (q)
                                    {                       
                                      *q=0;
                                      addDependency(getFileNoPath(p+1));
                                    }
                                }
                            }
                        }
                      else if (!strncmp(buf,"MAKER_ADD_DEPENDENCY=",21))
                        {
                          p=strchr(buf+21,'\"');
                          if (p)
                            {
                              q=strchr(p+1,'\"');
                              if (q)
                                {
                                  *q=0;
                                  char *tmpPath=warpPath(p+1);
                                  bool aCopy=false;
                                  File *tmp=addDependency(findFile(tmpPath,
                                                                   NULL,
                                                                   aCopy));
                                  if (!tmp)
                                    {
                                      printf("Dependency not found: %s\n",
                                             tmpPath);
                                    }
                                  if (!aCopy)
                                    {
                                      addFile(tmp);
                                    }
                                }
                            }
                        }
                      else
                        {
                          if (!strncmp(buf,"class",5))
                            {
                              classDef=true;
                              break;
                            }
                        }
                      if (line>128)
                        {
                          break;
                        }
                    }
                  fclose(fin);
                }
            }
          scanned=true;
          for(int i=0;i<cppFileCount;i++)
            {
              cppFile[i]->resolveDependencies();
            }
          for(int i=0;i<hFileCount;i++)
            {
              hFile[i]->resolveDependencies();
            }
        }
      hasClass&=classDef;
    }

  void print(bool recursive=false)
    {
      printf("Fullname: %s %s\n",fullName,hasClass?"(has class)":"");
      printf("This: 0x%X            %s\n",(int)this,rebuild?"REBUILD":"");
      printf("Path and name: %s + %s\n",path,fileName);    
      printf("ObjFile: 0x%X\n",(int)objFile);
      printf("CppFiles:\t0x%X\n",(int)cppFile[0]);
      for(int i=1;i<cppFileCount;i++)
        {
          printf("\t\t0x%X (%s)\n",(int)cppFile[i],cppFile[i]->fileName);
        }
      printf("Next: 0x%X\n",(int)next);
      printf("Dependecies: %d\n",hFileCount);
      for(int i=0;i<hFileCount;i++)
        {
          printf("%.7d: 0x%X (%s)\n",i,(int)hFile[i],hFile[i]->fileName);
        }
      if (recursive && next)
        {
          next->print(recursive);
        }
    }

  void tagRebuild(void)
    {
      if (tagged)
        {
          return;
        }
      tagged=true;
      if (extension==EXTCPP)
        {
          rebuild=false;
          if (!objFile)
            {
              rebuild=true;
            }
          else
            {
              clearAgeChecked();
              if (isObjFileOld(objFile->stats.st_mtime) /*st_ctime?*/)
                {
                  rebuild=true;
                }
            }
        }
      else if (extension==EXTH)
        {
          for(int i=0;i<cppFileCount;i++)
            {
              cppFile[i]->tagRebuild();
            }
        }
      for(int i=0;i<hFileCount;i++)
        {
          hFile[i]->tagRebuild();
        }
    }

  void writeCompilation(FILE *stream,const char *compiler)
    {
      if (compiled)
        {
          return;
        }
      compiled=true;
      for(int i=0;i<cppFileCount;i++)
        {
          cppFile[i]->writeCompilation(stream,compiler);
        }
      for(int i=0;i<hFileCount;i++)
        {
          hFile[i]->writeCompilation(stream,compiler);
        }
      if (extension==EXTCPP && rebuild)
        {
          char *output=MakeUtilities::changeExtension(fullName,"o");
          fprintf(stream,"echo COMPILING: %s\n",fullName);
          fprintf(stream,"%s -c -o %s",compiler,output);
          delete [] output;

          int count=0;
          char *paths[MAXINCLUDEPATHS];
          File::clearIncluded();
          getIncludePath(paths,count);
          for(int i=0;i<count;i++)
            {
              fprintf(stream," -I%s",paths[i]);
            }
          fprintf(stream," %s\n",fullName);
          fprintf(stream,"if [ $? -ne 0 ]; then\nexit 1\nfi\n");
        }
    }

  void writeLink(FILE* stream, const char *executable,
                 const char *linker, const char *linkerTail)
    {
      fprintf(stream,"echo LINKING: %s\n",executable);
      fprintf(stream,"%s -o %s",linker,executable);
      writeObjects(stream);
      fprintf(stream," %s\n",linkerTail);
    }

  bool writeDot(const char *dotFile)
  {
    /* Build big messy graph. */
    char *fname=MakeUtilities::changeExtension(dotFile,
                                               "all.dot");
    FILE *fout=fopen(fname,"w+");
    if (fout)
      {
        fprintf(fout,"digraph \"All files\" {\n");
        fprintf(fout,"size=\"7.5,11\";ratio=fill;rankdir=LR;\n");
        fprintf(fout,"node [fontsize=11];\n");

        clearDotted();
        writeDotNodes(fout,true);
        fprintf(fout,"}\n");
        fclose(fout);
        noDuplicates(fname);
      }
    else
      {
        delete [] fname;
        return false;
      }
    delete [] fname;

    /* Build organized graph of CPPs and Hs with no CPP and a class. */
    fname=MakeUtilities::changeExtension(dotFile,
                                     "class.dot");
    fout=fopen(fname,"w+");
    if (fout)
      {
        fprintf(fout,"digraph \"All source files\" {\n");
        fprintf(fout,"size=\"7.5,11\";ratio=fill;rankdir=LR;\n");
        fprintf(fout,"node [fontsize=11];\n");

        clearDotted();  
        clearSubDotted();
        writeDotCPPs2(fout);

        fprintf(fout,"}\n");
        fclose(fout);
        noDuplicates(fname);
      }
    else
      {
        return false;
      }
    delete [] fname;

    /* Build organized graph of CPPs only. */
    fout=fopen(dotFile,"w+");
    if (fout)
      {
        fprintf(fout,"digraph \"All source files\" {\n");
        fprintf(fout,"size=\"7.5,11\";ratio=fill;rankdir=LR;\n");
        fprintf(fout,"node [fontsize=11];\n");

        clearDotted();  
        clearSubDotted();
        writeDotCPPs(fout,NULL);

        fprintf(fout,"}\n");
        fclose(fout);
        noDuplicates(dotFile);
      }
    else
      {
        return false;
      }
    return true;
  }

private:

  void noDuplicates(const char *fname)
  {
    FILE *fin=fopen(fname,"r");
    if (fin)
      {
        char **lines,buf[5000];
        int linesC=0,i,newLine,c=0;
        lines=new char*[100000];
        while(fgets(buf,5000,fin))
          {
            c++;
            newLine=true;
            for(i=0;i<linesC;i++)
              {
                if (!strcmp(lines[i],buf))
                  {
                    newLine=false;
                    break;
                  }
              }
            if (newLine)
              {
                lines[linesC]=new char[1+strlen(buf)];
                strcpy(lines[i],buf);
                linesC++;
                if (linesC>100000)
                  {
                    printf("noDuplicates 100000 lines capacity exceeded. "
                           "Duplicates were not removed.\n");
                    fclose(fin);
                    return;
                  }
              }
          }
        fclose(fin);
        FILE *fout=fopen(fname,"w+");
        for(i=0;i<linesC;i++)
          {
            if (fout)
              {
                fputs(lines[i],fout);
              }
            delete [] lines[i];
          }
        delete lines;
        if (fout)
          {
            fclose(fout);
          }
      }
  }

  char *warpPath(char *incPath)
  {
    static char tmp[8000],*p;
    tmp[0]=0;
    
    if (!incPath || !path)
      {
        return incPath;
      }

    strcpy(tmp,path);
    char *addPath=incPath;
    while (!strncmp(addPath,"../",3))
      { 
        p=MakeUtilities::strchrReverse(tmp,'/');
        if (p)
          {
            *p=0;
          }
        else 
          {
            if (!*tmp)
              {
                printf("Cannot resolve relative path. Goes below /.\n");
                return incPath;
              }
            else
              {
                *tmp=0;
              }
          }
        addPath=strchr(addPath,'/')+1;
      }
    if (tmp[strlen(tmp)]!='/')
      {
        strcat(tmp,"/");
      }
    strcat(tmp,addPath);
    return tmp;    
  }

  static const char *stripPath(const char *incPath)
  {
    if (!incPath)
      {
        return incPath;
      }

    char *p=MakeUtilities::strchrReverse(incPath,'/');
    if (p)
      {
        return p+1;
      }
    return incPath;
  }

  void writeDotNodes(FILE *stream, bool followCPP=false)
  {
    if (dotted)
      {
        return;
      }
    dotted=true;

    if (extension==EXTCPP)
      {
        if (rebuild)
          {
            fprintf(stream,"\"%s\" [label=\"%s\\n(rebuild)\", style=filled, "
                    "color=lightgray, shape=box];",fileName,fileName);
          }
        else
          {
            fprintf(stream,"\"%s\" [shape=box];\n",fileName);
          }
      }
    if (cppFileCount)
      {
        if (followCPP)
          {
            for(int i=0;i<cppFileCount;i++)
              {
                cppFile[i]->writeDotNodes(stream,followCPP);
              }
          }
        for(int i=0;i<cppFileCount;i++)
          {
            fprintf(stream,"\"%s\" -> \"%s\";\n",
                    fileName,cppFile[i]->fileName);
          }
      }
    if (hFileCount)
      {
        fprintf(stream,"\"%s\" -> { ",fileName);
        for (int i=0;i<hFileCount;i++)
          {
            fprintf(stream,"\"%s\"%c",hFile[i]->fileName,
                    (i+1)==hFileCount?' ':';');
          }
        fprintf(stream,"}\n");
        for(int i=0;i<hFileCount;i++)
          {
            hFile[i]->writeDotNodes(stream,followCPP);
          }
      }
  }

  void writeDotCPPs(FILE *stream, File *from)
  {
    if (extension==EXTCPP && from)
      {
        fprintf(stream,"\"%s\" -> \"%s\";\n",from->fileName,fileName);
      }
    if (dotted)
      {
        return;
      }
    dotted=true;
    if (extension==EXTCPP)
      {
        if (rebuild)
          {
            fprintf(stream,"\"%s\" [label=\"%s\\n(rebuild)\", style=filled, "
                    "color=lightgray, shape=box];",fileName,fileName);
          }
        else
          {
            fprintf(stream,"\"%s\" [shape=box];\n",fileName);
          }
        from=this;
      }
    for(int i=0;i<cppFileCount;i++)
      {
        cppFile[i]->writeDotCPPs(stream,from);
      }
    for(int i=0;i<hFileCount;i++)
      {
        hFile[i]->writeDotCPPs(stream,from);
      }
  }

  void writeDotCPPs2(FILE *stream)
  {
    if (dotted)
      {
        return;
      }
    dotted=true;
    if (extension==EXTCPP || hasClass)
      {
        if (rebuild)
          {
            fprintf(stream,"\"%s\" [label=\"%s\\n(rebuild%s)\", "
                    "style=filled, color=lightgray, shape=box];",
                    fileName,fileName,excluded[1]?", excluded":"");
          }
        else
          {
             if (excluded[1])
               {
                  fprintf(stream,"\"%s\" [label=\"%s\\n(excluded)\", "
                          "shape=box];",
                          fileName,fileName);
               }
             else
               {
                  fprintf(stream,"\"%s\" [shape=box];\n",fileName);
               }
          }
        for(int i=0;i<cppFileCount;i++)
          {
            clearSubDotted();
            cppFile[i]->writeDotCPPsubs(stream,this);
          }
        for(int i=0;i<hFileCount;i++)
          {
            clearSubDotted();
             bool isMine=false;
             for (int k=0;k<hFile[i]->cppFileCount;k++)
               {
                  if (this==hFile[i]->cppFile[k])
                    {
                       isMine=true;
                       break;
                    }
               }
            hFile[i]->writeDotCPPsubs(stream,this,!isMine);
          }
      }

    for(int i=0;i<cppFileCount;i++)
      {
        cppFile[i]->writeDotCPPs2(stream);
      }
    for(int i=0;i<hFileCount;i++)
      {
        hFile[i]->writeDotCPPs2(stream);
      }
  }

  void writeDotCPPsubs(FILE *stream, File *from,bool CPPOnly=false)
  {
    if (hasClass || extension==EXTCPP)
      {
        if (from!=this && !from->excluded[1] && !excluded[1])
          {
            fprintf(stream,"\"%s\" -> \"%s\";\n",from->fileName,fileName);
          }
        return;
      }
    for(int i=0;i<cppFileCount;i++)
      {
        if (from!=cppFile[i] && !from->excluded[1] && !cppFile[i]->excluded[1])
          {
            fprintf(stream,"\"%s\" -> \"%s\";\n",
                    from->fileName,cppFile[i]->fileName);
          }
      }
    if (!CPPOnly)
      {
        for(int i=0;i<hFileCount;i++)
          {
            hFile[i]->writeDotCPPsubs(stream,from,true);
          }
      }
  }

  void getIncludePath(char **paths, int &count)
    {
      if (included)
        {
          return;
        }
      included=true;
      bool insert=true;
      for(int i=0;i<count;i++)
        {
          if (!strcmp(path,paths[i]))
            {
              insert=false;
              break;
            }
        }
      if (insert)
        {
          if (path && strlen(path))
            {
              paths[count]=MakeUtilities::getStrCopy(path);
              count++;
              if (count==MAXINCLUDEPATHS)
                {
                  printf("The include paths have overflown the buffer.\n");
                  _exit(-1);
                }
            }
        }
      for(int i=0;i<hFileCount;i++)
        {
          hFile[i]->getIncludePath(paths,count);
        }
    }

  void writeObjects(FILE *stream)
    {
      if (objected)
        {
          return;
        }
      objected=true;
      if (extension==EXTCPP)
        {
          char *object=MakeUtilities::changeExtension(fullName,"o");
          fprintf(stream," %s",object);
          delete [] object;
        }
      for(int i=0;i<cppFileCount;i++)
        {
          cppFile[i]->writeObjects(stream);
        }
      for(int i=0;i<hFileCount;i++)
        {
          hFile[i]->writeObjects(stream);
        }
    }

  bool isObjFileOld(time_t t)
    {
      if (isNewer(t))
        {
          return true;
        }
      if (ageChecked)
        {
          return false;
        }
      ageChecked=true;
      for (int i=0;i<hFileCount;i++)
        {
          if (hFile[i]->isObjFileOld(t))
            {
              return true;
            }
        }
      return false;
    }

  bool isNewer(time_t t)
    {
      return (t<stats.st_mtime);
    }

  File *addDependency(File *file)
    {
      if (file)
        {
          if (file->extension==EXTH)
            {
              for (int i=0;i<hFileCount;i++)
                {
                  if (hFile[i]==file)
                    {
                      /* No need to add the same file twice. */
                      return file;
                    }
                }
              hFile[hFileCount]=file;
              hFileCount++;
              if (hFileCount==MAXDEPEND)
                {
                  printf("Cannot insert dependency. Buffer overflow. "
                         "Probably files are including each other "
                         "recursively.\n");
                  _exit(-1);
                }
            }
          else if (file->extension==EXTCPP)
            {
              for (int i=0;i<cppFileCount;i++)
                {
                  if (cppFile[i]==file)
                    {
                      /* No need to add the same file twice. */
                      return file;
                    }
                }
              cppFile[cppFileCount]=file;
              cppFileCount++;
              if (cppFileCount==MAXDEPEND)
                {
                  printf("Cannot insert dependency. Buffer overflow. "
                         "Probably files are including each other "
                         "recursively.\n");
                  _exit(-1);
                }
            }
          else if (file->extension==EXTOBJ)
            {
              if (objFile)
                {
                  printf("Cannot add more than one object file to a "
                         "source file.\n");
                  _exit(-1);
                }
              objFile=file;
            }
        }
      return file;
    }

  int getStats(void)
    {
      return stat(fullName,&stats);
    }

  void disectFilename(void)
    {
      delete [] path;
      /* No need since it is part of path! */
      // delete [] fileName;
      path=MakeUtilities::getStrCopy(fullName);
      fileName=MakeUtilities::strchrReverse(path,'/');
      if (!fileName)
        {
          fileName=path;
          path=NULL;
        }
      else
        {
          *fileName=0;
          fileName++;
        }
      char *p=MakeUtilities::strchrReverse(fullName,'.');
      if (p)
        {
          p++;
          if (!strcmp(p,"h") || !strcmp(p,"hpp") || !strcmp(p,"hh"))
            {
              extension=EXTH;
            }
          else if (!strcmp(p,"c") || !strcmp(p,"cpp") || !strcmp(p,"cc"))
            {
              extension=EXTCPP;
            }
          else if (!strcmp(p,"o") || !strcmp(p,"obj"))
            {
              extension=EXTOBJ;
            }

          p=MakeUtilities::strchrReverse(fileName,'.');
          if (p);
            {
              *p=0;
              dotName=MakeUtilities::getStrCopy(fileName,4);
              *p='.';
              strcat(dotName,"_");
              strcat(dotName,p+1);
            }
        }
    }

  void guess(void)
    {
      bool aCopy=false;
      File *tmp;
      if (extension==EXTH)
        {
          tmp=addDependency(findFile(fullName,"cpp",aCopy));
          if (!aCopy)
            {
              addFile(tmp);
            }
          if (tmp)
            {
              hasClass=false;
            }

          tmp=addDependency(findFile(fullName,"cc",aCopy));
          if (!aCopy)
            {
              addFile(tmp);
            }
          if (tmp)
            {
              hasClass=false;
            }

          tmp=addDependency(findFile(fullName,"c",aCopy));
          if (!aCopy)
            {
              addFile(tmp);
            }
          if (tmp)
            {
              hasClass=false;
            }
        }
      if (extension==EXTCPP)
        {
          tmp=addDependency(findFile(fullName,"o",aCopy));
          if (!aCopy)
            {
              addFile(tmp);
            }

          tmp=addDependency(findFile(fullName,"obj",aCopy));
          if (!aCopy)
            {
              addFile(tmp);
            }
        }
    }

  static void clearIncluded(void)
    {
      File *f=fileRoot;
      while (f)
        {
          f->included=false;
          f=f->next;
        }
    }

  static void clearAgeChecked(void)
    {
      File *f=fileRoot;
      while (f)
        {
          f->ageChecked=false;
          f=f->next;
        }
    }

  static void clearDotted(void)
    {
      File *f=fileRoot;
      while (f)
        {
          f->dotted=false;
          f=f->next;
        }
    }

  static void clearSubDotted(void)
    {
      File *f=fileRoot;
      while (f)
        {
          f->subDotted=false;
          f=f->next;
        }
    }

  static File *findFile(const char *fname, const char *ext, bool &aCopy)
    {
      char *newName=MakeUtilities::getStrCopy(fname,ext?strlen(ext)+1:0);
      if (ext)
        {
          char *p=MakeUtilities::strchrReverse(newName,'.');
          if (!p)
            {
              p=newName+strlen(newName)+1;
              *p='.';
            }
          p[1]=0;
          strcat(newName,ext);
        }
      File *res=getFileNoPath(newName);
      if (res)
        {
          delete [] newName;
          aCopy=true;
          return res;
        }
      aCopy=false;
      res=new File(newName);
      delete [] newName;
      if (!res->fileName)
        {
          delete res;
          res=NULL;
        }
      return res;
    }

  static File *getFileNoPath(const char *fname)
    {
      File *f=fileRoot;
      while (f)
        {
          if (!strcmp(f->fileName,stripPath(fname)))
            {
              return f;
            }
          f=f->next;
        }
      return NULL;
    }

public:
  static void addFile(File *file)
    {
      if (file)
        {
          if (fileRoot)
            {
              fileRoot->addNextFile(file);
            }
          else
            {
              fileRoot=file;
            }
        }
    }

  static void printRegistered(void)
    {
      File *f=fileRoot;
      while (f)
        {
          f->print(false);
          f=f->next;
        }
    }

private:
  char *fullName, *path, *fileName, *dotName;
  int extension;
  struct stat stats;
  File *objFile;
  File *cppFile[MAXDEPEND];
  File *hFile[MAXDEPEND];
  File *next;
  bool rebuild,scanned,tagged,compiled,objected,
    included,dotted,subDotted,ageChecked;
  bool excluded[EXCLUDELISTS];
  bool hasClass;
  int hFileCount,cppFileCount;
};

#endif

/*************** LOG *****************
 $Log: file.h,v $
 Revision 1.2  2001/05/13 21:56:03  pbergen
 Improved dot output.

 Revision 1.16  2001/05/09 14:00:36  pb
 Removed recusion bug in tagRebuild (isObjFileOld).

 Revision 1.15  2001/05/09 13:25:54  pb
 Fixed the bug caused in warpPath by the prior bugfix.

 Revision 1.14  2001/05/09 13:15:07  pb
 Fixed a bug in warpPath.

 Revision 1.13  2001/05/09 12:22:49  pb
 Reversed the compilation.

 Revision 1.12  2001/05/09 12:10:56  pb
 Cleaned up the source. Added new directive MAKER_ADD_DEPENDENCY.
 Added documentation.

 Revision 1.11  2001/05/08 18:10:18  pb
 Fixed a couple of bugs.

 Revision 1.10  2001/05/08 14:21:28  pb
 Works 100% and lots of new features.

 Revision 1.9  2001/05/07 17:42:00  pb
 Added conditional break if compile errors occur.

 Revision 1.8  2001/05/07 17:17:15  pb
 It really works!

 Revision 1.7  2001/05/01 07:33:25  pb
 Nothing really.

 Revision 1.6  2001/04/30 13:20:42  arnum
 Misc. small changes to unitests and xatof handles errors and matches strings
        
 Revision 1.5  2001/04/28 14:35:10  pb
 Added dot-output.
                
 Revision 1.4  2001/04/28 10:11:19  pb
 A -perhaps- working version.
                
 Revision 1.3  2001/04/27 14:23:36  pb
 It seems to start working. But there is a bug in building dependencies.

 Revision 1.2  2001/04/27 13:49:28  pb
 Added headers and footers.
*************************************/

---