#ifndef ACTIONSANDRULES_H
#define ACTIONSANDRULES_H
/////////////////////////////////////////////////////////////////////
//  ActionsAndRules.h - declares new parsing rules and actions     //
//                                                                 //
//  Language:      Visual C++ 2005                                 //
//  Platform:      Dell Dimension 9150, Windows XP SP2             //
//  Application:   Prototype for CSE687 Pr1, Sp06                  //
//  Author:        Jim Fawcett, CST 2-187, Syracuse University     //
//                 (315) 443-3948, jfawcett@twcny.rr.com           //
/////////////////////////////////////////////////////////////////////
/*
  Module Operations: 
  ==================
  This module defines several action classes.  Its classes provide 
  specialized services needed for specific applications.  The modules
  Parser, SemiExpression, and Tokenizer, are intended to be reusable
  without change.  This module provides a place to put extensions of
  these facilities and is not expected to be reusable.
  

  Public Interface:
  =================
  Toker t(someFile);              // create tokenizer instance
  SemiExp se(&t);                 // create a SemiExp attached to tokenizer
  Parser parser(se);              // now we have a parser
  Rule1 r1;                       // create instance of a derived Rule class
  Action1 a1;                     // create a derived action
  r1.addAction(&a1);              // register action with the rule
  parser.addRule(&r1);            // register rule with parser
  while(se.getSemiExp())          // get semi-expression
    parser.parse();               //   and parse it

  Build Process:
  ==============
  Required files
    - Parser.h, Parser.cpp, ActionsAndRules.h, ActionsAndRules.cpp,
      SemiExpression.h, SemiExpression.cpp, tokenizer.h, tokenizer.cpp
  Build commands (either one)
    - devenv Project1HelpS06.sln
    - cl /EHsc /DTEST_PARSER parser.cpp ActionsAndRules.cpp \
         semiexpression.cpp tokenizer.cpp /link setargv.obj

  Maintenance History:
  ====================
  ver 1.0 : 12 Jan 06
  - first release

*/
//
#include <map>
#include <algorithm>
#include <string>
#include "Parser.h"
#include "semiexpression.h"

void showMap(std::map<std::string,std::string>* pMap);

///////////////////////////////////////////////////////////////
// rule to detect preprocessor statements

class CodeStatement : public IRule
{
public:
  bool doTest(SemiExp& se)
  {
    if(se.find("#") < se.length())
      return false;
    for(int i=0; i<se.length(); ++i)
    {
      if(!se.isComment(se[i]))
      {
        doActions(se);
        return true;
      }
    }
    return false;
  }
};

///////////////////////////////////////////////////////////////
// rule to detect preprocessor statements

class PreprocStatement : public IRule
{
public:
  bool doTest(SemiExp& se)
  {
    if(se.find("#") < se.length())
    {
      doActions(se);
      return true;
    }
    return false;
  }
};

///////////////////////////////////////////////////////////////
// rule to detect comments

class CommentStatement : public IRule
{
public:
  bool doTest(SemiExp& se)
  {
    for(int i=0; i<se.length(); ++i)
    {
      if(se.isComment(se[i]))
      {
        doActions(se);
        return true;
      }
    }
    return false;
  }
};

///////////////////////////////////////////////////////////////
// rule to detect function definitions

class FunctionDefinition : public IRule
{
public:
  bool isSpecialKeyWord(const std::string& tok)
  {
    const static std::string keys[]
      = { "for", "while", "switch", "if", "catch" };
    for(int i=0; i<5; ++i)
      if(tok == keys[i])
        return true;
    return false;
  }
  bool doTest(SemiExp& se)
  {
    if(se[se.length()-1] == "{")
    {
      int len = se.find("(");
      if(len < se.length() && !isSpecialKeyWord(se[len-1]))
      {
        doActions(se);
        return true;
      }
    }
    return false;
  }
};

//
///////////////////////////////////////////////////////////////
// action to send signature of a function def to console

class PrettyPrintFunction : public IAction
{
public:
  void doAction(SemiExp& se)
  {
    SemiExp temp = se;
    temp.remove("public");
    temp.remove(":");
    temp.trimFront();
    int len = temp.find(")");
    std::cout << "\n\n  Pretty Stmt:    ";
    for(int i=0; i<len+1; ++i)
      std::cout << temp[i] << " ";
  }
};

//
///////////////////////////////////////////////////////////////
// action to store a preprocessor statement in queue

class PreprocToMap : public IAction
{
  std::map<std::string,std::string>* pMap;

public:
  PreprocToMap(std::map<std::string,std::string>& resultMap) : pMap(&resultMap) {}
  void doAction(SemiExp& se)
  {
    se.toLower();
    if(se.length() < 2)
      return;
    int pos = se.find("ifndef");
    if(pos < se.length())
      (*pMap)[se[pos]] = se[pos+1];
    pos = se.find("define");
    if(pos < se.length())
      (*pMap)[se[pos]] = se[pos+1];
    pos = se.find("ifdef");
    if(pos < se.length())
      (*pMap)[se[pos]] = se[pos+1];

    if(se.find("endif") < se.length())
      (*pMap)["endif"] = "";
  }
};

class CommentToMap : public IAction
{
  std::map<std::string,std::string>* pMap;
public:
  CommentToMap(std::map<std::string,std::string>& resultMap) : pMap(&resultMap) {}
  void doAction(SemiExp& se)
  {
    se.toLower();
    size_t pos;
    for(int i=0; i<se.length(); ++i)
    {
      size_t len = se[i].size();
      if(se.isComment(se[i]))
      {
        pos = se[i].find("language");
        if( pos<len)
          (*pMap)["language"] = "";
        pos = se[i].find("platform");
        if( pos<len)
          (*pMap)["platform"] = "";
        pos = se[i].find("application");
        if( pos<len)
          (*pMap)["application"] = "";
        pos = se[i].find("author");
        if( pos<len)
          (*pMap)["author"] = "";
        pos = se[i].find("operations");
        if( pos<len) 
          (*pMap)["manual"] = "";
        pos = se[i].find("interface");
        if( pos<len)
          (*pMap)["manual"] = "";
        pos = se[i].find("build");
        if( pos<len)
          (*pMap)["build"] = "";
        pos = se[i].find("required");
        if( pos<len)
          (*pMap)["required"] = "files";
        pos = se[i].find("compile");
        if( pos<len)
          (*pMap)["compiler"] = "command";
        pos = se[i].find("command");
        if( pos<len)
          (*pMap)["compiler"] = "command";
        pos = se[i].find("maintenance");
        if( pos<len)
          (*pMap)["maintenance"] = "history";
        pos = se[i].find("history");
        if( pos<len)
          (*pMap)["maintenance"] = "history";
//        showMap(pMap);
      }
    }
  }
};

class CodeToMap : public IAction
{
  std::map<std::string,std::string>* pMap;
public:
  CodeToMap(std::map<std::string,std::string>& resultMap) : pMap(&resultMap) {}
  void doAction(SemiExp& se)
  {
    se.toLower();
    if(se.find("main") < se.length())
      (*pMap)["main"] = "";
  }
};

#endif