C++ POETCode::get_enum方法代码示例

 virtual void visitLocalVar(LocalVar* var) 
   {
      LvarSymbolTable::Entry e = var->get_entry();
      POETCode *restr = e.get_restr();
      if (restr == 0) {
         CollectInfoVisitor::visitLocalVar(var);
         return;
      }
      if (restr->get_enum() == SRC_CVAR) {
         CodeVar* cvar = static_cast<CodeVar*>(restr);
         POETCode* code = e.get_code();
         if (code!=0 && !match_AST(code, cvar,MATCH_AST_EQ)) {
            CodeVar* tmp = ASTFactory::inst()->new_codeRef(cvar->get_entry(), code); 
            tmp->visit(this); 
            return; 
         }
      }
      else if (restr->get_enum() == SRC_OP) {
          POETOperator* op = static_cast<POETOperator*>(restr);
          if (op->get_op() == POET_OP_LIST || op->get_op()==POET_OP_LIST1)  {
              POETCode* _listsep = listsep;
              CodeVar* _listelem = listelem;
              int save = align;
              align = start_pos;
              listsep = op->get_arg(1);
              listelem=dynamic_cast<CodeVar*>(op->get_arg(0));
              CollectInfoVisitor::visitLocalVar(var);
              align = save; listsep = _listsep; listelem = _listelem;
              return;
           }
      }
      CollectInfoVisitor::visitLocalVar(var);
   }

POETCode* EraseTrace(POETCode* vars, POETCode* res)
{
  std::vector<LocalVar*> vec;
  switch (vars->get_enum()) {
  case SRC_LVAR: {
     vars = eval_AST(vars);
     if (vars->get_enum() != SRC_LVAR) break;
     LocalVar* lvar = static_cast<LocalVar*>(vars);
     if (lvar->get_entry().get_entry_type() == LVAR_TRACE)
        vec.push_back(lvar);
     break;
  }
 case SRC_LIST: {
   POETList* l = static_cast<POETList*>(vars);
   while (l != 0) {
     POETCode* cur = l->get_first();
     if (cur->get_enum() == SRC_LVAR) {
        cur = eval_AST(cur);
        if (cur->get_enum() == SRC_LVAR) {
           LocalVar* cur_lvar = static_cast<LocalVar*>(cur);
           if (cur_lvar->get_entry().get_entry_type() == LVAR_TRACE) 
                vec.push_back(cur_lvar);
        }
     }
     l = dynamic_cast<POETList*>(l->get_rest());
   }
  }
  break;
 default: return res;
 }
 int size = vec.size();
 if (size == 0) return res;
 for (int i = size-1; i >= 0; --i) {
   LvarSymbolTable::Entry e = vec[i]->get_entry();
   assert (e.get_entry_type() == LVAR_TRACE); 
   e.set_entry_type(LVAR_TRACE_OUTDATE);
 }
 res = ReplInfoVisitor().apply(res);
 for (int i = size-1; i >= 0; --i) {
   LvarSymbolTable::Entry e = vec[i]->get_entry();
   e.set_entry_type(LVAR_TRACE);
 }
 return res;
}

 virtual void visitCodeVar(CodeVar* v) 
  {
    try {
      POETCode* _listsep = listsep;
      CodeVar* _listelem = listelem;
      POETCode* result = v->invoke_output(v->get_args());
      if (result != 0 && result != v) { 
          listsep = 0; listelem=0; 
          result->visit(this); 
          listsep = _listsep; listelem=_listelem;
          return; 
      }
      CvarSymbolTable::Entry e = v->get_entry();
      LvarSymbolTable *local = 0;
      POETCode* f = 0;
      POETCode *parse = e.get_parse();
      if (parse != 0 && parse->get_enum()==SRC_OP) { 
          POETOperator* op = static_cast<POETOperator*>(parse);
          if (op->get_op() == POET_OP_LIST || op->get_op()==POET_OP_LIST1)  {
              listsep = op->get_arg(1);
              listelem=dynamic_cast<CodeVar*>(op->get_arg(0));
              f = v->get_args();
           }
      }
      if (f == 0) { 
        listsep = 0; listelem=0;
        f = e.get_code();
        if (f == 0) { 
              if (parse==0) { CODE_SYNTAX_UNDEFINED(v->toString()); }
              else f = v->get_args(); 
        }
        else {
           local = e.get_symTable();
           if (local != 0) 
              local->push_table(false);
           POETCode* pars = e.get_param();
           if (pars != 0 && !match_parameters(pars, v->get_args(),MATCH_PAR_MOD_CODE))   
              CVAR_MISMATCH(v,pars, v->get_args());
           v->set_attr();
        }
      }
      if (f == 0) { CODE_SYNTAX_UNDEFINED(v->toString()); }
      int save = align;
      align = start_pos;
      f->visit(this); 
      align = save;
      if (local != 0)
          local->pop_table();
      listsep = _listsep; listelem=_listelem;
    }
    catch (Error err) { 
            std::cerr << " From unparsing code template " << SHORT(v->toString(),500) << "\n"; 
            throw err;
         }
    }

 POETEnum get_matchEnum(POETCode* v2first)
  {
    POETEnum v2first_enum = v2first->get_enum();
    if (v2first_enum == SRC_ASSIGN) {
       POETCode* c  = static_cast<POETAssign*>(v2first)->get_rhs();
       if (c != 0) {
           v2first_enum = c->get_enum();
       }
    }
    return v2first_enum;
  }

 virtual void visitList(POETList* l)
  {
     POETCode* first = l->get_first();
     int prevline = line;
     if (first->get_enum() == SRC_LIST) 
         {out << "("; first->visit(this); out << ")"; }
     else first->visit(this);
     if (line > prevline) print_linebreak(); 
     POETCode* rest = l->get_rest();
     if (rest != 0) {
        rest->visit(this);
     }
     else out << " NULL";
  }

 virtual void visitTuple(POETTuple* l)
  {
    out << "("; print_linebreak();
    int size=l->size();
    for (int i = 0; i < size; ++i) {
       POETCode* cur = l->get_entry(i);
       if (cur == 0) out << "NULL,";
       else if (cur->get_enum() == SRC_LIST) 
           { col+=2; out << "(";  cur->visit(this); 
             out << ")"; col-=2; }
       else cur->visit(this); 
       if (i < size-1) { out << ","; print_linebreak(); }
     }
     out << ")"; 
  }

