NetlistParser.h

Go to the documentation of this file.

#ifndef NETLISTPARSER_H_
#define NETLISTPARSER_H_

#include <vector>
#include <string>
#include <map>
#include <set>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <utility>
#include <boost/utility.hpp>

#include <cstring>
#include <cassert>
#include <cstdio>

#include "logicDefs.h"
#include "comDefs.h"

class NetlistTokenizer: public boost::noncopyable {
private:
  std::ifstream ifs;

  const char* delim;

  const char* comments;


  char* linePtr;

  char* nextTokPtr;

  char* currTokPtr;

private:

  bool isCommentBegin () const {
    std::string tok(nextTokPtr);
    if (tok.find (comments) == 0) {
      return true;
    } else {
      return false;
    }
  }

  char* getNextLine () {
    // read next line
    std::string currLine;

    if (ifs.eof () || ifs.bad ()) {
      linePtr = NULL;
    }
    else {

      std::getline (ifs, currLine);

      delete[] linePtr;
      linePtr = new char[currLine.size () + 1];
      strcpy (linePtr, currLine.c_str ());
    }

    return linePtr;
  }

  char* readNextToken () {
    nextTokPtr = strtok (NULL, delim);

    while (nextTokPtr == NULL || isCommentBegin ()) {
          linePtr = getNextLine ();
          if (linePtr == NULL) {
            nextTokPtr = NULL;
            break;
          }
          nextTokPtr = strtok (linePtr, delim);
    }
    return nextTokPtr;
  }

public:
  NetlistTokenizer (const char* fileName, const char* delim, const char* comments)
    : ifs(fileName), delim (delim), comments(comments), linePtr (NULL), currTokPtr (NULL)  {

    if (!ifs.good ()) {
      std::cerr << "Failed to open this file for reading: " << fileName << std::endl; 
      abort ();
    }
    nextTokPtr = readNextToken();

  }

  const std::string nextToken () {
    assert (nextTokPtr != NULL);
    
    std::string retval(nextTokPtr);
    nextTokPtr = readNextToken ();

    return retval;
  }

  bool hasMoreTokens () const {
    return !ifs.eof() || nextTokPtr != NULL;
  }
};

struct GateRec {

  std::string name;

  std::vector<std::string> outputs;

  std::vector<std::string> inputs;

  SimTime delay;

  void addOutput(const std::string& net) {
    outputs.push_back(net);
  }

  void addInput(const std::string& net) {
    inputs.push_back(net);
  }

  void setDelay(const SimTime& delay) {
    this->delay = delay;
  }

  void setName(const std::string& name) {
    this->name = name;
  }

  const std::string& getName() const {
    return name;
  }
};

class NetlistParser {
public:

  static const char* DELIM;

  static const char* COMMENTS;

public:
  typedef std::map<std::string, std::vector<std::pair<SimTime, LogicVal> > > StimulusMapType;

private:
  const char* netlistFile;

  std::vector<std::string> inputNames;

  std::vector<std::string> outputNames;

  std::map<std::string, LogicVal> outValues;

  StimulusMapType inputStimulusMap;

  std::vector<GateRec> gates;

  SimTime finishTime;



private:

  static const std::set<std::string>  oneInputGates () {
    std::set<std::string> oneInSet;
    oneInSet.insert (toLowerCase (std::string("INV")));
    return oneInSet;
  }

  static const std::set<std::string> twoInputGates () {
    std::set<std::string> twoInSet;
    twoInSet.insert (toLowerCase (std::string ("AND2")));
    twoInSet.insert (toLowerCase (std::string ("OR2")));
    twoInSet.insert (toLowerCase (std::string ("NAND2")));
    twoInSet.insert (toLowerCase (std::string ("NOR2")));
    twoInSet.insert (toLowerCase (std::string ("XOR2")));
    twoInSet.insert (toLowerCase (std::string ("XNOR2")));
    return twoInSet;
  }


  static void parsePortList(NetlistTokenizer& tokenizer, std::vector<std::string>& portNames) {
    std::string token = toLowerCase (tokenizer.nextToken ());
    while (token != ("end")) {
      portNames.push_back(token);
      token = toLowerCase (tokenizer.nextToken ());
    }
  }

  static void parseOutValues(NetlistTokenizer& tokenizer, std::map<std::string, LogicVal>& outValues) {
    std::string token = toLowerCase (tokenizer.nextToken ());
    while (token != ("end")) {
      std::string outName = token;
      token = toLowerCase (tokenizer.nextToken ());
      LogicVal value = token[0];
      token = toLowerCase (tokenizer.nextToken ());

      outValues.insert (std::make_pair(outName, value));
    }
  }

