예제 #1
0
void TreeViewer::setNode( SyntaxNode *node )
{
    clearTreeStack();

    TreeIterator iterator(node);
    while( ! iterator.isDone() ){
        SyntaxNode *syntaxNode = dynamic_cast<SyntaxNode *>(iterator.current());
        if( syntaxNode )
            syntaxNode->accept( this );
        iterator.next();
    }
    update();
}
예제 #2
0
SyntaxNode* ActionMake::Invoke(const std::vector<void*>& container) {
	SyntaxNode* ans = new SyntaxNode(SyntaxNodeOperation, argument_.text);
	SyntaxNode** nodes = new SyntaxNode*[argument_.parameters.size()];
	for (int i = 0; i < (int)argument_.parameters.size(); ++i) {
		if (argument_.parameters[i] == 0) {
			nodes[i] = nullptr;
		}
		else {
			nodes[i] = (SyntaxNode*)container[container.size() - argument_.parameters[i]];
		}
	}

	ans->AddChildren(nodes, argument_.parameters.size());
	delete[] nodes;

	return ans;
}
예제 #3
0
// Converts a SyntaxNode tree to a Moses::GHKM::ParseTree.
std::auto_ptr<ParseTree> XmlTreeParser::ConvertTree(
    const SyntaxNode &tree,
    const std::vector<std::string> &words)
{
  std::auto_ptr<ParseTree> root(new ParseTree(tree.GetLabel()));
  const std::vector<SyntaxNode*> &children = tree.GetChildren();
  if (children.empty()) {
    if (tree.GetStart() != tree.GetEnd()) {
      std::ostringstream msg;
      msg << "leaf node covers multiple words (" << tree.GetStart()
          << "-" << tree.GetEnd() << "): this is currently unsupported";
      throw Exception(msg.str());
    }
    std::auto_ptr<ParseTree> leaf(new ParseTree(words[tree.GetStart()]));
    leaf->SetParent(root.get());
    root->AddChild(leaf.release());
  } else {
    for (std::vector<SyntaxNode*>::const_iterator p = children.begin();
         p != children.end(); ++p) {
      assert(*p);
      std::auto_ptr<ParseTree> child = ConvertTree(**p, words);
      child->SetParent(root.get());
      root->AddChild(child.release());
    }
  }
  return root;
}
예제 #4
0
void BlockSyntaxNode::printAST(SyntaxNode *root, std::ostream &os)
{
	os << std::setw(4) << std::dec << nodenum << " ";
	os << "[label=\"";
	if (pbb) {
		switch (pbb->getType()) {
		case ONEWAY:   os << "Oneway";
			if (notGoto) os << " (ignored)";
			break;
		case TWOWAY:   os << "Twoway";        break;
		case NWAY:     os << "Nway";          break;
		case CALL:     os << "Call";          break;
		case RET:      os << "Ret";           break;
		case FALL:     os << "Fall";          break;
		case COMPJUMP: os << "Computed jump"; break;
		case COMPCALL: os << "Computed call"; break;
		case INVALID:  os << "Invalid";       break;
		}
		os << " " << std::hex << pbb->getLowAddr();
	} else
		os << "block";
	os << "\"];" << std::endl;
	if (pbb) {
		for (int i = 0; i < pbb->getNumOutEdges(); i++) {
			PBB out = pbb->getOutEdge(i);
			os << std::setw(4) << std::dec << nodenum << " ";
			SyntaxNode *to = root->findNodeFor(out);
			assert(to);
			os << " -> " << to->getNumber() << " [style=dotted";
			if (pbb->getNumOutEdges() > 1)
				os << ",label=" << i;
			os << "];" << std::endl;
		}
	} else {
		for (unsigned i = 0; i < statements.size(); i++)
			statements[i]->printAST(root, os);
		for (unsigned i = 0; i < statements.size(); i++) {
			os << std::setw(4) << std::dec << nodenum << " ";
			os << " -> " << statements[i]->getNumber()
			   << " [label=\"" << i << "\"];" << std::endl;
		}
	}
}
예제 #5
0
SyntaxNode *SyntaxNode::findChild(int searchtoken) const {
  switch(m_token) {
  case NAME      :
  case PARAM     :
  case HOSTVAR   :
  case STRING    :
  case NUMBER    :
  case DATECONST :
  case TIMECONST :
  case TIMESTAMPCONST:
    throwSqlError(SQL_FATAL_ERROR,_T("No children in findChild(%d) in SyntaxNode (line %d, token %d)")
                                 ,searchtoken,m_pos.getLineNumber(),m_token);
    break;
  }
  for(int i = 0; i < m_attributes.m_children.m_count; i++) {
    SyntaxNode *p = m_attributes.m_children.m_child[i];
    if(p->token() == searchtoken)
      return p;
  }
  return NULL;
}
예제 #6
0
void SqlCompiler::genInsert(SyntaxNode *n) { // n == <insert_stmt>
  const TCHAR *tableName = n->child(0)->name();

  StatementTable table(*this,n->child(0));

  if(!ok()) return;
  if(table.getTableType() != TABLETYPE_USER) {
    syntaxError(n->child(0),SQL_INVALID_TABLETYPE,_T("Cannot insert into systemtable <%s>"),tableName);
    return;
  }
  SyntaxNode *insertwhat = n->child(2);
  switch(insertwhat->token()) {
  case VALUES:
    genInsertValues(n,table);
    break;
  case SELECT:
    genInsertSelect(n);
    break;
  default:
    stopcomp(insertwhat);
  }
  m_code.appendIns0(CODERETURN);
}
void SyntaxTree::ConnectNodes()
{
  typedef SyntaxTreeIndex2::const_reverse_iterator InnerIterator;

  SyntaxNode *prev = 0;
  // Iterate over all start indices from lowest to highest.
  for (SyntaxTreeIndexIterator p = m_index.begin(); p != m_index.end(); ++p) {
    const SyntaxTreeIndex2 &inner = p->second;
    // Iterate over all end indices from highest to lowest.
    for (InnerIterator q = inner.rbegin(); q != inner.rend(); ++q) {
      const std::vector<SyntaxNode*> &nodes = q->second;
      // Iterate over all nodes that cover the same span in order of tree
      // depth, top-most first.
      for (std::vector<SyntaxNode*>::const_reverse_iterator r = nodes.rbegin();
           r != nodes.rend(); ++r) {
        SyntaxNode *node = *r;
        if (!prev) {
          // node is the root.
          m_top = node;
          node->SetParent(0);
        } else if (prev->GetStart() == node->GetStart()) {
          // prev is the parent of node.
          assert(prev->GetEnd() >= node->GetEnd());
          node->SetParent(prev);
          prev->AddChild(node);
        } else {
          // prev is a descendant of node's parent.  The lowest common
          // ancestor of prev and node will be node's parent.
          SyntaxNode *ancestor = prev->GetParent();
          while (ancestor->GetEnd() < node->GetEnd()) {
            ancestor = ancestor->GetParent();
          }
          assert(ancestor);
          node->SetParent(ancestor);
          ancestor->AddChild(node);
        }
        prev = node;
      }
    }
  }
}
예제 #8
0
/*TODO: we'd only have to return a vector of XML options if we dropped linking. 2-d vector
	is so we can link things up afterwards. We can't create TranslationOptions as we
	parse because we don't have the completed source parsed until after this function
	removes all the markup from it (CreateFromString in Sentence::Read).
*/
bool ProcessAndStripXMLTags(string &line, SyntaxTree &tree, set< string > &labelCollection, map< string, int > &topLabelCollection )
{
  //parse XML markup in translation line

  // no xml tag? we're done.
  if (line.find_first_of('<') == string::npos) {
    return true;
  }

  // break up input into a vector of xml tags and text
  // example: (this), (<b>), (is a), (</b>), (test .)
  vector<string> xmlTokens = TokenizeXml(line);

  // we need to store opened tags, until they are closed
  // tags are stored as tripled (tagname, startpos, contents)
  typedef pair< string, pair< size_t, string > > OpenedTag;
  vector< OpenedTag > tagStack; // stack that contains active opened tags

  string cleanLine; // return string (text without xml)
  size_t wordPos = 0; // position in sentence (in terms of number of words)
  bool isLinked = false;

  // loop through the tokens
  for (size_t xmlTokenPos = 0 ; xmlTokenPos < xmlTokens.size() ; xmlTokenPos++) {
    // not a xml tag, but regular text (may contain many words)
    if(!isXmlTag(xmlTokens[xmlTokenPos])) {
      // add a space at boundary, if necessary
      if (cleanLine.size()>0 &&
          cleanLine[cleanLine.size() - 1] != ' ' &&
          xmlTokens[xmlTokenPos][0] != ' ') {
        cleanLine += " ";
      }
      cleanLine += unescape(xmlTokens[xmlTokenPos]); // add to output
      wordPos = Tokenize(cleanLine).size(); // count all the words
    }

    // process xml tag
    else {
      // *** get essential information about tag ***

      // strip extra boundary spaces and "<" and ">"
      string tag =  Trim(TrimXml(xmlTokens[xmlTokenPos]));
      // cerr << "XML TAG IS: " << tag << std::endl;

      if (tag.size() == 0) {
        cerr << "ERROR: empty tag name: " << line << endl;
        return false;
      }

      // check if unary (e.g., "<wall/>")
      bool isUnary = ( tag[tag.size() - 1] == '/' );

      // check if opening tag (e.g. "<a>", not "</a>")g
      bool isClosed = ( tag[0] == '/' );
      bool isOpen = !isClosed;

      if (isClosed && isUnary) {
        cerr << "ERROR: can't have both closed and unary tag <" << tag << ">: " << line << endl;
        return false;
      }

      if (isClosed)
        tag = tag.substr(1); // remove "/" at the beginning
      if (isUnary)
        tag = tag.substr(0,tag.size()-1); // remove "/" at the end

      // find the tag name and contents
      string::size_type endOfName = tag.find_first_of(' ');
      string tagName = tag;
      string tagContent = "";
      if (endOfName != string::npos) {
        tagName = tag.substr(0,endOfName);
        tagContent = tag.substr(endOfName+1);
      }

      // *** process new tag ***

      if (isOpen || isUnary) {
        // put the tag on the tag stack
        OpenedTag openedTag = make_pair( tagName, make_pair( wordPos, tagContent ) );
        tagStack.push_back( openedTag );
        // cerr << "XML TAG " << tagName << " (" << tagContent << ") added to stack, now size " << tagStack.size() << endl;
      }

      // *** process completed tag ***

      if (isClosed || isUnary) {
        // pop last opened tag from stack;
        if (tagStack.size() == 0) {
          cerr << "ERROR: tag " << tagName << " closed, but not opened" << ":" << line << endl;
          return false;
        }
        OpenedTag openedTag = tagStack.back();
        tagStack.pop_back();

        // tag names have to match
        if (openedTag.first != tagName) {
          cerr << "ERROR: tag " << openedTag.first << " closed by tag " << tagName << ": " << line << endl;
          return false;
        }

        // assemble remaining information about tag
        size_t startPos = openedTag.second.first;
        string tagContent = openedTag.second.second;
        size_t endPos = wordPos;

        // span attribute overwrites position
        string span = ParseXmlTagAttribute(tagContent,"span");
        if (! span.empty()) {
          vector<string> ij = Tokenize(span, "-");
          if (ij.size() != 1 && ij.size() != 2) {
            cerr << "ERROR: span attribute must be of the form \"i-j\" or \"i\": " << line << endl;
            return false;
          }
          startPos = atoi(ij[0].c_str());
          if (ij.size() == 1) endPos = startPos + 1;
          else endPos = atoi(ij[1].c_str()) + 1;
        }

        // cerr << "XML TAG " << tagName << " (" << tagContent << ") spanning " << startPos << " to " << (endPos-1) << " complete, commence processing" << endl;

        if (startPos >= endPos) {
          cerr << "ERROR: tag " << tagName << " must span at least one word (" << startPos << "-" << endPos << "): " << line << endl;
          return false;
        }

        string label = ParseXmlTagAttribute(tagContent,"label");
        labelCollection.insert( label );

        string scoreString = ParseXmlTagAttribute(tagContent,"score");
        float score = scoreString == "" ? 0.0f : std::atof(scoreString.c_str());

        // report what we have processed so far
        if (0) {
          cerr << "XML TAG NAME IS: '" << tagName << "'" << endl;
          cerr << "XML TAG LABEL IS: '" << label << "'" << endl;
          cerr << "XML SPAN IS: " << startPos << "-" << (endPos-1) << endl;
        }
        SyntaxNode *node = tree.AddNode( startPos, endPos-1, label );
        node->SetScore(score);
      }
    }
  }
  // we are done. check if there are tags that are still open
  if (tagStack.size() > 0) {
    cerr << "ERROR: some opened tags were never closed: " << line << endl;
    return false;
  }

  // collect top labels
  const vector< SyntaxNode* >& topNodes = tree.GetNodes( 0, wordPos-1 );
  for( vector< SyntaxNode* >::const_iterator node = topNodes.begin(); node != topNodes.end(); node++ ) {
    SyntaxNode *n = *node;
    const string &label = n->GetLabel();
    if (topLabelCollection.find( label ) == topLabelCollection.end())
      topLabelCollection[ label ] = 0;
    topLabelCollection[ label ]++;
  }

  // return de-xml'ed sentence in line
  line = cleanLine;
  return true;
}
예제 #9
0
void SqlCompiler::genInsertValues(const SyntaxNode *n,              // n == insert_stmt
                                  StatementTable &table) {
  NodeList    columnlist((n->child(1)->childCount() == 0) ? NULL : n->child(1)->child(0));
  SyntaxNode *insertwhat = n->child(2); // == VALUES
  NodeList    exprlist(insertwhat->child(0));
  Array<InsertColumnExpression> icemap;

  if(columnlist.size() == 0) { // no columnnames specified. use all columns of tabledefinition
    if(exprlist.size() != table.getColumnCount()) {
      syntaxError(insertwhat,SQL_INVALID_EXPRLIST,_T("Invalid number of expressions specified"));
      return;
    }
    for(UINT i = 0; i < table.getColumnCount(); i++)
      icemap.add(InsertColumnExpression(table,i,exprlist[i]));
  }
  else { // columnnames specified
    if(columnlist.size() != exprlist.size()) {
      syntaxError(insertwhat,SQL_INVALID_EXPRLIST,_T("Invalid number of expressions specified"));
      return;
    }
    for(UINT i = 0; i < columnlist.size(); i++) {
      const TCHAR *name = columnlist[i]->name();
      int colindex = table.findColumnIndex(name);
      if(colindex < 0)
        syntaxError(columnlist[i],SQL_INVALID_COLUMNNAME,_T("Invalid columnname:<%s>"),name);
      else {
        bool found = false;
        for(UINT j = 0; j < icemap.size(); j++) { // check not already spec
          if(icemap[j].m_colIndex == colindex) {
            syntaxError(columnlist[i],SQL_COLUMN_ALREADY_DEFINED,_T("Column <%s> already specified"),name);
            found = true;
            break;
          }
        }
        if(!found)
          icemap.add(InsertColumnExpression(table,colindex,exprlist[i]));
      }
    }
    if(columnlist.size() > table.getColumnCount())
      syntaxError(insertwhat,SQL_TOO_MANY_COLUMNS,_T("Too many columns specified"));
    else {
      if(columnlist.size() < table.getColumnCount()) // check, that unspecified columns have nulls-allowed or defaultvalue
        for(UINT i = 0; i < table.getColumnCount(); i++) {
          bool found = false;
          for(UINT j = 0; j < icemap.size(); j++) {
            if(icemap[j].m_colIndex == i) {
              found = true;
              break;
            }
          }
          if(!found) { // unspecified column
            SyntaxNode *defaultvalue = fetchDefaultValueNode(table.getColumn(i));
            if(defaultvalue == NULL)
              syntaxError(n->child(0),SQL_NODEFAULT_OR_NULLALLOWED,_T("Column <%s> has no default-value or null-allowed"),table.getColumn(i).m_name.cstr());
            else
              icemap.add(InsertColumnExpression(table,i,defaultvalue));
          }
        }
    }
  }
  if(ok()) {
    // icemap.size == tableDef.colcount. i.e all columns has an expression
    int hostvarcounter = 0;
    for(UINT i = 0; i < icemap.size(); i++) {
      findHostVarIndex(icemap[i].m_expr,hostvarcounter);
    }
  }
  if(ok()) {
    for(UINT i = 0; i < icemap.size(); i++)
      checkExpressionType(icemap[i]);
  }

  if(ok()) {
    m_code.appendIns2(CODETUPINIT,0,table.getColumnCount());
    for(UINT i = 0; i < icemap.size(); i++) {
      bool dummy;
      genExpression(reduceExpression(icemap[i].m_expr,dummy));
      m_code.appendIns2(CODEPOPTUP,0,icemap[i].m_colIndex);
    }
    m_code.appendIns0(CODETRBEGIN);
    m_code.appendIns1(CODEPUSHCONST,m_code.appendConst(table.getSequenceNo()));
    m_code.appendIns1(CODETUPINSERT,0);
    m_code.appendIns0(CODETRCOMMIT);
  }
#ifdef TRACECOMP
  m_code.dump();
#endif

//  if(ok()) {
//    FILE *dmp = FOPEN(_T("fisk"),_T("w"));
//    for(int i = 0; i < icemap.size(); i++)
//      icemap[i].dump(dmp);
//    m_code.dump(dmp);
//    fclose(dmp);
//  }
}
예제 #10
0
void BlockSyntaxNode::addSuccessors(SyntaxNode *root, std::vector<SyntaxNode *> &successors)
{
	for (unsigned i = 0; i < statements.size(); i++) {
		if (statements[i]->isBlock()) {
			//BlockSyntaxNode *b = (BlockSyntaxNode*)statements[i];
			// can move previous statements into this block
			if (i > 0) {
				std::cerr << "successor: move previous statement into block" << std::endl;
				SyntaxNode *n = root->clone();
				n->setDepth(root->getDepth() + 1);
				BlockSyntaxNode *b1 = (BlockSyntaxNode *)this->clone();
				BlockSyntaxNode *nb = (BlockSyntaxNode *)b1->getStatement(i);
				b1 = (BlockSyntaxNode *)b1->replace(statements[i - 1], NULL);
				nb->prependStatement(statements[i - 1]->clone());
				n = n->replace(this, b1);
				successors.push_back(n);
				//PRINT_BEFORE_AFTER
			}
		} else {
			if (statements.size() != 1) {
				// can replace statement with a block containing that statement
				std::cerr << "successor: replace statement with a block containing the statement" << std::endl;
				BlockSyntaxNode *b = new BlockSyntaxNode();
				b->addStatement(statements[i]->clone());
				SyntaxNode *n = root->clone();
				n->setDepth(root->getDepth() + 1);
				n = n->replace(statements[i], b);
				successors.push_back(n);
				//PRINT_BEFORE_AFTER
			}
		}
		// "jump over" style of if-then
		if (i < statements.size() - 2 && statements[i]->isBranch()) {
			SyntaxNode *b = statements[i];
			if (b->getOutEdge(root, 0) == statements[i + 2]
			 && (statements[i + 1]->getOutEdge(root, 0) == statements[i + 2]
			  || statements[i + 1]->endsWithGoto())) {
				std::cerr << "successor: jump over style if then" << std::endl;
				BlockSyntaxNode *b1 = (BlockSyntaxNode *)this->clone();
				b1 = (BlockSyntaxNode *)b1->replace(statements[i + 1], NULL);
				IfThenSyntaxNode *nif = new IfThenSyntaxNode();
				Exp *cond = b->getBB()->getCond();
				cond = new Unary(opLNot, cond->clone());
				cond = cond->simplify();
				nif->setCond(cond);
				nif->setThen(statements[i + 1]->clone());
				nif->setBB(b->getBB());
				b1->setStatement(i, nif);
				SyntaxNode *n = root->clone();
				n->setDepth(root->getDepth() + 1);
				n = n->replace(this, b1);
				successors.push_back(n);
				//PRINT_BEFORE_AFTER
			}
		}
		// if then else
		if (i < statements.size() - 2 && statements[i]->isBranch()) {
			SyntaxNode *tThen = statements[i]->getOutEdge(root, 0);
			SyntaxNode *tElse = statements[i]->getOutEdge(root, 1);

			assert(tThen && tElse);
			if (((tThen == statements[i + 2] && tElse == statements[i + 1])
			  || (tThen == statements[i + 1] && tElse == statements[i + 2]))
			 && tThen->getNumOutEdges() == 1 && tElse->getNumOutEdges() == 1) {
				SyntaxNode *else_out = tElse->getOutEdge(root, 0);
				SyntaxNode *then_out = tThen->getOutEdge(root, 0);

				if (else_out == then_out) {
					std::cerr << "successor: if then else" << std::endl;
					SyntaxNode *n = root->clone();
					n->setDepth(root->getDepth() + 1);
					n = n->replace(tThen, NULL);
					n = n->replace(tElse, NULL);
					IfThenElseSyntaxNode *nif = new IfThenElseSyntaxNode();
					nif->setCond(statements[i]->getBB()->getCond()->clone());
					nif->setBB(statements[i]->getBB());
					nif->setThen(tThen->clone());
					nif->setElse(tElse->clone());
					n = n->replace(statements[i], nif);
					successors.push_back(n);
					//PRINT_BEFORE_AFTER
				}
			}
		}

		// pretested loop
		if (i < statements.size() - 2 && statements[i]->isBranch()) {
			SyntaxNode *tBody = statements[i]->getOutEdge(root, 0);
			SyntaxNode *tFollow =  statements[i]->getOutEdge(root, 1);

			assert(tBody && tFollow);
			if (tBody == statements[i + 1] && tFollow == statements[i + 2]
			 && tBody->getNumOutEdges() == 1
			 && tBody->getOutEdge(root, 0) == statements[i]) {
				std::cerr << "successor: pretested loop" << std::endl;
				SyntaxNode *n = root->clone();
				n->setDepth(root->getDepth() + 1);
				n = n->replace(tBody, NULL);
				PretestedLoopSyntaxNode *nloop = new PretestedLoopSyntaxNode();
				nloop->setCond(statements[i]->getBB()->getCond()->clone());
				nloop->setBB(statements[i]->getBB());
				nloop->setBody(tBody->clone());
				n = n->replace(statements[i], nloop);
				successors.push_back(n);
				//PRINT_BEFORE_AFTER
			}
		}

		// posttested loop
		if (i > 0 && i < statements.size() - 1 && statements[i]->isBranch()) {
			SyntaxNode *tBody = statements[i]->getOutEdge(root, 0);
			SyntaxNode *tFollow =  statements[i]->getOutEdge(root, 1);

			assert(tBody && tFollow);
			if (tBody == statements[i - 1] && tFollow == statements[i + 1]
			 && tBody->getNumOutEdges() == 1
			 && tBody->getOutEdge(root, 0) == statements[i]) {
				std::cerr << "successor: posttested loop" << std::endl;
				SyntaxNode *n = root->clone();
				n->setDepth(root->getDepth() + 1);
				n = n->replace(tBody, NULL);
				PostTestedLoopSyntaxNode *nloop = new PostTestedLoopSyntaxNode();
				nloop->setCond(statements[i]->getBB()->getCond()->clone());
				nloop->setBB(statements[i]->getBB());
				nloop->setBody(tBody->clone());
				n = n->replace(statements[i], nloop);
				successors.push_back(n);
				//PRINT_BEFORE_AFTER
			}
		}

		// infinite loop
		if (statements[i]->getNumOutEdges() == 1
		 && statements[i]->getOutEdge(root, 0) == statements[i]) {
			std::cerr << "successor: infinite loop" << std::endl;
			SyntaxNode *n = root->clone();
			n->setDepth(root->getDepth() + 1);
			InfiniteLoopSyntaxNode *nloop = new InfiniteLoopSyntaxNode();
			nloop->setBody(statements[i]->clone());
			n = n->replace(statements[i], nloop);
			successors.push_back(n);
			PRINT_BEFORE_AFTER
		}

		statements[i]->addSuccessors(root, successors);
	}
예제 #11
0
int BlockSyntaxNode::evaluate(SyntaxNode *root)
{
#if DEBUG_EVAL
	if (this == root)
		std::cerr << "begin eval =============" << std::endl;
#endif
	if (pbb)
		return 1;
	int n = 1;
	if (statements.size() == 1) {
		SyntaxNode *out = statements[0]->getOutEdge(root, 0);
		if (out->getBB() != NULL && out->getBB()->getNumInEdges() > 1) {
#if DEBUG_EVAL
			std::cerr << "add 15" << std::endl;
#endif
			n += 15;
		} else {
#if DEBUG_EVAL
			std::cerr << "add 30" << std::endl;
#endif
			n += 30;
		}
	}
	for (unsigned i = 0; i < statements.size(); i++) {
		n += statements[i]->evaluate(root);
		if (statements[i]->isGoto()) {
			if (i != statements.size() - 1) {
#if DEBUG_EVAL
				std::cerr << "add 100" << std::endl;
#endif
				n += 100;
			} else {
#if DEBUG_EVAL
				std::cerr << "add 50" << std::endl;
#endif
				n += 50;
			}
		} else if (statements[i]->isBranch()) {
			SyntaxNode *loop = root->getEnclosingLoop(this);
			std::cerr << "branch " << statements[i]->getNumber()
			          << " not in loop" << std::endl;
			if (loop) {
				std::cerr << "branch " << statements[i]->getNumber()
				          << " in loop " << loop->getNumber() << std::endl;
				// this is a bit C specific
				SyntaxNode *out = loop->getOutEdge(root, 0);
				if (out && statements[i]->getOutEdge(root, 0) == out) {
					std::cerr << "found break" << std::endl;
					n += 10;
				}
				if (statements[i]->getOutEdge(root, 0) == loop) {
					std::cerr << "found continue" << std::endl;
					n += 10;
				}
			} else {
#if DEBUG_EVAL
				std::cerr << "add 50" << std::endl;
#endif
				n += 50;
			}
		} else if (i < statements.size() - 1
		        && statements[i]->getOutEdge(root, 0) != statements[i + 1]) {
#if DEBUG_EVAL
			std::cerr << "add 25" << std::endl;
			std::cerr << statements[i]->getNumber() << " -> "
			          << statements[i]->getOutEdge(root, 0)->getNumber()
			          << " not " << statements[i + 1]->getNumber() << std::endl;
#endif
			n += 25;
		}
	}
#if DEBUG_EVAL
	if (this == root)
		std::cerr << "end eval = " << n << " =============" << std::endl;
#endif
	return n;
}
예제 #12
0
SymVar* Parser::ParseDeclarator(SymType* type, bool parseParams)
{
    SymVar* result = NULL;

    //pointer
    while (*lexer.Peek() == MULTIPLICATION)
    {
        type = new SymTypePointer(type);
        lexer.Get();
    }

    //direct-declarator
    if (*lexer.Peek() == ROUND_LEFT_BRACKET)
    {
        lexer.Get();
        result =  ParseDeclarator(type);
        Expected(lexer.Get()->GetSubType(), ROUND_RIGHT_BRACKET);
        return result;
    }

    Expected(parseParams || *lexer.Peek() == IDENTIFIER, "exepcted an identifier");

    if (parseParams && *lexer.Peek() != IDENTIFIER)
    {
        string n = to_string((long double)counter++);
        BaseToken* dummy = new BaseToken("abstract-"+n, 0, 0, IDENTIFIER, IDENTIFIER);
        result = new SymVar(dummy, type);
    }
    else
    {
        string msg = "redefinition: " + lexer.Peek()->GetText();
        Expected(!symStack.Top()->Find(lexer.Peek()->GetText()), &msg[0]);
        result = new SymVar(lexer.Get(), type);
    }

    BaseToken* token = lexer.Peek();
    if (*token == SQUARE_LEFT_BRACKET)
    {
        lexer.Get();
        Expected(*lexer.Peek() != SQUARE_RIGHT_BRACKET, "unknown size");

        SyntaxNode* index = ParseExpression();
        Expected(*index->token != IDENTIFIER, "expression must have a constant value");

        SymType* indexType = index->GetType();
        Expected(indexType == intType && indexType->CanConvertTo(intType),
                 "expression must be an integral constant expression");

        Expected(lexer.Get()->GetSubType(), SQUARE_RIGHT_BRACKET);

        int size = dynamic_cast<TokenVal <int> *>(index->token)->GetValue();
        result->SetType(new SymTypeArray(size, type));
    }
    else if (*token == ROUND_LEFT_BRACKET)
    {
        lexer.Get();
        SymTypeFunc* t = new SymTypeFunc(type);
        t->params->offset = 4;

        symStack.Push(t->params);
        ParseParameterList();
        symStack.Pop();

        if (*lexer.Peek() == FIGURE_LEFT_BRACKET)
        {
            parseFunc.push_back(t);
            t->body = ParseBlock();
            parseFunc.pop_back();
        }
        result->SetType(t);
    }

    return result;
}
예제 #13
0
SyntaxNode* ActionSymbol::Invoke(const std::vector<void*>& container) {
	Sym* sym = (Sym*)container[container.size() - argument_.parameters.front()];
	SyntaxNode* ans = new SyntaxNode(SyntaxNodeSymbol, sym->ToString());
	ans->SetSymbolAddress(sym);
	return ans;
}
예제 #14
0
SyntaxNode* ActionLiteral::Invoke(const std::vector<void*>& container) {
	Literal* literal = (Literal*)container[container.size() - argument_.parameters.front()];
	SyntaxNode* ans = new SyntaxNode(SyntaxNodeLiteral, literal->ToString());
	ans->SetLiteralAddress(literal);
	return ans;
}
예제 #15
0
SyntaxNode* ActionConstant::Invoke(const std::vector<void*>& container) {
	Constant* constant = (Constant*)container[container.size() - argument_.parameters.front()];
	SyntaxNode* ans = new SyntaxNode(SyntaxNodeConstant, constant->ToString());
	ans->SetConstantAddress(constant);
	return ans;
}