std::string POETTuple :: toString(ASTOutputEnum config)
{ 
    std:: stringstream r;
    r << "(";
    for (unsigned i = 0; i < impl.size(); ++i) {
       POETCode* cur = impl[i];
       if (cur == 0) r << "NULL,";
       else if (cur->get_enum() == SRC_LIST) 
           r << "(" << cur->toString(config) << "),";
       else
           r << cur->toString(config) << ",";
    }
    std::string str = r.str();
    str[str.size()-1] = ')' ; 
    return str;
  }

 virtual void visitTupleAccess(TupleAccess* fc) 
    { 
     try {
      POETCode* tuple = apply(fc->get_tuple());
      POETCode* tuple1 = EvalTrace(tuple);
      if (tuple1 == 0) SYM_UNDEFINED(tuple->toString())
      else tuple = tuple1;
      POETCode* access= EvalTrace(fc->get_access()); 
      switch (tuple->get_enum()) {
        case SRC_TUPLE: {
           access= apply(access);
           if (access->get_enum() == SRC_LVAR) {
             LvarSymbolTable::Entry e = static_cast<LocalVar*>(access)->get_entry();
             if (e.get_entry_type() == LVAR_OUTPUT) access = e.get_code(); 
             else TUPLE_ACC_MISMATCH(fc, tuple,access);
           }
           res = eval_tuple_access(tuple,access);
           if (res == 0) { TUPLE_ACC_MISMATCH(fc, tuple,access); }
           return;
         }
        case SRC_MAP: {
           POETMap* m = static_cast<POETMap*>(tuple);
           access= apply(access);
           res = m->find(access);
           if (res == 0) 
               res = EMPTY;
           return;
        }
        case SRC_CVAR: {
           CodeVar* cv = static_cast<CodeVar*>(tuple);
           CvarSymbolTable::Entry cv_e = cv->get_entry();
           LvarSymbolTable* symTable = cv_e.get_symTable();
           res = eval_cvar_access(cv, access);
           return;
        }
        default: { 
           res = eval_tuple_access(tuple,access);
           if (res == 0)
            TUPLE_ACC_MISMATCH( fc, tuple, access); 
          }
       }
     }
     catch (Error err) { std::cerr << "From invoking " << SHORT(fc->toString(),500) << "\n"; throw err; }
    } 