  static void parseInitList(NetlistTokenizer& tokenizer, StimulusMapType& inputStimulusMap) {
    // capture the name of the input signal
    std::string input = toLowerCase (tokenizer.nextToken ());

    std::string token = toLowerCase (tokenizer.nextToken ());

    std::vector<std::pair<SimTime, LogicVal> > timeValList;
    while (token != ("end")) {

      SimTime t = static_cast<SimTime> (atol (token.c_str ())); // SimTime.parseLong(token);

      token = toLowerCase (tokenizer.nextToken ());
      LogicVal v = token[0];

      timeValList.push_back (std::make_pair(t, v));

      token = toLowerCase (tokenizer.nextToken ());
    }

    inputStimulusMap.insert (std::make_pair(input, timeValList));
  }

  static void parseNetlist(NetlistTokenizer& tokenizer, std::vector<GateRec>& gates) {

    std::string token = toLowerCase (tokenizer.nextToken ());

    while (token != ("end")) {

      if (oneInputGates().count (token) > 0) {

        GateRec g;
        g.setName(token); // set the gate name

        token = toLowerCase (tokenizer.nextToken ()); // output name
        g.addOutput(token);

        token = toLowerCase (tokenizer.nextToken ()); // input
        g.addInput(token);

        // possibly delay, if no delay then next gate or end
        token = toLowerCase (tokenizer.nextToken ());
        if (token[0] == '#') {
          token = token.substr(1);
          SimTime d = static_cast<SimTime> (atol (token.c_str ())); // SimTime.parseLong(token);
          g.setDelay(d);
          gates.push_back (g);
        } else {
          gates.push_back (g);
          continue;
        }
      } else if (twoInputGates().count (token) > 0) {
        GateRec g;
        g.setName(token); // set the gate name

        token = toLowerCase (tokenizer.nextToken ()); // output name
        g.addOutput(token);

        token = toLowerCase (tokenizer.nextToken ()); // input 1
        g.addInput(token);

        token = toLowerCase (tokenizer.nextToken ()); // input 2
        g.addInput(token);

        // possibly delay, if no delay then next gate or end
        token = toLowerCase (tokenizer.nextToken ());
        if (token[0] == '#') {
          token = token.substr(1);
          SimTime d = static_cast<SimTime> (atol (token.c_str ())); // SimTime.parseLong(token);
          g.setDelay(d);
          gates.push_back (g);
        } else {
          gates.push_back (g);
          continue;
        }
      } else {
        std::cerr << "Unknown type of gate " << token << std::endl;
        abort ();
      }

      //necessary to move forward in the while loop
      token = toLowerCase (tokenizer.nextToken ());
    } // end of while
  }

public:
  NetlistParser(const char* netlistFile): netlistFile(netlistFile) {
    parse(netlistFile);
  }

  void parse(const char* fileName) {
    std::cout << "input: reading circuit from file: " << fileName << std::endl;


    NetlistTokenizer tokenizer (fileName, DELIM, COMMENTS);

    std::string token;

    while (tokenizer.hasMoreTokens()) {

      token = toLowerCase (tokenizer.nextToken ());

      if (token == ("inputs")) {
        parsePortList(tokenizer, inputNames);
      } else if (token == ("outputs")) {
        parsePortList(tokenizer, outputNames);
      } else if (token == ("outvalues")) {
        parseOutValues(tokenizer, outValues);
      } else if (token == ("finish")) {
        token = toLowerCase (tokenizer.nextToken ());
        finishTime = static_cast<SimTime> (atol (token.c_str ())); // SimTime.parseLong(token);
      } else if (token == ("initlist")) {
        parseInitList(tokenizer, inputStimulusMap);
      } else if (token == ("netlist")) {
        parseNetlist(tokenizer, gates);
      }
    } // end outer while

  } // end parse()


  const SimTime& getFinishTime() const {
    return finishTime;
  }

  const char* getNetlistFile() const {
    return netlistFile;
  }

  const std::vector<std::string>& getInputNames() const {
    return inputNames;
  }

  const std::vector<std::string>& getOutputNames() const {
    return outputNames;
  }

  const std::map<std::string, LogicVal>& getOutValues() const {
    return outValues;
  }

  const StimulusMapType& getInputStimulusMap() const {
    return inputStimulusMap;
  }

  const std::vector<GateRec>& getGates() const {
    return gates;
  }

};


#endif /* NETLISTPARSER_H_ */

---