Ejemplo n.º 1
0
	/* call function */
	Value Object::call (const std::string& function,
	                    const List& params) const
	{
		FunctionList list = mClass->getFunctions (function);
		
		/* no function found */
		if (list.empty())
			throw std::runtime_error (
					"Cannot find the function '" + function + "' in the class '"
					+ mClass->getName() + "'.");
		
		
		FunctionList::iterator iter;
		
		/* find a function which can handle the parameters */
		for (iter = list.begin(); iter != list.end(); ++iter)
		{
			Function* func = *iter;
			
			/* found match, execute the function */
			if (func->getType()->checkParamTypes (params))
				return func->call (params);
		}
		
		
		/* no capable function found */
		throw std::runtime_error (
				"Cannot find a function capable of handling the provided "
				"parameters");
	}
void QuickOpenFunctionDialog::slotTextChangedDelayed() {
    QString text = nameEdit->text();
    QString txt = text;
    QStringList parts = QStringList::split("::", text);
    if(text.endsWith("::") || parts.isEmpty()) {
        txt = "";
    }else{
        txt = parts.back();
        parts.pop_back();
    }
    QValueList<QRegExp> regExpParts;
    for( QStringList::const_iterator it = parts.begin(); it != parts.end(); ++it ) {
      regExpParts << QRegExp( *it, false, true );
    }

    QString scope = parts.join("::");

    if( m_scope != scope ) {
        if( !scope.startsWith(m_scope) ) { ///Not a specialization, so reload all function-definitions
          fillItemList();
        }

        if(!parts.isEmpty()) {
            FunctionList accepted;
            QStringList acceptedItems;
            FunctionList::iterator it = m_functionDefList.begin();
            while(it != m_functionDefList.end()) {
                QStringList scope = (*it)->scope();
                QValueList<QRegExp>::iterator mit = regExpParts.begin();
                QStringList::iterator sit = scope.begin();
                bool fail = false;
                while(mit != regExpParts.end()) {
                    while(sit != scope.end() && !(*mit).exactMatch( *sit ) ) ++sit;
                    if(sit == scope.end()) {
                        fail = true;
                        break;
                    }
                    ++mit;
                }
                if(!fail) {
                  accepted.append(*it);
                  acceptedItems << (*it)->name();
                }
                ++it;
            }
            m_functionDefList = accepted;
            m_items = acceptedItems;
            QStringList_unique( m_items );
        }

        m_scope = scope;
    }
    
    itemList->clear();
    itemList->insertStringList( wildCardCompletion( txt ) );
    itemList->setCurrentItem(0);
}
Ejemplo n.º 3
0
	/* get function list */
	FunctionList Class::getFunctions () const
	{
		FunctionList list;
		FunctionMap::const_iterator iter;
		
		/* merge function lists from the map into a flat list */
		for (iter = mFunctions.begin(); iter != mFunctions.end(); ++iter)
			list.insert (list.end(), iter->second.begin(), iter->second.end());
		
		return list;
	}