POETCode* TraceEval(POETCode* vars, POETCode* res)
{
  std::vector<LocalVar*> vec;
  switch (vars->get_enum()) {
  case SRC_LVAR: {
     LocalVar* lvar = static_cast<LocalVar*>(vars);
     vec.push_back(lvar);
     break;
  }
 case SRC_LIST: {
   POETList* l = static_cast<POETList*>(vars);
   while (l != 0) {
     POETCode* cur = l->get_first();
     if (cur->get_enum() != SRC_LVAR) INCORRECT_TRACE_HANDLE(cur->toString());
     vec.push_back(static_cast<LocalVar*>(cur));
     l = dynamic_cast<POETList*>(l->get_rest());
   }
  } 
   break;
 default: INCORRECT_TRACE_HANDLE(vars->toString()); 
 }
 for (int i = vec.size()-1; i >= 0; --i) {
    LocalVar* lvar = vec[i];
    LvarSymbolTable::Entry entry = lvar->get_entry();
    entry.push(true);
    entry.set_entry_type(LVAR_TRACE);
 }
 res = eval_AST(res);
 for (int i = vec.size()-1; i >= 0; --i) {
    LocalVar* lvar = dynamic_cast<LocalVar*>(vec[i]);
    assert(lvar != 0);
    LvarSymbolTable::Entry entry = lvar->get_entry();
    POETCode* val = entry.get_code();
    entry.pop();
    entry.set_code(val);
 }
 return res;
}

