NIREPFunctionParseEngine.cxx

Go to the documentation of this file.

#include "NIREPFunctionParseEngine.h"
#include "stdio.h"

NIREPFunctionParseEngine::NIREPFunctionParseEngine(void)
{
}

NIREPFunctionParseEngine::~NIREPFunctionParseEngine(void)
{
}

std::string NIREPFunctionParseEngine::functionHandler(std::string str, std::string::size_type loc)//"function("
{
  std::string capture = str.substr(0, loc);
  str = str.substr(loc+1);

  if(capture.empty()) return str;

  node = new Node;
  lst.push_back(node);

  current->child.push_back(node);
  
  node->root = current;
  node->function = capture;

  current = node;

  return str;
}
std::string NIREPFunctionParseEngine::operatorHandler(std::string str, std::string::size_type loc)//"T1:A-1"
{
  std::string capture = str.substr(0, loc);
  str = str.substr(loc+1);

  Node * temp = current; 

  current = current->root;
  if(capture.empty()) return str;

  node = new Node;
  lst.push_back(node);

  temp->child.push_back(node);
  
  node->root = temp;
  node->function = capture;

  temp = node;

  current = temp;
  current = current->root;
  
  return str;
}
std::string NIREPFunctionParseEngine::endHandler(std::string str, std::string::size_type loc)//")"
{
  std::string capture = str.substr(0, loc);
  str = str.substr(loc+1);

  Node * temp = current; 
  current = current->root;

  if(capture.empty()) return str;


  node = new Node;
  lst.push_back(node);

  temp->child.push_back(node);
  
  node->root = temp;
  node->function = capture;

  temp = node;

  current = temp;
  current = current->root;

  return str;
}

std::string NIREPFunctionParseEngine::removeSpaceTabNewLineReturn(std::string str)
{
  size_t loc;
  while((loc = str.find(' ')) != -1)
    str = str.erase(loc,1);
  while((loc = str.find('\r')) != -1)
    str = str.erase(loc,1);
  while((loc = str.find('\t')) != -1)
    str = str.erase(loc,1);
  return str;
}

bool NIREPFunctionParseEngine::CheckMismatchParenthesis(std::string str)
{
  const char * ptr = str.c_str();
  int x = 0, y = 0;
  for(unsigned int i = 0; i < str.length(); i++)
  {
    if( ptr[i] == '(' )
      x++;
    else if(ptr[i] == ')')
      y++;
    if(x-y < 0) 
      return false;
  }
  if(x != y) return false;
  return true;
}
bool NIREPFunctionParseEngine::CheckUndefinedFunction()
{
  bool undef;
  std::vector<std::string> temp_list;
  for(unsigned int i = 1; i < lst.size(); i ++)
  {
     if(lst[i]->function.find(":") == -1)
     {
      temp_list.push_back(lst[i]->function);
     }
  }
  for(unsigned int i = 0; i < temp_list.size(); i++)
  {
    undef = true;
    for(unsigned int j = 0; j < func_list.size(); j++)
    {
      if(!func_list[j].func.compare(temp_list[i]))
      {
        undef = false;
      }
    }
    if(undef)
    {
      return true;
    }
  }
  return false;
}

void NIREPFunctionParseEngine::EvaluateString(std::string str)
{
  std::string::size_type loc[3];
  while(!str.empty())
  {
    if( (loc[0] = str.find("(")) < (loc[1] =  str.find(",")))
      if( loc[0] < (loc[2] = str.find(")")) ) 
        str = functionHandler(str, loc[0]);
      else 
        str = endHandler(str, loc[2]);
    else if( loc[1] < (loc[2] = str.find(")"))) 
      str = operatorHandler(str, loc[1]);
    else str = endHandler(str, loc[2]);
  }
}

std::string NIREPFunctionParseEngine::DispatchCallBack(std::string func, std::vector<std::string> para)
{
  std::vector<std::string> para_list;
  for(unsigned int i = 0; i < para.size(); i++)
  {
    if(para[i].find(":") == 0)
      para_list.push_back(cache[para[i]]);//lookpup in temp cache
    else
      para_list.push_back(para[i]);//lookup from database
  }
  for(unsigned int i = 0; i < func_list.size(); i++)
  {
    if(!func_list[i].func.compare(func))
    {
      return (*func_list[i].ptr)(para_list); //dispatchCallBack
    }
  }
  char buffer[128];
  sprintf(buffer,"undefined function %s error", func.c_str());
  return std::string((char *)buffer);
}

std::string NIREPFunctionParseEngine::CallBackHandler()
{
 bool flag; //iteration flag, should we continue looking for calls
 std::string ret;
 do
  {
    flag = false;
    for(unsigned int i = 1; i < lst.size(); i++)
    {
      size_t cnt;
      if( (cnt = lst[i]->child.size()) >= 1)
      {
        flag = true;
        int tmp = cnt;
        for(int j = 0;j < cnt;j++)
        {
          if(lst[i]->child[j]->function.find(":") != -1)
          {
            tmp--;
          }
        }
        if(!tmp)
        {
          std::string _operator = lst[i]->function;
          std::vector<std::string> _operands;
          for(int j = 0; j < cnt; j++)//loop through children
          {
            _operands.push_back(lst[i]->child[j]->function);  
          }
   
          char buffer[32];
          sprintf((char *)buffer,"%d", tablecnt++);

          lst[i]->function = std::string(":").append(buffer);//add temp entry, so algorithm skips
          lst[i]->child.clear();//remove
          //lookup function level
          ret = cache[lst[i]->function] = DispatchCallBack(_operator, _operands);;
        }
      }
    }
  }while(flag);

  return ret;
}

void NIREPFunctionParseEngine::AddCallback(std::string fn, std::string (*func)(std::vector<std::string>))
{
  func_info info;
  info.func = fn;
  info.ptr = func;
  func_list.push_back(info);
}

void NIREPFunctionParseEngine::SetString(std::string str)
{
  this->str = str;
}
std::string NIREPFunctionParseEngine::Evaluate()
{
  tablecnt = 0;

  str = removeSpaceTabNewLineReturn(str);
  if( !CheckMismatchParenthesis(str) ){
    return std::string("Error: Mismatch Parenthesis");//return mismatch error
  }

  //create root node
  node = new Node;
  lst.push_back(node);

  root = node;
  node->root = NULL;
  current = node;

  EvaluateString(str);
  if( CheckUndefinedFunction()) {
    return std::string("Error: Undefined Function");//return undefined function
  }
  std::string ret = CallBackHandler();

  Delete();
  return ret;
}

void NIREPFunctionParseEngine::Delete()
{
  for( unsigned int i = 0; i < lst.size(); i++)
    delete lst[i];
}