makestate.h

Go to the documentation of this file.

#ifndef MAKESTATE_H
#define MAKESTATE_H

#include <cassert>
#include <iostream>
#include <queue>
using namespace std;

#include <makefilebtglobals.h>
#include <projfiles.h>
#include <print.h>
#include <systemcalls.h>
#include <tokenizer.h>

template <typename CFC>
class makestate
{
public:
  
  CFC processed;
  CFC standard;
  CFC unknown;

  CFC processqueue2;
  deque<compilationfile*> processqueue;
  void processqueueadd(compilationfile* cf);

  CFC objs;

  void standardbuild();

  ~makestate();

  void print();

  makestate();

  bool printobjs;
  bool printprocessed;
  bool printprocessqueue;
  bool printstandard;
  bool printunknown;
  bool printobjsdependencies;

  void printdefaults();

  void printafterbuild();

  void eval(compilationfile& cf);
  void evaldriver();

  void objseval(compilationfile& cf);
  void objseval(compilationfile& cf, compilationfile& h );

  void objsdependenciesPass1();
  void objsdependenciesPass2();
  

  compilationfile* isinprocesschain(stringc & filename) const;

  projfiles<CFC> proj;

  string driver;

  boolc valid();

private:
  void printcontainer(CFC& i, stringc & cont);

};


//---------------------------------------------------------
// Implementation

template<typename CFC>
compilationfile* makestate<CFC>::isinprocesschain(stringc & filename) const
{
  compilationfile* x;

  x = standard[filename];
  if (x)
    return x;
  
  x = processed[filename];
  if (x)
    return x;

  x = unknown[filename];
  if (x)
    return x;

  x = processqueue2[filename];
  if (x)
    return x;

  return 0;
}

template<typename CFC>
void makestate<CFC>::printafterbuild()
{
  printprocessed=true;
  printstandard=false;
  printunknown=true;
  printobjs=false;
  printprocessqueue=false;
  printobjsdependencies=false;

  print();
}

template<typename CFC>
void makestate<CFC>::print()
{
  if (printprocessed)
    printcontainer(processed,"processed");
  if (printstandard)
    printcontainer(standard,"standard");
  if (printunknown)
    printcontainer(unknown,"unknown");
  if (printobjs)
    printcontainer(objs,"objs");
  //printcontainer(processqueue2,"processqueue2");

  if (printprocessqueue)
  {
    cout << "processqueue: ";
    if (!processqueue.empty()) 
    {
      for (deque<compilationfile*>::const_iterator i=processqueue.begin();
        i != processqueue.end(); i++)
        cout << " " << (*i)->filename;
      cout << endl;
    }
    else
      cout << endl;
  }

  if (printobjsdependencies)
  {
    cout << "objsdependencies:" << endl;
    compilationfile* x;
    for ( objs.reset(); !objs; ++objs )
    {
      x = objs();
      assert(x);
      cout << x->filename << ": ";
      uint imax=x->includes.size();
      for (uint i=0; i<imax; ++i)
      {
        assert(x->includes[i]);
        cout << " " << x->includes[i]->filename;
      }
      cout << endl;
    }
  }

  assert(valid());
  cout << endl;
}

template<typename CFC>
void makestate<CFC>::printcontainer
(
  CFC& i,
  stringc & cont
)
{
  cout << cont << ": ";
  i.reset();
  if (!i)
  {
    for (; !i; ++i)
    {
      assert(i()!=0);
      cout << " " << i()->filename;
    }
    cout << endl;
  }
  else
    cout << endl;
}

template<typename CFC>
makestate<CFC>::~makestate()
{
  // Cleanup as created separately
  for ( objs.reset(); !objs; ++objs)
    delete objs();
}