void SerialPlugIn::RemoveDMFunctions( void )
{
	FunctionList::const_iterator functionPtr;

	for(	functionPtr = fFunctionList.begin(); 
			functionPtr != fFunctionList.end(); 
			++functionPtr )
	{
		RemoveFunction( *functionPtr );
	}
}
Ejemplo n.º 5
0
void refreshFunctions(ClassViewPart *part, KComboView *view, const ClassDom & dom)
{
    view->clear();

    view->setCurrentText(EmptyFunctions);
    FunctionList functions = dom->functionList();
    for (FunctionList::const_iterator it = functions.begin(); it != functions.end(); ++it)
    {
        FunctionItem *item = new FunctionItem(part, view->listView(), part->languageSupport()->formatModelItem(*it, true), *it);
        view->addItem(item);
        item->setOpen(true);
    }
}
Ejemplo n.º 6
0
FunctionList DSNodeEquivs::getCallees(CallSite &CS) {
  const Function *CalledFunc = CS.getCalledFunction();

  // If the called function is casted from one function type to another, peer
  // into the cast instruction and pull out the actual function being called.
  if (ConstantExpr *CExpr = dyn_cast<ConstantExpr>(CS.getCalledValue())) {
    if (CExpr->getOpcode() == Instruction::BitCast &&
        isa<Function>(CExpr->getOperand(0)))
      CalledFunc = cast<Function>(CExpr->getOperand(0));
  }

  FunctionList Callees;

  // Direct calls are simple.
  if (CalledFunc) {
    Callees.push_back(CalledFunc);
    return Callees;
  }

  // Okay, indirect call.
  // Ask the DSCallGraph what this calls...

  TDDataStructures &TDDS = getAnalysis<TDDataStructures>();
  const DSCallGraph &DSCG = TDDS.getCallGraph();

  DSCallGraph::callee_iterator CalleeIt = DSCG.callee_begin(CS);
  DSCallGraph::callee_iterator CalleeItEnd = DSCG.callee_end(CS);
  for (; CalleeIt != CalleeItEnd; ++CalleeIt)
    Callees.push_back(*CalleeIt);

  // If the callgraph doesn't give us what we want, query the DSGraph
  // ourselves.
  if (Callees.empty()) {
    Instruction *Inst = CS.getInstruction();
    Function *Parent = Inst->getParent()->getParent();
    Value *CalledValue = CS.getCalledValue();
    DSNodeHandle &NH = TDDS.getDSGraph(*Parent)->getNodeForValue(CalledValue);

    if (!NH.isNull()) {
      DSNode *Node = NH.getNode();
      Node->addFullFunctionList(Callees);
    }
  }

  // For debugging, dump out the callsites we are unable to get callees for.
  DEBUG(
  if (Callees.empty()) {
    errs() << "Failed to get callees for callsite:\n";
    CS.getInstruction()->dump();
  });
Ejemplo n.º 7
0
Dispatcher::Dispatcher(Module *M, CLData *Cl){
  FunctionList *fl = new FunctionList(M,Cl);
  if(fl != NULL){
    fl->runFnPtrValidator(Cl);
  } else {
    errs() << "\nError:Creation of FunctionList object failed!\n";
    exit(-1);
  }

  this->Fl = fl;

  if(Cl->getMode() == Common::INJECT){
    this->populateFaultSites(M,Cl);
    this->runFaultInjector(M,Cl);
  }
}
void QuickOpenFunctionDialog::gotoFile( QString name )
{
        FunctionModel *fmodel;
        FunctionList funcList;
        FunctionDom fdom;

        for( FunctionList::ConstIterator it = m_functionDefList.begin() ; it!=m_functionDefList.end() ; ++it ){
                fdom = *it;
                fmodel = fdom.data();
                if( fmodel->name() == name ){
                        funcList.append( fdom );
                }
        }
        if( funcList.count() == 1 ){
                fdom = funcList.first();
                fmodel = fdom.data();
                QString fileNameStr = fmodel->fileName();
                int startline, startcol;
                fmodel->getStartPosition( &startline, &startcol );
                m_part->partController()->editDocument( KURL( fileNameStr), startline, startcol );
                selectClassViewItem( ItemDom(&(*fmodel)) );

        }else if( funcList.count() > 1 ){
                QString fileStr;

                QuickOpenFunctionChooseForm fdlg( this, name.ascii() );

                for( FunctionList::Iterator it = funcList.begin() ; it!=funcList.end() ; ++it ){
                        fmodel = (*it).data();

                        fdlg.argBox->insertItem( m_part->languageSupport()->formatModelItem(fmodel) +
                                (fmodel->scope().isEmpty() ? "" : "   (in " + fmodel->scope().join("::") + ")"));
                        fileStr = KURL( fmodel->fileName() ).fileName();
                        KURL full_url( fmodel->fileName() );
                        KURL base_url( part()->project()->projectDirectory()+"/" );
                        fdlg.setRelativePath(fdlg.fileBox->count(),
                            KURL::relativeURL( base_url, full_url ));
                        fdlg.fileBox->insertItem(fileStr);
                }
                if( fdlg.exec() ){
                        int id = fdlg.argBox->currentItem();
                        if( id>-1 && id < (int) funcList.count() ){
                                FunctionModel *model = funcList[id].data();
                                int line, col;
                                model->getStartPosition( &line, &col );
                                selectClassViewItem( ItemDom(&(*model)) );
                                QString fileNameStr = model->fileName();
                                m_part->partController()->editDocument( KURL(fileNameStr), line );
                        }
                }
        }
        else{
                KMessageBox::error( this, i18n("Error: cannot find matching name function.") );
        }

        accept();
}
Ejemplo n.º 9
0
void Navigator::selectFunctionNav(QListViewItem *item)
{
    FunctionNavItem *nav = dynamic_cast<FunctionNavItem*>(item);
    if (!nav)
        return;

    FileDom file = m_part->codeModel()->fileByName(m_part->m_activeFileName);
    if (!file)
        return;

    switch (nav->type())
    {
        case FunctionNavItem::Definition: //jump to definition
        {
            FileList files = file->wholeGroup();
            FunctionDefinitionList deflist;
            CodeModelUtils::findFunctionDefinitions(NavOp(this, nav->text(0)), files, deflist);
            if (deflist.count() < 1)
                return;

            FunctionDefinitionDom fun = deflist.first();
            if (!fun)
                return;
            int startLine = 0, startColumn = 0;
            fun->getStartPosition(&startLine, &startColumn);
            m_part->partController()->editDocument(KURL(fun->fileName()), startLine);
            break;
        }
        case FunctionNavItem::Declaration: //jump to declaration
        {
            FileList files = file->wholeGroup();
            FunctionList declist;
            CodeModelUtils::findFunctionDeclarations(NavOp(this, nav->text(0)), files, declist);
            if (declist.count() < 1)
                return;

            FunctionDom fun = declist.first();
            if (!fun)
                return;
            int startLine = 0, startColumn = 0;
            fun->getStartPosition(&startLine, &startColumn);
            m_part->partController()->editDocument(KURL(fun->fileName()), startLine);
            break;
        }
    }
}
Ejemplo n.º 10
0
void TypeRegistry::collect_pure_methods(const TypeDesc &td, FunctionList &fl) const
{
    for (BaseTypeList::const_iterator i=td.base_types.begin(); i!=td.base_types.end(); ++i)
    {
        const TypeDesc *base = findTypeDescription(i->name);
        if (base)
            collect_pure_methods(*base, fl);
    }

    FunctionList methods;
    std::copy(td.methods.begin(), td.methods.end(), std::back_inserter(methods));
    std::copy(td.prot_methods.begin(), td.prot_methods.end(), std::back_inserter(methods));
    std::copy(td.priv_methods.begin(), td.priv_methods.end(), std::back_inserter(methods));

    for (FunctionList::const_iterator i=methods.begin(); i!=methods.end(); ++i)
    {
        if (i->is_pure_virtual)
        {
            fl.push_back(*i);
        }
        else
        {
            for (FunctionList::iterator j=fl.begin(); j!=fl.end();)
            {
                if (j->get_signature() == i->get_signature())
                {
                    fl.erase(j);
                }
                else
                    ++j;
            }
        }
    }
}
Ejemplo n.º 11
0
void testFuncParser(char *buf)
{
    printf("===== Testing function parser ======\n");
//	time_t start = GetTickCount();
    FunctionList li;
    //fflush(stdout);
    std::map<std::string, std::string> ignoreTokens;
    get_functions(buf, li, ignoreTokens);
//	time_t end = GetTickCount();
    for (FunctionList::iterator iter = li.begin(); iter != li.end(); iter++) {
        //test the var parser on the function argument list:
        clFunction f = (*iter);
        f.Print();
        //testVarParser((char*)f.m_signature.c_str());
        printf("%s\n", f.m_name.c_str());
    }

//	printf("total time: %d\n", end-start);
    printf("matches found: %d\n", li.size());
}
Ejemplo n.º 12
0
void refreshFunctions(ClassViewPart *part, KComboView *view, const QString & dom)
{
    view->clear();

    view->setCurrentText(EmptyFunctions);
    NamespaceDom nsdom;
    if (dom == "::")
        nsdom = part->codeModel()->globalNamespace();
    else
    {
        nsdom = namespaceByName(part->codeModel()->globalNamespace(), dom);
        if (!nsdom)
            return;
    }
    FunctionList functions = nsdom->functionList();
    for (FunctionList::const_iterator it = functions.begin(); it != functions.end(); ++it)
    {
        FunctionItem *item = new FunctionItem(part, view->listView(), part->languageSupport()->formatModelItem(*it, true), *it);
        view->addItem(item);
        item->setOpen(true);
    }
}
Ejemplo n.º 13
0
void SerialPlugIn::AddDMFunctions( void )
{
	fFunctionList.push_back( AddFunction( 0, "void SerialOpen(char * port, long baud)", 3, (void *) &SerialOpen ) );
	fFunctionList.push_back( AddFunction( 0, "void SerialCheck(char * port)", 3, (void *) &SerialCheck ) );
	fFunctionList.push_back( AddFunction( 0, "void SerialClose( void )", 3, (void *)  &SerialClose ) );
	fFunctionList.push_back( AddFunction( 0, "short RxByte( void )", 3, (void *) &RxByte ) );
	fFunctionList.push_back( AddFunction( 0, "void TxByte(short byte)", 3, (void *) &TxByte ) );
	fFunctionList.push_back( AddFunction( 0, "void TxInt(unsigned int num)", 3, (void *) &TxInt ) );
}
Ejemplo n.º 14
0
AddMethodDialog::AddMethodDialog( CppSupportPart* cppSupport, ClassDom klass,
                                  QWidget* parent, const char* name, bool modal, WFlags fl )
: AddMethodDialogBase( parent, name, modal, fl ), m_cppSupport( cppSupport ), m_klass( klass ), m_count( 0 )
{
	QString fileName = m_klass->fileName();

	access->insertStringList( QStringList() << "Public" << "Protected" << "Private" << "Signals" <<
	                          "Public Slots" << "Protected Slots" << "Private Slots" );

	storage->insertStringList( QStringList() << "Normal" << "Static" << "Virtual" << "Pure Virtual" << "Friend" );

	// setup sourceFile combo
	QMap<QString, bool> m;
#if 0 /// \FIXME ROBE

	FunctionList l = m_klass->functionList();
	{
		for ( FunctionList::Iterator it = l.begin(); it != l.end(); ++it )
		{
			if ( ( *it ) ->hasImplementation() )
				m.insert( ( *it ) ->implementedInFile(), true );
		}
	}
#endif

	{
		QStringList headers = QStringList::split( ",", "h,H,hh,hxx,hpp,inl,tlh,diff,ui.h" );
		QStringList fileList;
		QMap<QString, bool>::Iterator it = m.begin();
		while ( it != m.end() )
		{
			QString ext = QFileInfo( it.key() ).extension();
			if ( !headers.contains( ext ) )
				sourceFile->insertItem( it.key() );
			++it;
		}

		if ( sourceFile->count() == 0 )
		{
			QFileInfo info( fileName );
			QString impl = DomUtil::readEntry( *cppSupport->projectDom(), "/cppsupportpart/filetemplates/implementationsuffix", "cpp" );
			sourceFile->insertItem( info.dirPath( true ) + "/" + info.baseName() + impl );
		}
	}

	returnType->setAutoCompletion( true );
	returnType->insertStringList( QStringList()
	                              << "void"
	                              << "char"
	                              << "wchar_t"
	                              << "bool"
	                              << "short"
	                              << "int"
	                              << "long"
	                              << "signed"
	                              << "unsigned"
	                              << "float"
	                              << "double" );

	returnType->insertStringList( typeNameList( m_cppSupport->codeModel() ) );

	updateGUI();
	addMethod();
}
Ejemplo n.º 15
0
void AddMethodDialog::accept()
{
	m_cppSupport->partController() ->editDocument( KURL( m_klass->fileName() ) );
	KTextEditor::EditInterface* editIface = dynamic_cast<KTextEditor::EditInterface*>( m_cppSupport->partController() ->activePart() );
	if ( !editIface )
	{
		/// @todo show messagebox
		QDialog::accept();
		return ;
	}

	int line, column;
	m_klass->getEndPosition( &line, &column );

	// compute the insertion point map
	QMap<QString, QPair<int, int> > points;
	QStringList accessList;

	const FunctionList functionList = m_klass->functionList();
	for ( FunctionList::ConstIterator it = functionList.begin(); it != functionList.end(); ++it )
	{
		int funEndLine, funEndColumn;
		( *it ) ->getEndPosition( &funEndLine, &funEndColumn );
		QString access = accessID( *it );
		QPair<int, int> funEndPoint = qMakePair( funEndLine, funEndColumn );

		if ( !points.contains( access ) || points[ access ] < funEndPoint )
		{
			accessList.remove( access );
			accessList.push_back( access ); // move 'access' at the end of the list

			points[ access ] = funEndPoint;
		}
	}

	int insertedLine = 0;

	accessList += newAccessList( accessList );

	for ( QStringList::iterator it = accessList.begin(); it != accessList.end(); ++it )
	{
		QListViewItem* item = methods->firstChild();
		while ( item )
		{
			QListViewItem * currentItem = item;

			item = item->nextSibling();

			if ( currentItem->text( 1 ) != *it )
				continue;

			QString access = ( *it ).lower();

			bool isInline = currentItem->text( 0 ) == "True";
			QString str = isInline ? functionDefinition( currentItem ) : functionDeclaration( currentItem );

			QPair<int, int> pt;
			if ( points.contains( *it ) )
			{
				pt = points[ *it ];
			}
			else
			{
			str.prepend( access + ":\n" );
				points[ *it ] = qMakePair( line - 1, 0 );
				pt = points[ *it ]; // end of class declaration
			}

			editIface->insertText( pt.first + insertedLine + 1, 0 /*pt.second*/, str );
			insertedLine += str.contains( QChar( '\n' ) );
		}
	}

	m_cppSupport->backgroundParser() ->addFile( m_klass->fileName() );

	QString str;
	QListViewItem* item = methods->firstChild();
	while ( item )
	{
		QListViewItem * currentItem = item;

		item = item->nextSibling();

		QString str = functionDefinition( currentItem );
		if ( str.isEmpty() )
			continue;

		QString implementationFile = currentItem->text( 5 );
		if ( currentItem->text( 0 ) == "True" )
			implementationFile = m_klass->fileName();

		QFileInfo fileInfo( implementationFile );
		if ( !QFile::exists( fileInfo.absFilePath() ) )
		{
			if ( KDevCreateFile * createFileSupp = m_cppSupport->extension<KDevCreateFile>( "KDevelop/CreateFile" ) )
				createFileSupp->createNewFile( fileInfo.extension(), fileInfo.dirPath( true ), fileInfo.baseName() );
		}

		m_cppSupport->partController() ->editDocument( KURL( implementationFile ) );
		editIface = dynamic_cast<KTextEditor::EditInterface*>( m_cppSupport->partController() ->activePart() );
		if ( !editIface )
			continue;

		bool isInline = currentItem->text( 0 ) == "True";
		if ( !isInline )
		{
			editIface->insertLine( editIface->numLines(), QString::fromLatin1( "" ) );
			editIface->insertText( editIface->numLines() - 1, 0, str );
			m_cppSupport->backgroundParser() ->addFile( implementationFile );
		}
	}

	QDialog::accept();
}
Ejemplo n.º 16
0
/* FIXME TODO: error processing. Find out a way to notify the caller of the occurred 
 * error. The "cout" method cannot be used
 */
IAnjutaIterable *
EngineParser::processExpression(const string& stmt, 
    							const string& above_text,
    							const string& full_file_path, 
    							unsigned long linenum)
{
	ExpressionResult result;
	string current_token;
	string op;
	string type_name;
	string type_scope;

	DEBUG_PRINT ("Setting text %s to the tokenizer", stmt.c_str ());
	_main_tokenizer->setText (stmt.c_str ());

	/* get the first token */
	nextMainToken (current_token, op);		

	DEBUG_PRINT ("First main token \"%s\" with op \"%s\"", current_token.c_str (), op.c_str ());

	/* parse the current sub-expression of a statement and fill up 
	 * ExpressionResult object
	 */
	result = parseExpression (current_token);

	/* fine. Get the type name and type scope given the above result for the first 
	 * and most important token.
	 * The type_scope is for instance 'std' in this statement:
	 * (std::foo_util)klass->
	 */	
	bool process_res = getTypeNameAndScopeByToken (result, 
    									  current_token,
    									  op,
    									  full_file_path, 
    									  linenum,
    									  above_text,
    									  type_name, 
    									  type_scope);
	if (process_res == false)
	{
		DEBUG_PRINT ("Initial statement processing failed. "
			"I cannot continue. ");
		return NULL;
	}
	
	DEBUG_PRINT ("Searching for curr_searchable_scope with type_name \"%s\""
				" and type_scope \"%s\"", type_name.c_str (), type_scope.c_str ());

	/* at this time we're enough ready to issue a first query to our db. 
	 * We absolutely need to find the searchable object scope of the first result 
	 * type. By this one we can iterate the tree of scopes and reach a result.
	 */	
	IAnjutaIterable *curr_searchable_scope =
		getCurrentSearchableScope (type_name, type_scope);

	if (curr_searchable_scope == NULL)
	{
		DEBUG_PRINT ("curr_searchable_scope failed to process, check the problem please");
		return NULL;
	}	
	
	/* fine. Have we more tokens left? */
	while (nextMainToken (current_token, op) == 1) 
	{
		DEBUG_PRINT("Next main token \"%s\" with op \"%s\"",current_token.c_str (), op.c_str ());

		/* parse the current sub-expression of a statement and fill up 
	 	 * ExpressionResult object
	 	 */
		result = parseExpression (current_token);
		
		if (process_res == false || curr_searchable_scope == NULL)
		{
			DEBUG_PRINT ("No luck with the NEXT token, the NEXT token failed and then "
				"I cannot continue. ");

			if (curr_searchable_scope != NULL)
				g_object_unref (curr_searchable_scope );
			return NULL;
		}
		
		/* check if the name of the result is valuable or not */
		IAnjutaSymbol *node;
		IAnjutaIterable * iter;

		node = IANJUTA_SYMBOL (curr_searchable_scope);
		
		iter = ianjuta_symbol_query_search_in_scope (_query_search_in_scope,
		                                             result.m_name.c_str (),
		                                             node, NULL);
		
		if (iter == NULL)
		{
			DEBUG_PRINT ("Warning, the result.m_name %s "
				"does not belong to scope (id %d)", result.m_name.c_str (), 
			             ianjuta_symbol_get_int (node, IANJUTA_SYMBOL_FIELD_ID, NULL));
			
			if (curr_searchable_scope != NULL)
				g_object_unref (curr_searchable_scope );
			
			return NULL;
		}
		else 
		{
			gchar *sym_kind;
			DEBUG_PRINT ("Good element %s", result.m_name.c_str ());
			
			node = IANJUTA_SYMBOL (iter);
			sym_kind = (gchar*)ianjuta_symbol_get_string (node, 
		    										IANJUTA_SYMBOL_FIELD_KIND, NULL);
			
			DEBUG_PRINT (".. it has sym_kind \"%s\"", sym_kind);

			/* the same check as in the engine-core on sdb_engine_add_new_sym_type () */
			if (g_strcmp0 (sym_kind, "member") == 0 || 
	    		g_strcmp0 (sym_kind, "variable") == 0 || 
	    		g_strcmp0 (sym_kind, "field") == 0)
			{
				iter = switchMemberToContainer (iter);
				node = IANJUTA_SYMBOL (iter);
				sym_kind = (gchar*)ianjuta_symbol_get_string (node, 
		    										IANJUTA_SYMBOL_FIELD_KIND, NULL);				
			}
			
			/* check for any typedef */
			if (g_strcmp0 (ianjuta_symbol_get_string (node, 
		    										IANJUTA_SYMBOL_FIELD_KIND, NULL),
	    											"typedef") == 0)
			{			
				iter = switchTypedefToStruct (iter);
				node = IANJUTA_SYMBOL (iter);
				sym_kind = (gchar*)ianjuta_symbol_get_string (node, 
		    										IANJUTA_SYMBOL_FIELD_KIND, NULL);				
			}
			
			/* is it a function or a method? */
			if (g_strcmp0 (sym_kind, "function") == 0 ||
			    g_strcmp0 (sym_kind, "method") == 0 ||
			    g_strcmp0 (sym_kind, "prototype") == 0)
			{

				string func_ret_type_name = 
					ianjuta_symbol_get_string (node, IANJUTA_SYMBOL_FIELD_RETURNTYPE, NULL);

				string func_signature = 
					ianjuta_symbol_get_string (node, IANJUTA_SYMBOL_FIELD_SIGNATURE, NULL);
				
				func_ret_type_name += " " + result.m_name + func_signature + "{}";

				FunctionList li;
				std::map<std::string, std::string> ignoreTokens;
				get_functions (func_ret_type_name, li, ignoreTokens);

				DEBUG_PRINT ("Functions found are...");
/*				
				for (FunctionList::reverse_iterator func_iter = li.rbegin(); 
				     func_iter != li.rend(); 
				     func_iter++) 
				{
					Function var = (*func_iter);
					var.print ();			
				}
*/
			
				g_object_unref (iter);

				DEBUG_PRINT ("Going to look for the following function ret type %s",
							func_ret_type_name.c_str ());

				iter = getCurrentSearchableScope (li.front().m_returnValue.m_type,
				                                  type_scope);
			}			               
			
			/* remove the 'old' curr_searchable_scope and replace with 
			 * this new one
			 */			
			g_object_unref (curr_searchable_scope);			
			curr_searchable_scope = iter;
			continue;
		}
	}

	DEBUG_PRINT ("END of expression processing. Returning curr_searchable_scope");
	return curr_searchable_scope;
}
Ejemplo n.º 17
0
void
html_web_view_open (GtkWidget *viewer, const gchar *uri)
{
  g_debug ("uri = '%s'\n",uri);
  function_list._html_web_view_open (viewer, uri);
}
Ejemplo n.º 18
0
GtkWidget *
html_web_view_new (void)
{
  return function_list._html_web_view_new ();
}
Ejemplo n.º 19
0
int WriteFunctions(const FunctionList &functions)
{
	// separate the master function list into namespaces
	OutFileMap fileMap;
	fileMap.insert(std::make_pair("","Globals"));

	for(obuint32 i = 0; i < functions.size(); ++i)
	{
		OutFileMap::iterator it = fileMap.find(functions[i].ClassName);
		if(it == fileMap.end())
		{
			OutFileMap::_Pairib ins = fileMap.insert(std::make_pair(functions[i].ClassName,NameSpaces(functions[i].ClassName)));
			it = ins.first;
		}
		it->second.Functions.push_back(functions[i]);
	}

	// write out each file.
	for(OutFileMap::iterator it = fileMap.begin();
		it != fileMap.end();
		++it)
	{
		File outFile;

		// write out each function
		const String FileName = Utils::VA("%s.cpp", it->second.FileName.c_str());
		if(outFile.OpenForWrite(FileName.c_str(),File::Text,false))
		{
			outFile.Printf("#include \"gmThread.h\"\n\n");

			WriteUserTypeVars(outFile,it->second);

			// write the function implementations
			WriteFunctionImplementations(outFile,it->second);

			// write the binding block
			WriteFunctionBindBlock(outFile,it->second);
		}
	}

	// write table of contents file, where all bindings are registered.
	File tocFile;
	if(tocFile.OpenForWrite("ScriptBindAll.cpp",File::Text))
	{
		tocFile.Printf("#include \"gmThread.h\"\n\n");

		tocFile.Printf("// declarations\n");
		for(OutFileMap::iterator it = fileMap.begin();
			it != fileMap.end();
			++it)
		{
			if(!it->second.Functions.empty())
			{
				tocFile.Printf("void gmBind%sLib(gmMachine * a_machine);\n",it->second.FileName.c_str());
			}
		}

		tocFile.Printf("\n\n// bind libraries\n");
		tocFile.Printf("void gmBindAllAutogenLibs(gmMachine * a_machine)\n");
		tocFile.Printf("{\n");

		for(OutFileMap::iterator it = fileMap.begin();
			it != fileMap.end();
			++it)
		{
			if(!it->second.Functions.empty())
			{
				tocFile.Printf("\tgmBind%sLib(a_machine);\n",it->second.FileName.c_str());
			}
		}
		tocFile.Printf("}\n");
	}

	return fileMap.size();
}
Ejemplo n.º 20
0
// An "invalid" list is one whose functions don't match, and therefore has to be animated as a Matrix
// The hasBigRotation flag will always return false if isValid is false. Otherwise hasBigRotation is 
// true if the rotation between any two keyframes is >= 180 degrees.
void GraphicsLayer::TransformValueList::makeFunctionList(FunctionList& list, bool& isValid, bool& hasBigRotation) const
{
    list.clear();
    isValid = false;
    hasBigRotation = false;
    
    if (m_values.size() < 2)
        return;
    
    // empty transforms match anything, so find the first non-empty entry as the reference
    size_t firstIndex = 0;
    for ( ; firstIndex < m_values.size(); ++firstIndex) {
        if (m_values[firstIndex].value()->operations().size() > 0)
            break;
    }
    
    if (firstIndex >= m_values.size())
        return;
        
    const TransformOperations* firstVal = m_values[firstIndex].value();
    
    // see if the keyframes are valid
    for (size_t i = firstIndex + 1; i < m_values.size(); ++i) {
        const TransformOperations* val = m_values[i].value();
        
        // a null transform matches anything
        if (val->operations().isEmpty())
            continue;
            
        if (firstVal->operations().size() != val->operations().size())
            return;
            
        for (size_t j = 0; j < firstVal->operations().size(); ++j) {
            if (!firstVal->operations().at(j)->isSameType(*val->operations().at(j)))
                return;
        }
    }

    // keyframes are valid, fill in the list
    isValid = true;
    
    double lastRotAngle = 0.0;
    double maxRotAngle = -1.0;
        
    list.resize(firstVal->operations().size());
    for (size_t j = 0; j < firstVal->operations().size(); ++j) {
        TransformOperation::OperationType type = firstVal->operations().at(j)->getOperationType();
        list[j] = type;
        
        // if this is a rotation entry, we need to see if any angle differences are >= 180 deg
        if (type == TransformOperation::ROTATE_X ||
            type == TransformOperation::ROTATE_Y ||
            type == TransformOperation::ROTATE_Z ||
            type == TransformOperation::ROTATE_3D) {
            lastRotAngle = static_cast<RotateTransformOperation*>(firstVal->operations().at(j).get())->angle();
            
            if (maxRotAngle < 0)
                maxRotAngle = fabs(lastRotAngle);
            
            for (size_t i = firstIndex + 1; i < m_values.size(); ++i) {
                const TransformOperations* val = m_values[i].value();
                double rotAngle = val->operations().isEmpty() ? 0 : (static_cast<RotateTransformOperation*>(val->operations().at(j).get())->angle());
                double diffAngle = fabs(rotAngle - lastRotAngle);
                if (diffAngle > maxRotAngle)
                    maxRotAngle = diffAngle;
                lastRotAngle = rotAngle;
            }
        }
    }
    
    hasBigRotation = maxRotAngle >= 180.0;
}
Ejemplo n.º 21
0
int main(int argc,const char **argv)
{
	int returnVal = 0;

	g_Logger.Start("gmParser.log", true);
	LOG("gmParser");

	if(argc < 2)
	{
		PrintUsage();
		ERROR_RETURN;
	}	

	Timer tme, totaltime;
	

	const char *FolderIn = argv[1];
	//const char *FolderOut = argv[2];

	if(!FileSystem::InitRawFileSystem(FolderIn))
	{
		std::cout << "Unable to Initialize File System." << std::endl;
		ERROR_RETURN;
	}

	if(!FileSystem::Mount(FolderIn,""))
	{
		std::cout << "Unable to Mount Root Folder." << std::endl;
		ERROR_RETURN;
	}

	if(!FileSystem::SetWriteDirectory(fs::path(FolderIn,fs::native)))
	{
		std::cout << "Unable to Set Write Folder." << std::endl;
		ERROR_RETURN;
	}

	// find all files to parse
	tme.Reset();
	boost::regex ex("test.*.cpp");
	DirectoryList dl;
	FileSystem::FindAllFiles("",dl,ex,true);
	std::cout << "Found " << dl.size() << " files in " << tme.GetElapsedSeconds() << " seconds." << std::endl;;

	// parse files
	tme.Reset();
	typedef std::vector<FileParser> FileParserList;
	FileParserList parsers;
	parsers.reserve(dl.size());
	for(obuint32 i = 0; i < dl.size(); ++i)
	{
		parsers.push_back(FileParser(dl[i].string()));
	}

	const int numParsers = parsers.size();

#pragma omp parallel for
	for(int i = 0; i < numParsers; ++i)
	{
		parsers[i].ParseFile();
		std::cout << "*";
	}

	std::cout << std::endl;
	std::cout << "Parsed " << numParsers << " files in " << tme.GetElapsedSeconds() << " seconds." << std::endl;

	// merge all to a master function list
	FunctionList allFunctions;
	allFunctions.reserve(2048);
	for(obuint32 i = 0; i < (obuint32)numParsers; ++i)
	{
		allFunctions.insert(allFunctions.end(),parsers[i].Functions.begin(),parsers[i].Functions.end());

		for(obuint32 e = 0; e < parsers[i].Info.size(); ++e)
		{
			std::cout << parsers[i].Info[e] << std::endl;
		}
	}
	std::cout << "Found " << allFunctions.size() << " functions..." << std::endl;

	// write the function bindings out to files.
	tme.Reset();
	const int numFiles = WriteFunctions(allFunctions);
	std::cout << "Wrote " << numFiles << " files in " << tme.GetElapsedSeconds() << " seconds." << std::endl;

	std::cout << "Finished in " << totaltime.GetElapsedSeconds() << " seconds." << std::endl;

	return 0;
}
Ejemplo n.º 22
0
// Parse a region of tokens
Node *Parser::ParseRegion(Parser::size_type start, Parser::size_type end)
{
    size_type pos;
    size_type fgopen = (size_type)-1;
    size_type fgclose = (size_type)-1;
    size_type assignindex = (size_type)-1;
    size_type addsubindex = (size_type)-1;
    size_type muldivindex = (size_type)-1;
    size_type posnegindex = (size_type)-1;
    size_type expindex = (size_type)-1;
    bool multiexpr = false;
    int plevel = 0;
    
    // Check simple syntax
    if(start > end)
        throw(SyntaxException());
        
    // Scan through tokens
    for(pos = start; pos <= end; pos++)
    {
        switch(m_tokens[pos].GetType())
        {
            case Token::TypeOpenParenthesis:
            {
                plevel++;
                
                // Opening of first group?
                if(plevel == 1 && fgopen == (size_type)-1)
                    fgopen = pos;
                    
                break;
            };
                
            case Token::TypeCloseParenthesis:
            {
                plevel--;
                
                // First group closed?
                if(plevel == 0 && fgclose == (size_type)-1)
                    fgclose = pos;
                    
                if(plevel < 0)
                {
                    UnmatchedParenthesisException e;
                    
                    e.SetStart(m_tokens[pos].GetStart());
                    e.SetEnd(m_tokens[pos].GetEnd());
                    throw(e);
                }
                    
                break;
            }
                
            case Token::TypeEqual:
            {
                if(plevel == 0)
                {
                    if(assignindex == (size_type)-1)
                        assignindex = pos;
                }
                    
                break;
            }
                
            case Token::TypeAsterisk:
            case Token::TypeForwardSlash:
            {
                if(plevel == 0)
                {
                    muldivindex = pos;
                }
                    
                break;
            }
                
            case Token::TypeHat:
            {
                if(plevel == 0)
                {
                    expindex = pos;
                }
                
                break;
            }
                
            case Token::TypePlus:
            case Token::TypeHyphen:
            {
                if(plevel == 0)
                {
                    if(pos == start)
                    {
                        // Positive or negative sign
                        if(posnegindex == (size_type)-1)
                            posnegindex = pos;
                    }
                    else
                    {
                        // What is before us
                        switch(m_tokens[pos - 1].GetType())
                        {
                            case Token::TypeEqual:
                            case Token::TypePlus:
                            case Token::TypeHyphen:
                            case Token::TypeAsterisk:
                            case Token::TypeForwardSlash:
                            case Token::TypeHat:
                                // After any of these, we are a positive/negative
                                if(posnegindex == (size_type)-1)
                                    posnegindex = pos;
                                break;
                                
                            default:
                                // After any other, we are addition/subtration
                                addsubindex = pos;
                                break;
                        }
                    }
                }
                    
                break;
            }
                
            case Token::TypeSemicolon:
            {
                if(plevel == 0)
                {
                    multiexpr = true;
                }
                
                break;
            }
        }
    }
        
    // plevel should be 0
    if(plevel != 0)
    {
        UnmatchedParenthesisException e;
        
        e.SetStart(end);
        e.SetEnd(end);
        throw(e);
    }
        
    // Parse in certain order to maintain order of operators
    
    // Multi-expression first
    if(multiexpr)
    {
        auto_ptr<Node> n(new MultiNode(m_expr));
        n->Parse(*this, start, end);
        return n.release();
    }
    else if(assignindex != (size_type)-1)
    {
        // Assignment next
        auto_ptr<Node> n(new AssignNode(m_expr));
        n->Parse(*this, start, end, assignindex);
        return n.release();
    }
    else if(addsubindex != (size_type)-1)
    {
        // Addition/subtraction next
        if(m_tokens[addsubindex].GetType() == Token::TypePlus)
        {
            // Addition
            auto_ptr<Node> n(new AddNode(m_expr));
            n->Parse(*this, start, end, addsubindex);
            return n.release();
        }
        else
        {
            // Subtraction
            auto_ptr<Node> n(new SubtractNode(m_expr));
            n->Parse(*this, start, end, addsubindex);
            return n.release();
        }
    }
    else if(muldivindex != (size_type)-1)
    {
        // Multiplication/division next
        
        if(m_tokens[muldivindex].GetType() == Token::TypeAsterisk)
        {
            // Multiplication
            auto_ptr<Node> n(new MultiplyNode(m_expr));
            n->Parse(*this, start, end, muldivindex);
            return n.release();
        }
        else
        {
            // Division
            auto_ptr<Node> n(new DivideNode(m_expr));
            n->Parse(*this, start, end, muldivindex);
            return n.release();
        }
    }
    else if(posnegindex == start)
    {
        // Positive/negative next, must be at start and check before exponent
        if(m_tokens[posnegindex].GetType() == Token::TypePlus)
        {
            // Positive
            return ParseRegion(posnegindex + 1, end);
        }
        else
        {
            auto_ptr<Node> n(new NegateNode(m_expr));
            n->Parse(*this, start, end, posnegindex);
            return n.release();
        }
    }
    else if(expindex != (size_type)-1)
    {
        // Exponent
        auto_ptr<Node> n(new ExponentNode(m_expr));
        n->Parse(*this, start, end, expindex);
        return n.release();
    }
    else if(posnegindex != (size_type)-1)
    {
        // Check pos/neg again.  After testing for exponent, a pos/neg
        // at plevel 0 is syntax error
        SyntaxException e;
        
        e.SetStart(m_tokens[posnegindex].GetStart());
        e.SetEnd(m_tokens[posnegindex].GetEnd());
        throw(e);
    }
    else if(fgopen == start)
    {
        // Group parenthesis, make sure something in between them
        if(fgclose == end && fgclose > fgopen + 1)
        {
            return ParseRegion(fgopen + 1, fgclose - 1);
        }
        else
        {
            SyntaxException e;
            
            e.SetStart(m_tokens[fgopen].GetStart());
            if(fgclose == (size_type)-1)
                e.SetEnd(m_tokens[fgopen].GetEnd());
            else
                e.SetEnd(m_tokens[fgclose].GetEnd());
                
            throw(e);
        }
    }
    else if(fgopen == start + 1)
    {
        // Function
        if(fgclose == end)
        {
            // Find function list
            FunctionList *flist = m_expr->GetFunctionList();
            
            if(flist == 0)
            {
                NoFunctionListException e;
        
                e.SetStart(m_tokens[start].GetStart());
                e.SetEnd(m_tokens[start].GetEnd());
                throw(e);
            }
                
            // Get name
            string ident = m_tokens[start].GetIdentifier();
            
            // Create function node
            auto_ptr<FunctionNode> n(flist->Create(ident, m_expr));
            
            if(n.get())
            {
                n->Parse(*this, fgopen, fgclose);
            }
            else
            {
                NotFoundException e(ident);
        
                e.SetStart(m_tokens[start].GetStart());
                e.SetEnd(m_tokens[start].GetEnd());
                throw(e);                
            }
                
            return n.release();
        }
        else
        {
            SyntaxException e;
        
            e.SetStart(m_tokens[fgopen].GetStart());
            if(fgclose == (size_type)-1)
                e.SetEnd(m_tokens[fgopen].GetEnd());
            else
                e.SetEnd(m_tokens[fgclose].GetEnd());    
                
            throw(e);
        }
    }
    else if(start == end)
    {
        // Value, variable, or constant
        
        if(m_tokens[start].GetType() == Token::TypeIdentifier)
        {
            // Variable/constant
            auto_ptr<Node> n(new VariableNode(m_expr));
            n->Parse(*this, start, end);
            return n.release();    
        }
        else
        {
            // Value
            auto_ptr<Node> n(new ValueNode(m_expr));
            n->Parse(*this, start, end);
            return n.release();
        }
    }
    else
    {
        // Unknown, syntax
        SyntaxException e;
        
        e.SetStart(m_tokens[pos].GetStart());
        e.SetEnd(m_tokens[pos].GetEnd());
        
        throw(e);
    }
}