/Users/barrand/private/dev/softinex/old/inexlib-1.2/inlib/inlib/columns

Go to the documentation of this file.

// Copyright (C) 2010, Guy Barrand. All rights reserved.
// See the file inlib.license for terms.

#ifndef inlib_columns
#define inlib_columns

#include <vector>
#include <ostream>

#ifdef INLIB_MEM
#include "mem"
#endif

namespace inlib {
namespace columns {

class tree {
  static const std::string& s_class() {
    static const std::string s_v("inlib::columns::tree");
    return s_v;
  }
public:
#ifdef ANDROID_NDK
  tree():m_parent(0){} //Android : for inlib STL.
#endif
  tree(tree* a_parent):m_parent(a_parent){
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  virtual ~tree(){
#ifdef INLIB_MEM
    mem::decrement(s_class().c_str());
#endif
  }
public:
  tree(const tree& a_from)
  :m_dcl(a_from.m_dcl)
  ,m_sub(a_from.m_sub)
  ,m_parent(a_from.m_parent)
  {
#ifdef INLIB_MEM
    mem::increment(s_class().c_str());
#endif
  }
  tree& operator=(const tree& a_from) {
    m_dcl = a_from.m_dcl;
    m_sub = a_from.m_sub;
    m_parent = a_from.m_parent;
    return *this;
  }
public: 
  void clear(){
    m_dcl.clear();
   {std::vector<tree>::iterator it;
    for(it=m_sub.begin();it!=m_sub.end();++it) {
      (*it).clear();
    }}
  }
  void dump_tree(std::ostream& a_out,const std::string& a_margin) {
    if(m_dcl.size()) a_out << a_margin << m_dcl << std::endl;
   {std::vector<tree>::iterator it;
    for(it=m_sub.begin();it!=m_sub.end();++it) {
      (*it).dump_tree(a_out,a_margin+"  ");
    }}
  }
public:
  std::string m_dcl;
  std::vector<tree> m_sub;
  tree* m_parent;
};

}}

#include <inlib/smanip>

namespace inlib {
namespace columns {

class parser {
public:
  parser():m_top(0){}
  virtual ~parser(){m_top.clear();}
protected:
  parser(const parser& a_from):m_top(a_from.m_top){}
private:
  parser& operator=(const parser&){return *this;}
public:
  bool parse(const std::string& a_s){
    m_top.clear();
    tree* prev = &m_top;
   {tree tmp(0);
    std::string s;
    for(std::string::const_iterator it=a_s.begin();;++it) {
      if(it==a_s.end()) {
        if(s.size()) {
          tmp.m_dcl = s;
          tmp.m_parent = prev;
          prev->m_sub.push_back(tmp);
          s.clear();
        }
        tmp.clear();
        break;
      } else {
        const char& c = *it;
        if(c==',') {
          if(s.size()) {
            tmp.m_dcl = s;
            tmp.m_parent = prev;
            prev->m_sub.push_back(tmp);
            s.clear();
          }
          tmp.clear();
        } else if(c=='{') {
          tmp.clear();
          if(s.size()) {
            tmp.m_dcl = s;
            s.clear();
          }
          tmp.m_parent = prev;
          prev->m_sub.push_back(tmp);      
          prev = &(prev->m_sub.back());
        } else if(c=='}') {
          if(s.size()) {
            tmp.m_dcl = s;
            tmp.m_parent = prev;
            prev->m_sub.push_back(tmp);
            s.clear();
          }
          tmp.clear();
          prev = prev->m_parent;
          if(!prev) return false; //should not happen.
        } else {
          s += c;
        }
      }
    }}
    return true;
  }