void POETProgram:: write_to_file(std::ostream& out)
{  
  int lineNo=0;
  for (std::list<POETProgram*>::const_iterator 
           pincludeFiles = includeFiles.begin();
           pincludeFiles!=includeFiles.end(); ++pincludeFiles) {
        POETProgram* cur = (*pincludeFiles);
        out << "include " << cur->get_filename() << "\n";
        ++lineNo;
  }
  for (const_iterator pdef = define.begin(); pdef != define.end(); ++pdef) {
       POETCode* cur = *pdef;
       const FileInfo* curFile = cur->get_fileinfo();
       if (curFile != 0) {
           while (lineNo < curFile->get_lineno()) {
               out << "\n"; ++lineNo;
           }
       }
       switch (cur->get_enum())
       {
       case SRC_WRITE_OUTPUT: case SRC_READ_INPUT: case SRC_PARAM_DECL:
       case SRC_TRACE_DECL:
          out << cur->toString(DEBUG_NO_VAR) << "\n"; ++lineNo; break;
       case SRC_CVAR: 
         {
          CodeVar* cvar = static_cast<CodeVar*>(cur);
          out << "<code " << cvar->toString();
          const CodeDefSave& def = codeDef[cvar];
          unsigned par_size = def.par_type.size();
          if (par_size > 0) {
             out << " pars=(";
             for (unsigned i = 0; i < par_size; ++i) 
             {
               const LocalVarSave& par_save = def.par_type[i];
               assert(par_save.lvar != 0); 
               out << par_save.lvar->get_entry().get_name();
               if (par_save.restr != 0)
                   out << ":" << par_save.restr->toString(DEBUG_NO_VAR);
               if (i < par_size) out << ",";
             } 
             out << ")";
          }
          CvarSymbolTable::Entry cvar_entry = cvar->get_entry();
          for (unsigned i = 0; i < cvar_entry.attr_size(); ++i) {
             LocalVar* v = cvar_entry.get_attr(i); 
             out << " " << v->get_entry().get_name()->toString(OUTPUT_NO_DEBUG) << "=" << v->get_entry().get_code()->toString(DEBUG_NO_VAR);
          } 
          out << "/>\n";++lineNo;  
          break;
         } 
       case SRC_LVAR:
         {
          LocalVar* cur_var = static_cast<LocalVar*>(cur);
          switch (cur_var->get_entry().get_entry_type())
          {
           case LVAR_TUNE:
              out << "<define " << cur->toString(OUTPUT_NO_DEBUG) << "/>\n";
              ++lineNo;  
              break;
           default:
                std::cerr << "Something is wrong. Unexpected var decl at global scope: " << cur->toString(DEBUG_OUTPUT) << "\n"; 
               assert(0);
          }
          break;
         }
       case SRC_EVAL: // eval command
          if (dynamic_cast<POETCondExp*>(cur) != 0)
               out << "<cond ";
          else out << "<eval ";
          Write_POET_Exp write(out,6);
          lineNo += write(cur);
          out << "/>\n"; ++lineNo;
      }
   }
}

  virtual void visitOperator(POETOperator *op)
  {
     switch (op->get_op()) {
     case POET_OP_TUPLE: {
       parseTuple(op->get_arg(0));
       break;
      }
     case TYPE_LIST1:
     case TYPE_LIST: {
         POETCode* arg = op->get_arg(0);
         POETCode* matchSave = fullmatch; fullmatch = EMPTY;
         std::vector<POETCode*> match_res;
         do {
            POETCode* r1_first=match_eval(arg);
            if (r1_first == 0)  { 
                fullmatch = matchSave;
                if (fullmatch != 0) {
                    res = Vector2List(match_res); 
                    if (res == EMPTY && op->get_op() == TYPE_LIST1)
                         PARSE_MISMATCH(r1,op,lineno);
                    return; 
                   }
                else PARSE_MISMATCH(r1,op,lineno);
            }
            match_res.push_back(r1_first);
         } while (r1 != 0);
         fullmatch = matchSave;
         if (match_res.size() == 0) PARSE_MISMATCH(r1,op,lineno);
         res = Vector2List(match_res);
         assert(res != EMPTY);
         return;
       }
     case TYPE_TOR: {
        POETCode* r1_first = get_head(r1);
        if (r1_first->get_enum() == SRC_CVAR &&
             static_cast<CodeVar*>(r1_first)->get_parseInfo() != EMPTY) 
            { /*QY: r1_first is already parsed and is not a token*/  
              if (!match_eval(op)) PARSE_MISMATCH(r1,op,lineno);
              return;
            }
 
         if (!backtrack) {
            POETTypeTor* tor = static_cast<POETTypeTor*>(op);
            POETCode* arg = tor->get_parseInfo(this, r1);
            apply(arg, fullmatch); 
            if (fullmatch != 0) fullmatch=EMPTY; 
            return;
         }
         else  {
            POETCode* r1save = r1;
            size_t size = op->numOfArgs();
            for (unsigned i = 0; i < size; ++i) {
               POETCode* arg = op->get_arg(i);
               POETCode* filter = 0;
               switch (arg->get_enum()) {
               case SRC_STRING: if (arg != EMPTY) filter = arg; break;
               case SRC_CVAR:
                 filter=static_cast<CodeVar*>(arg)->get_parseInfo();
                 if (filter != 0 && filter->get_enum() == SRC_LIST)
                    filter = static_cast<POETList*>(filter)->get_first();
                 else filter = 0;
                 break;
               default: ; /* no filtering */
               }
               if (filter != 0 && filter->get_enum()==SRC_STRING && filter != r1_first) {
                 continue;
               }
               try { apply(arg, EMPTY);
                    if (res != 0) return; }
               catch (ParseError err) { r1 = r1save; }
            }
         }
         PARSE_MISMATCH(r1,op,lineno);
         return;
      }
     case POET_OP_EXP: {
       ParseExp::Result exp_res = ParseExp::inst()->parse(r1, &lineno);
       res = exp_res.first;
       if (res == 0) PARSE_MISMATCH(r1,op,lineno); 
       if (fullmatch != 0) r1 = exp_res.second;
       else if (exp_res.second != 0 && exp_res.second != EMPTY) 
             { PARSE_MISMATCH_LEFT(exp_res.second,lineno); }
       else r1 = 0;
       break;
       }
     case POET_OP_LIST1:
     case POET_OP_LIST: {
       POETParseList* oplist = dynamic_cast<POETParseList*>(op);
       assert(oplist != 0);
       std::string sepString;
       POETCode* sep = op->get_arg(1);
       if (sep != 0) { 
           sep  = eval_AST(sep);  
           POETString* sep1 = AST2String(sep);
           if (sep1 == 0) INCORRECT_STRING(sep);
           sepString = sep1->get_content();
       }
       else sep = EMPTY;
       if (IS_SPACE(sepString)) sep = EMPTY;
       try { parseList(oplist, op->get_arg(0), sep); }
//.........这里部分代码省略.........