tools::columns::finder Class Reference

Inheritance diagram for tools::columns::finder:

Collaboration diagram for tools::columns::finder:

Public Member Functions
	finder (std::ostream &a_out, const std::string &a_script)
virtual	~finder ()
bool	find_variables ()
void	result (std::vector< value > &a_vars) const
void	clear ()
Public Member Functions inherited from tools::columns::parser
	parser ()
virtual	~parser ()
bool	parse (const std::string &a_s)
void	dump (std::ostream &a_out)

Public Attributes
std::ostream &	m_out
std::string	m_script
std::vector< value >	m_stack
value::e_type	m_cur_type

Protected Member Functions
	finder (const finder &a_from)
finder &	operator= (const finder &)
bool	analyse (columns::tree &a_tree, std::vector< value > &a_stack)
value *	analyse_dcl (const std::string &a_s)
Protected Member Functions inherited from tools::columns::parser
	parser (const parser &)
parser &	operator= (const parser &)

Static Protected Member Functions
static bool	s2type (const std::string &a_s, value::e_type &a_type)
static value *	new_value (value::e_type a_type, const std::string &a_v)

Additional Inherited Members
Protected Attributes inherited from tools::columns::parser
tree	m_top

Detailed Description

Definition at line 180 of file columns.

Constructor & Destructor Documentation

finder() [1/2]

tools::columns::finder::finder ( std::ostream &  a_out, const std::string &  a_script  )

inline

Definition at line 183 of file columns.

  :m_out(a_out)
  ,m_script(a_script)
  //,fSuccess(false)
  ,m_cur_type(value::NONE)
  {}

~finder()

virtual tools::columns::finder::~finder ( )

inlinevirtual

Definition at line 189 of file columns.

{clear();}

finder() [2/2]

tools::columns::finder::finder ( const finder &  a_from )

inlineprotected

Definition at line 191 of file columns.

:parent(a_from),m_out(a_from.m_out){}

Member Function Documentation

analyse()

bool tools::columns::finder::analyse ( columns::tree &  a_tree, std::vector< value > &  a_stack  )

inlineprotected