  void dump(std::ostream& a_out) {m_top.dump_tree(a_out,"");}
protected:
  tree m_top;
};

}}

#include <inlib/words>
#include <inlib/value>

namespace inlib {
namespace columns {

inline void delete_columns(std::vector<inlib::value>& a_vars) {
  std::vector<inlib::value>::iterator it;
  for(it=a_vars.begin();it!=a_vars.end();++it) {
    if((*it).type()==inlib::value::VOID_STAR) {
      std::vector<inlib::value>* vars = 
        (std::vector<inlib::value>*)(*it).get_void_star();
      delete_columns(*vars);
      delete vars;
    }
  }
  a_vars.clear();
}

inline void copy_columns(const std::vector<inlib::value>& a_from,
                         std::vector<inlib::value>& a_to) {
  std::vector<inlib::value>::const_iterator it;
  for(it=a_from.begin();it!=a_from.end();++it) {
    if((*it).type()==inlib::value::VOID_STAR) {
      std::vector<inlib::value>* vars = new std::vector<inlib::value>();
      inlib::value v((void*)vars);
      v.set_label((*it).label());
      a_to.push_back(v);
      std::vector<inlib::value>* p = 
        (std::vector<inlib::value>*)(*it).get_void_star(); 
      copy_columns(*p,*vars);
    } else {
      a_to.push_back(*it);
    }
  }
}

inline void dump_columns(std::ostream& a_out,
                         const std::vector<inlib::value>& a_vars,
                         const std::string& a_margin = "") {
  std::vector<inlib::value>::const_iterator it;
  for(it=a_vars.begin();it!=a_vars.end();++it) {
    if((*it).type()==inlib::value::VOID_STAR) {
      a_out << a_margin
            << "ITuple : " << (*it).label() << " : begin "
            << std::endl;
      std::vector<inlib::value>* vars = 
        (std::vector<inlib::value>*)(*it).get_void_star();
      dump_columns(a_out,*vars,a_margin+"  ");
      //a_out << a_margin
      //      << "ITuple : " << (*it).label() << " : end "
      //      << std::endl;
    } else {
      //(*it).print(a_out);
      std::string stype;        
      (*it).s_type(stype);
      std::string sval;        
      (*it).tos(sval);

      a_out << a_margin
            << stype << " : " 
            << (*it).label() << " : " 
            << sval
            << std::endl;
    }
  }
}

class finder : public inlib::columns::parser {
public:
  finder(std::ostream& a_out,const std::string& a_script) 
  :m_out(a_out)
  ,m_script(a_script)
  //,fSuccess(false)
  ,m_cur_type(inlib::value::NONE)
  {}
  virtual ~finder() {clear();}
private:
  finder(const finder& a_from):parser(a_from),m_out(a_from.m_out){}
  finder& operator=(const finder&){return *this;}
public:
  //void setScript(const std::string& a_string) { m_script = a_string;}
  bool find_variables() {
    clear();
    if(m_script.empty()) return false; //keep old version logic.
    if(!parse(m_script)) return false;    
    //dump(m_out);
    //analyse m_top :
    if(!analyse(m_top,m_stack)) {clear();return false;}
    return true;
  }

  std::vector<inlib::value> result() const {
    std::vector<inlib::value> vars;
    copy_columns(m_stack,vars);
    return vars;
  }