template<typename CFC>
void makestate<CFC>::standardbuild()
{
  string standardstring="algorithm bitset cassert cctype cfloat climits cmath complex cstddef cstdlib cstring ctime deque exception fstream functional iomanip ios iosfwd iostream istream iterator limits list local map memory new numeric ostream queue set sstream stack stdexcept streambuf string strstream typeinfo utility valarray vector";

  tokenizer ss(standardstring);
  ss.subtract(" ");

  compilationfile* x;
  for (ss.reset(); !ss; ++ss)
  {
    x = new compilationfile("",ss(),compilationfile::header); 
    standard.add(x);
    //cout << ss() << endl;
  }
}

template<typename CFC>
boolc makestate<CFC>::valid()
{
  // The processqueue is contained in processqueue2
  //   They should have the same elements exactly, but I am not
  //   testing in the other direction.
  if (!processqueue.empty()) 
  {
    for (deque<compilationfile*>::const_iterator i=processqueue.begin();
      i != processqueue.end(); i++)
    {
      if ( processqueue2[ (*i)->filename ] == 0 )
        return false;
    }
  }

  return true;
}

template<typename CFC>
void makestate<CFC>::processqueueadd(compilationfile* cf)
{
  processqueue2.add(cf);
  processqueue.push_back(cf);
} 

template<typename CFC>
void makestate<CFC>::evaldriver()
{
  assert(!proj.driver.empty());

  compilationfile* x = proj.files[proj.driverh()];
  processed.add(x); 
  compilationfile* x2 = proj.files[proj.drivercpp()];
  processqueueadd(x2);
  x->linkheader = x;
  x->linksource = x2;
}

template<typename CFC>
void makestate<CFC>::eval(compilationfile& cf)
{
//cout << SHOW(cf.filename) << endl;
//cout << SHOW(cf.linkheader) << endl;
//cout << SHOW(cf.linksource) << endl;
//cout << SHOW(cf.linkobj) << endl;
  // Has this object been evaluated before?
  if (cf.linkheader || cf.linksource || cf.linkobj)
    return;

  assert(cf.includes.empty());

  assert(!cf.path.empty());  

  systemcalls sys01
  (
    "perl ../makefilebuildtool/extractheaders.pl " + cf.path + cf.filename,
//    "tempheaders.txt"
    makefilebtglobals::tempheaders
  );
  sys01.eval();

  compilationfile* x;
  string filename;
  
  for (uint i=0; i<sys01.lines.size(); ++i)
  {
    filename=sys01.lines[i];
    if (standard[filename])
       continue;

    // Assume the headers have a .h extension.
    filename += ".h";

    x = isinprocesschain(filename);
    if (x)
    {
//      cf.includes.push_back(x);
        cf.includesadd(x);
      continue;
    }

    assert(!x); //make sure continue works.
//cout << "Not in process chain." << endl;
//cout << SHOW(filename) << endl;

    x = proj.files[filename];
    if (!x)
    {
      unknown.add(new compilationfile("",filename));
      continue;
    }

    processqueueadd(x);

    //cf.includes.push_back(x);
    cf.includesadd(x);

//cout << sys01.lines[i] << endl;;    
  }


  if (cf.ft==compilationfile::header)
  {
    // Headers are included before cpp,

    cf.linkheader= &cf;
    x = proj.files[cf.component()+".cpp"];
    if (x)
    {
      cf.linksource = x;
      processqueueadd(x);
    }
  }

  if (cf.ft==compilationfile::source)
  {
    cf.linksource = &cf;

    x = proj.files[cf.component()+".h"];
    assert(x);
    cf.linkheader = x;

    assert(cf.component() == x->linkheader->component());

    x = new compilationfile(cf.path,cf.component()+".o");
    x->linkobj = x;
    x->linksource = &cf;
    x->linkheader = cf.linkheader;

//cout << "*11*" << cf.filename << endl;
    cf.linkheader->linkobj = x;
    cf.linkobj = x;

    objs.add(x);
  }

}