Definition at line 221 of file columns.

                                                              {
    if(a_tree.m_dcl.empty()) { //top
      //std::cout << "debug : dcl empty" << std::endl;
      tools_vforit(columns::tree*,a_tree.m_sub,it) {
        if(!analyse(*(*it),a_stack)) return false;
      }
    } else {
      //std::cout << "debug : dcl not empty" << std::endl;
      if(is_spaces(a_tree.m_dcl)) return true;
      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()!=value::VOID_STAR) {
          m_out << "tools::columns::finder::analyse :"
                << " Expect a VOID_STAR."
                << std::endl;
          delete v;
          return false;
        }
        m_cur_type = value::NONE;
        std::vector<value>* stk = new std::vector<value>();
        tools_vforit(columns::tree*,a_tree.m_sub,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;
  }

analyse_dcl()

value* tools::columns::finder::analyse_dcl ( const std::string &  a_s )

inlineprotected

Definition at line 258 of file columns.

                                           {
    std::vector<std::string> ws;
    words(a_s,"=",false,ws);
    if(ws.size()==2) { //<type> <name>=<value>
      std::vector<std::string> swords;
      words(ws[0]," ",false,swords);
      if(swords.size()==2) {
 
        strip(swords[0]);
        strip(swords[1]);
 
        if(swords[0]=="ITuple") {
 
          //create a value::VOID_STAR :
          value* v = new value((void*)0);
          v->set_label(swords[1]);
          return v;
 
        } else {
 
          value::e_type type;
          if(!s2type(swords[0],type)){
            m_out << "tools::columns::finder::analyse_dcl :"
                  << " s2type failed for " << sout(swords[0]) << "."
                  << std::endl;
            return 0;
          }
 
          strip(ws[1]);
          value* v = new_value(type,ws[1]);
          if(!v) {
            m_out << "tools::columns::finder::analyse_dcl :"
                  << " syntax error in " << 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==value::NONE) {
          m_out << "tools::columns::finder::analyse_dcl :"
                << " (1) current type is NONE."
                << std::endl;
          return 0;
        }
 
        strip(ws[1]);
        value* v = new_value(m_cur_type,ws[1]);
        if(!v) {
          m_out << "tools::columns::finder::analyse_dcl :"
                << " syntax error in " << sout(a_s) << "."
                << " Bad value " << sout(ws[1]) << "."
                << std::endl;
          return 0;
        }
        v->set_label(swords[0]);
        return v;
 
      } else {
        m_out << "tools::columns::finder::analyse_dcl :"
              << " syntax error in " << sout(a_s)
              << ". Case 1."
              << std::endl;
        return 0;
      }
 
    } else if(ws.size()==1) {
      //<type> <name>
      //<type> <name>={
      std::vector<std::string> swords;
      words(ws[0]," ",false,swords);
      if(swords.size()==2) {
        strip(swords[0]);
        strip(swords[1]);
 
        if(swords[0]=="ITuple") {
 
          //create a value::VOID_STAR :
          value* v = new value((void*)0);
          v->set_label(swords[1]);
          return v;
 
    } else {
          value::e_type type;
          if(!s2type(swords[0],type)){
            m_out << "tools::columns::finder::analyse_dcl :"
                  << " s2type failed for " << sout(swords[0]) << "."
                  << std::endl;
            return 0;
          }
 
          value* v = new_value(type,"");
          if(!v) {
            m_out << "tools::columns::finder::analyse_dcl :"
                  << " (2) syntax error in " << sout(ws[0]) << "."
                  << " Unknown type " << sout(swords[0]) << "."
                  << std::endl;
            return 0;
          }
          v->set_label(swords[1]);
          return v;
        }
 
      } else if(swords.size()==1) {
 
        if(m_cur_type==value::NONE) {
          m_out << "tools::columns::finder::analyse_dcl :"
                << " (1) current type is NONE."
                << std::endl;
          return 0;
        }
 
        value* v = new value();
        v->set_type(m_cur_type);
        v->set_label(swords[0]);
        return v;
 
      } else {
        m_out << "tools::columns::finder::analyse_dcl :"
              << " syntax error in " << sout(a_s)
              << ". Case 2."
              << std::endl;
        return 0;
      }
 
    } else {
      m_out << "tools::columns::finder::analyse_dcl :"
            << " syntax error in " << sout(a_s)
            << ". Case 3."
            << std::endl;
      return 0;
    }
  }

clear()

void tools::columns::finder::clear ( )

inline

Definition at line 210 of file columns.

               {
    m_top.clear();
    delete_columns(m_stack);
    m_cur_type = value::NONE;
  }

find_variables()

bool tools::columns::finder::find_variables ( )

inline

Definition at line 195 of file columns.

                        {
    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;
  }

new_value()

static value* tools::columns::finder::new_value ( value::e_type  a_type, const std::string &  a_v  )

inlinestaticprotected

Definition at line 449 of file columns.

                                                                   {
           if(a_type==value::FLOAT) {
      float v = 0;
      if(a_v.size()) {if(!to<float>(a_v,v)) return 0;}
      return new value(v);
    } else if(a_type==value::DOUBLE) {
      double v = 0;
      if(a_v.size()) {if(!to<double>(a_v,v)) return 0;}
      return new value(v);
    //} else if(a_type==value::CHAR) {
    //  char v = 0;
    //  if(a_v.size()) {if(!to<char>(a_v,v)) return 0;}
    //  return new value(v);
    } else if(a_type==value::SHORT) {
      short v = 0;
      if(a_v.size()) {if(!to<short>(a_v,v)) return 0;}
      return new value(v);
    } else if(a_type==value::INT) {
      int v = 0;
      if(a_v.size()) {if(!to<int>(a_v,v)) return 0;}
      return new value(v);
 
    } else if(a_type==value::INT64) {
      int64 v = 0;
      if(a_v.size()) {if(!to<int64>(a_v,v)) return 0;}
      return new value(v);
    } else if(a_type==value::BOOL) {
      bool v = false;
      if(a_v.size()) {if(!to(a_v,v)) return 0;}
      return new value(v);
 
    } else if(a_type==value::STRING) {
      if( (a_v.size()>=2) && (a_v[0]=='"') && (a_v[a_v.size()-1]=='"') ){
        return new value(a_v.substr(1,a_v.size()-2));
      } else {
        return new value(a_v);
      }
 
    //} else if(a_type==value::UNSIGNED_CHAR) {
    //  unsigned short v = 0;
    //  if(a_v.size()) {if(!to<unsigned short>(a_v,v)) return 0;}
    //  return new value((unsigned char)v);
 
    } else if(a_type==value::UNSIGNED_SHORT) {
      unsigned short v = 0;
      if(a_v.size()) {if(!to<unsigned short>(a_v,v)) return 0;}
      return new value(v);
    } else if(a_type==value::UNSIGNED_INT) {
      unsigned int v = 0;
      if(a_v.size()) {if(!to<unsigned int>(a_v,v)) return 0;}
      return new value(v);
 
    } else if(a_type==value::UNSIGNED_INT64) {
      uint64 v = 0;
      if(a_v.size()) {if(!to<uint64>(a_v,v)) return 0;}
      return new value(v);
 
    } else if(a_type==value::ARRAY_FLOAT) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_FLOAT);
      return v;
    } else if(a_type==value::ARRAY_DOUBLE) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_DOUBLE);
      return v;
    //} else if(a_type==value::ARRAY_UNSIGNED_CHAR) {
    //  if(a_v.size()) return 0;
    //  value* v = new value();
    //  v->set_type(value::ARRAY_UNSIGNED_CHAR);
    //  return v;
    //} else if(a_type==value::ARRAY_CHAR) {
    //  if(a_v.size()) return 0;
    //  value* v = new value();
    //  v->set_type(value::ARRAY_CHAR);
    //  return v;
    } else if(a_type==value::ARRAY_SHORT) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_SHORT);
      return v;
    } else if(a_type==value::ARRAY_INT) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_INT);
      return v;
    } else if(a_type==value::ARRAY_INT64) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_INT64);
      return v;
    } else if(a_type==value::ARRAY_BOOL) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_BOOL);
      return v;
    } else if(a_type==value::ARRAY_STRING) {
      if(a_v.size()) return 0;
      value* v = new value();
      v->set_type(value::ARRAY_STRING);
      return v;
    } else {
      return 0;
    }
  }