  void clear() {
    m_top.clear();
    delete_columns(m_stack);
    m_cur_type = inlib::value::NONE;
  }
/*
  const std::string& script() const { return m_script;}
  std::string script() { return m_script;}
  //bool isSuccess() const { return fSuccess;}
  std::ostream& out() const {return m_out;}
*/
private:
  bool analyse(inlib::columns::tree& a_tree,
                      std::vector<inlib::value>& a_stack) {
    if(a_tree.m_dcl.empty()) { //top
      //std::cout << "debug : dcl empty" << std::endl;
      std::vector<inlib::columns::tree>::iterator it;
      for(it=a_tree.m_sub.begin();it!=a_tree.m_sub.end();++it) {
        if(!analyse(*it,a_stack)) return false;
      }
    } else {
      //std::cout << "debug : dcl not empty" << std::endl;
      inlib::value* v = analyse_dcl(a_tree.m_dcl);
      if(!v) return false;
      //std::cout << "debug : dcl label " << v->label() << std::endl;
      if(a_tree.m_sub.size()) {
        if(v->type()!=inlib::value::VOID_STAR) {
          m_out << "inlib::columns::finder::analyse :"
                << " Expect a VOID_STAR."
                << std::endl;
          delete v;
          return false;
        }
        m_cur_type = inlib::value::NONE;
        std::vector<inlib::value>* stk = new std::vector<inlib::value>();
        std::vector<inlib::columns::tree>::iterator it;
        for(it=a_tree.m_sub.begin();it!=a_tree.m_sub.end();++it) {
          if(!analyse(*it,*stk)) {
            delete v;
            return false;
          }
        }
        v->set((void*)stk);
      } else {
        m_cur_type = v->type();
      }
      a_stack.push_back(*v);
      delete v;
    }
    return true;
  }
  inlib::value* analyse_dcl(const std::string& a_s) {
    std::vector<std::string> words;
    inlib::words(a_s,"=",false,words);
    if(words.size()==2) { //<type> <name>=<value>
      std::vector<std::string> swords;
      inlib::words(words[0]," ",false,swords);
      if(swords.size()==2) {

        inlib::strip(swords[0]);
        inlib::strip(swords[1]);

        if(swords[0]=="ITuple") {
  
          //create a inlib::value::VOID_STAR :
          inlib::value* v = new inlib::value((void*)0);
          v->set_label(swords[1]);
          return v;
  
        } else {
  
          inlib::value::e_type type;
          if(!s2type(swords[0],type)){
            m_out << "inlib::columns::finder::analyse_dcl :"
                  << " s2type failed for " << inlib::sout(swords[0]) << "."
                  << std::endl;
            return 0;
          }

          inlib::strip(words[1]);
          inlib::value* v = new_value(type,words[1]);
          if(!v) {
            m_out << "inlib::columns::finder::analyse_dcl :"
                  << " syntax error in " << inlib::sout(a_s) << "."
                  << " new_value() failed."
                  << std::endl;
            return 0;
          }
          v->set_label(swords[1]);
          return v;

        }

      } else if(swords.size()==1) {
        if(m_cur_type==inlib::value::NONE) {
          m_out << "inlib::columns::finder::analyse_dcl :"
                << " (1) current type is NONE."
                << std::endl;
          return 0;
        }

        inlib::strip(words[1]);
        inlib::value* v = new_value(m_cur_type,words[1]);
        if(!v) {
          m_out << "inlib::columns::finder::analyse_dcl :"
                << " syntax error in " << inlib::sout(a_s) << "."
                << " Bad value " << inlib::sout(words[1]) << "."
                << std::endl;
          return 0;
        }
        v->set_label(swords[0]);
        return v;

      } else {
        m_out << "inlib::columns::finder::analyse_dcl :"
              << " syntax error in " << inlib::sout(a_s)
              << ". Case 1."
              << std::endl;
        return 0;
      }

    } else if(words.size()==1) {
      //<type> <name>
      //<type> <name>={
      std::vector<std::string> swords;
      inlib::words(words[0]," ",false,swords);
      if(swords.size()==2) {
        inlib::strip(swords[0]);
        inlib::strip(swords[1]);

        if(swords[0]=="ITuple") {
  
          //create a inlib::value::VOID_STAR :
          inlib::value* v = new inlib::value((void*)0);
          v->set_label(swords[1]);
          return v;

        } else {
          inlib::value::e_type type;
          if(!s2type(swords[0],type)){
            m_out << "inlib::columns::finder::analyse_dcl :"
                  << " s2type failed for " << inlib::sout(swords[0]) << "."
                  << std::endl;
            return 0;
          }

          inlib::value* v = new_value(type,"");
          if(!v) {
            m_out << "inlib::columns::finder::analyse_dcl :"
                  << " (2) syntax error in " << inlib::sout(words[0]) << "."
                  << " Unknown type " << inlib::sout(swords[0]) << "."
                  << std::endl;
            return 0;
          }
          v->set_label(swords[1]);
          return v;
        }

      } else if(swords.size()==1) {

        if(m_cur_type==inlib::value::NONE) {
          m_out << "inlib::columns::finder::analyse_dcl :"
                << " (1) current type is NONE."
                << std::endl;
          return 0;
        }

        inlib::value* v = new inlib::value();
        v->set_type(m_cur_type);       
        v->set_label(swords[0]);
        return v;

      } else {
        m_out << "inlib::columns::finder::analyse_dcl :"
              << " syntax error in " << inlib::sout(a_s)
              << ". Case 2."
              << std::endl;
        return 0;
      }

    } else {
      m_out << "inlib::columns::finder::analyse_dcl :"
            << " syntax error in " << inlib::sout(a_s)
            << ". Case 3."
            << std::endl;
      return 0;
    }
  }
private:
  static bool s2type(const std::string& a_s,
                            inlib::value::e_type& a_type){
           if(a_s=="float") {
      a_type = inlib::value::FLOAT;    
    } else if(a_s=="double") {
      a_type = inlib::value::DOUBLE;    
    //} else if(a_s=="char") {
    //  a_type = inlib::value::CHAR;    
    } else if(a_s=="short") {
      a_type = inlib::value::SHORT;    
    } else if(a_s=="int") {
      a_type = inlib::value::INT;    
    } else if(a_s=="long") {
      a_type = inlib::value::INT64;    
    } else if((a_s=="bool")||(a_s=="boolean")) {
      a_type = inlib::value::BOOL;    
    } else if((a_s=="string")||(a_s=="java.lang.String")){
      a_type = inlib::value::STRING;    
    //} else if(a_s=="byte") {
    //  a_type = inlib::value::UNSIGNED_CHAR;    

    } else if(a_s=="float[]") {
      a_type = inlib::value::ARRAY_FLOAT;
    } else if(a_s=="double[]") {
      a_type = inlib::value::ARRAY_DOUBLE;
    //} else if(a_s=="char[]") {
    //  a_type = inlib::value::ARRAY_CHAR;
    //} else if(a_s=="byte[]") {
    //  a_type = inlib::value::ARRAY_UNSIGNED_CHAR;
    } else if(a_s=="short[]") {
      a_type = inlib::value::ARRAY_SHORT;
    } else if(a_s=="int[]") {
      a_type = inlib::value::ARRAY_INT;
    } else if(a_s=="long[]") {
      a_type = inlib::value::ARRAY_INT64;
    } else if((a_s=="bool[]")||(a_s=="boolean[]")) {
      a_type = inlib::value::ARRAY_BOOL;
    } else if((a_s=="string[]")||(a_s=="java.lang.String[]")){
      a_type = inlib::value::ARRAY_STRING;

    // not AIDA :
    //} else if(a_s=="uchar") {
    //  a_type = inlib::value::UNSIGNED_CHAR;    
    } else if(a_s=="ushort") {
      a_type = inlib::value::UNSIGNED_SHORT;    
    } else if(a_s=="uint") {
      a_type = inlib::value::UNSIGNED_INT;    
    } else if(a_s=="ulong") {
      a_type = inlib::value::UNSIGNED_INT64;    
    } else {
      return false;
    }
    return true;
  }
  static inlib::value* new_value(inlib::value::e_type a_type,
                                        const std::string& a_v) {
           if(a_type==inlib::value::FLOAT) {
      float v = 0;
      if(a_v.size()) {if(!inlib::to<float>(a_v,v)) return 0;}
      return new inlib::value(v);    
    } else if(a_type==inlib::value::DOUBLE) {
      double v = 0;
      if(a_v.size()) {if(!inlib::to<double>(a_v,v)) return 0;}
      return new inlib::value(v);    
    //} else if(a_type==inlib::value::CHAR) {
    //  char v = 0;
    //  if(a_v.size()) {if(!inlib::to<char>(a_v,v)) return 0;}
    //  return new inlib::value(v);    
    } else if(a_type==inlib::value::SHORT) {
      short v = 0;
      if(a_v.size()) {if(!inlib::to<short>(a_v,v)) return 0;}
      return new inlib::value(v);    
    } else if(a_type==inlib::value::INT) {
      int v = 0;
      if(a_v.size()) {if(!inlib::to<int>(a_v,v)) return 0;}
      return new inlib::value(v);    

    } else if(a_type==inlib::value::INT64) {
      int64 v = 0;
      if(a_v.size()) {if(!inlib::to<int64>(a_v,v)) return 0;}
      return new inlib::value(v);    
    } else if(a_type==inlib::value::BOOL) {
      bool v = false;
      if(a_v.size()) {if(!inlib::to(a_v,v)) return 0;}
      return new inlib::value(v);    

    } else if(a_type==inlib::value::STRING) {
      if( (a_v.size()>=2) && (a_v[0]=='"') && (a_v[a_v.size()-1]=='"') ){
        return new inlib::value(a_v.substr(1,a_v.size()-2));
      } else {
        return new inlib::value(a_v);    
      }

    //} else if(a_type==inlib::value::UNSIGNED_CHAR) {
    //  unsigned short v = 0;
    //  if(a_v.size()) {if(!inlib::to<unsigned short>(a_v,v)) return 0;}
    //  return new inlib::value((unsigned char)v);    

    } else if(a_type==inlib::value::UNSIGNED_SHORT) {
      unsigned short v = 0;
      if(a_v.size()) {if(!inlib::to<unsigned short>(a_v,v)) return 0;}
      return new inlib::value(v);    
    } else if(a_type==inlib::value::UNSIGNED_INT) {
      unsigned int v = 0;
      if(a_v.size()) {if(!inlib::to<unsigned int>(a_v,v)) return 0;}
      return new inlib::value(v);    

    } else if(a_type==inlib::value::UNSIGNED_INT64) {
      uint64 v = 0;
      if(a_v.size()) {if(!inlib::to<uint64>(a_v,v)) return 0;}
      return new inlib::value(v);    

    } else if(a_type==inlib::value::ARRAY_FLOAT) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();    
      v->set_type(inlib::value::ARRAY_FLOAT);
      return v;
    } else if(a_type==inlib::value::ARRAY_DOUBLE) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();
      v->set_type(inlib::value::ARRAY_DOUBLE);
      return v;
    //} else if(a_type==inlib::value::ARRAY_UNSIGNED_CHAR) {
    //  if(a_v.size()) return 0;
    //  inlib::value* v = new inlib::value();
    //  v->set_type(inlib::value::ARRAY_UNSIGNED_CHAR);
    //  return v;
    //} else if(a_type==inlib::value::ARRAY_CHAR) {
    //  if(a_v.size()) return 0;
    //  inlib::value* v = new inlib::value();
    //  v->set_type(inlib::value::ARRAY_CHAR);
    //  return v;
    } else if(a_type==inlib::value::ARRAY_SHORT) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();
      v->set_type(inlib::value::ARRAY_SHORT);
      return v;
    } else if(a_type==inlib::value::ARRAY_INT) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();
      v->set_type(inlib::value::ARRAY_INT);
      return v;
    } else if(a_type==inlib::value::ARRAY_INT64) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();
      v->set_type(inlib::value::ARRAY_INT64);
      return v;
    } else if(a_type==inlib::value::ARRAY_BOOL) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();
      v->set_type(inlib::value::ARRAY_BOOL);
      return v;
    } else if(a_type==inlib::value::ARRAY_STRING) {
      if(a_v.size()) return 0;
      inlib::value* v = new inlib::value();
      v->set_type(inlib::value::ARRAY_STRING);
      return v;
    } else {
      return 0;
    }
  }
public:
  std::ostream& m_out;
  std::string m_script;
  std::vector<inlib::value> m_stack;
  inlib::value::e_type m_cur_type;
  //bool fSuccess;
};

}}

#endif