template<typename CFC>
void makestate<CFC>::printdefaults()
{
  printobjs=true;
  printprocessqueue=true;
  printprocessed=true;
  printstandard=false;
  printunknown=true;
  printobjsdependencies=false;
}

template<typename CFC>
makestate<CFC>::makestate()
  : driver("main")
{
  // I have chosen this on my current project size, for example
  //  I may have about 50 files being in a container realistically,
  //  by making the default much larger it should handle more code
  //  that has many more files.
  uintc size=500;
  processed.construct(size);
  standard.construct(size);
  unknown.construct(size);
  processqueue2.construct(size);
  objs.construct(size);
  
  printdefaults();
}

template<typename CFC>
void makestate<CFC>::objsdependenciesPass1()
{
//  assert(objs.size()!=0);

  for (objs.reset(); !objs; ++objs)
    objseval(*objs());

  // The driver programs virtual .h file is to be deleted.
  objs.reset();
  if (!objs)
    objs()->includes.pop_back();
}

template<typename CFC>
void makestate<CFC>::objsdependenciesPass2()
{

  compilationfile *x;
  compilationfile *y;
  for (objs.reset(); !objs; ++objs)
  {
    x=objs();   
    uint imax = x->includes.size();
    for (uint i=0; i<imax; ++i)
    {
      y = x->includes[i];
      if (y->ft!=compilationfile::obj)
        continue;

      uint kmax = y->includes.size();
      for (uint k=0; k<kmax; ++k)
      {
        if (x!=y->includes[k])
          continue;
        
        // Searched and found circular dependency
        //cout << SHOW(i) << "  " << SHOW(k) << endl;
        x->includes[i] = x->includes[i]->linkheader;
        //x->includes.push_back( x->includes[i]->linksource );
        x->includesadd(x->includes[i]->linksource );
        y->includes[k] = y->includes[k]->linkheader;
        //y->includes.push_back( y->includes[k]->linksource );
        y->includesadd( y->includes[k]->linksource );
      }
    }
  }
}

// Recursive descent
template<typename CFC>
void makestate<CFC>::objseval(compilationfile& cf, compilationfile& h )
{
  assert(cf.ft==compilationfile::obj);
  assert(h.ft==compilationfile::header);
  assert(h.linksource==0);
  assert(h.linkobj==0);

  // Unknown files are assumed to work, often part of a library,
  //  which I assume is constant.  e.g. GL/gl.h GL/glut.h
  if (unknown[h.filename])
    return;

  // Stop infinite recursion, case already handled.
  if (cf.includesadd(&h)==false)
    return;

  uint imax=h.includes.size();
  compilationfile* y;
  for (uint i=0; i<imax; ++i)
  {
    y = h.includes[i];
    if (y->linkobj)
      cf.includesadd(y->linkobj);
    else
      objseval(cf,*y);
  }
}

template<typename CFC>
void makestate<CFC>::objseval(compilationfile& cf)
{
  assert(cf.ft==compilationfile::obj);

//cout << SHOW(cf.filename) << endl;

  compilationfile* x; 

  // Descend into the header first.
  x = cf.linkheader;
  assert(x);
  assert(x->includesvalid());
  assert(cf.includes.size()==0);

  uint imax;
  compilationfile* y;

  imax = x->includes.size();
  for (uint i=0; i<imax; ++i)
  {
    y = x->includes[i];
assert(y!=0);
    if (y->linkobj)
      cf.includesadd(y->linkobj);
    else
      objseval(cf,*y);
  }

  // Now descend into the cpp
  x = cf.linksource;
  assert(x);
  assert(x->includesvalid());
  imax = x->includes.size();
  for (uint i=0; i<imax; ++i)
  {
    y = x->includes[i];
    if (y->linkobj)
      cf.includesadd(y->linkobj);
    else
      objseval(cf,*y);
  }

  // Add the cpp and headers
  cf.includesadd(cf.linksource);
  cf.includesadd(cf.linkheader);
}

#endif