operator=()

finder& tools::columns::finder::operator= ( const finder &  )

inlineprotected

Definition at line 192 of file columns.

{return *this;}

result()

void tools::columns::finder::result ( std::vector< value > &  a_vars ) const

inline

Definition at line 205 of file columns.

                                              {
    a_vars.clear();
    copy_columns(m_stack,a_vars);
  }

s2type()

static bool tools::columns::finder::s2type ( const std::string &  a_s, value::e_type &  a_type  )

inlinestaticprotected

Definition at line 396 of file columns.

                                                              {
           if(a_s=="float") {
      a_type = value::FLOAT;
    } else if(a_s=="double") {
      a_type = value::DOUBLE;
    //} else if(a_s=="char") {
    //  a_type = value::CHAR;
    } else if(a_s=="short") {
      a_type = value::SHORT;
    } else if(a_s=="int") {
      a_type = value::INT;
    } else if(a_s=="long") {
      a_type = value::INT64;
    } else if((a_s=="bool")||(a_s=="boolean")) {
      a_type = value::BOOL;
    } else if((a_s=="string")||(a_s=="java.lang.String")){
      a_type = value::STRING;
    //} else if(a_s=="byte") {
    //  a_type = value::UNSIGNED_CHAR;
 
    } else if(a_s=="float[]") {
      a_type = value::ARRAY_FLOAT;
    } else if(a_s=="double[]") {
      a_type = value::ARRAY_DOUBLE;
    //} else if(a_s=="char[]") {
    //  a_type = value::ARRAY_CHAR;
    //} else if(a_s=="byte[]") {
    //  a_type = value::ARRAY_UNSIGNED_CHAR;
    } else if(a_s=="short[]") {
      a_type = value::ARRAY_SHORT;
    } else if(a_s=="int[]") {
      a_type = value::ARRAY_INT;
    } else if(a_s=="long[]") {
      a_type = value::ARRAY_INT64;
    } else if((a_s=="bool[]")||(a_s=="boolean[]")) {
      a_type = value::ARRAY_BOOL;
    } else if((a_s=="string[]")||(a_s=="java.lang.String[]")){
      a_type = value::ARRAY_STRING;
 
    // not AIDA :
    //} else if(a_s=="uchar") {
    //  a_type = value::UNSIGNED_CHAR;
    } else if(a_s=="ushort") {
      a_type = value::UNSIGNED_SHORT;
    } else if(a_s=="uint") {
      a_type = value::UNSIGNED_INT;
    } else if(a_s=="ulong") {
      a_type = value::UNSIGNED_INT64;
    } else {
      return false;
    }
    return true;
  }

Member Data Documentation

m_cur_type

value::e_type tools::columns::finder::m_cur_type

Definition at line 559 of file columns.

m_out

std::ostream& tools::columns::finder::m_out

Definition at line 556 of file columns.

m_script

std::string tools::columns::finder::m_script

Definition at line 557 of file columns.

m_stack

std::vector<value> tools::columns::finder::m_stack

Definition at line 558 of file columns.

---

The documentation for this class was generated from the following file:

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/columns