Ast Class Reference

#include <AstContainer.h>

Collaboration diagram for Ast:

[legend]

---

Detailed Description

The Ast class is the main container of the AST. It contains all possible information about the source code: variable names (context), function, etc.

Definition at line 120 of file AstContainer.h.

Public Member Functions
std::list< VarBase >	getSubVariables (const tree< AstNode >::iterator &it) const
	Get the list of all subvariable.
	Ast ()
	Ast (const Ast &ast)
	Ast (const std::string &xmlFile)
Ast &	operator= (const Ast &ast)
	~Ast ()
tree< AstNode > *	getTreePtr ()
const tree< AstNode > *	getTreeConstPtr () const
std::map < std::string, BoxedFunction >	getBoxedFunctions () const
FunctionMapping	getMappedFunctions () const
std::list< std::string >	getVariableNames () const
	Get names informations.
std::list< std::string >	getFunctionNames () const
std::list< std::string >	getClassNames () const
Ast	skeleton () const
void	trace (const std::string &varName) const
void	apply (Obfuscator *obs)
StringBuffer	convert (Translation *obs)
MetricResult	compute (Metric *metric) const
void	printInfo (std::ostream &stream) const
Protected Member Functions
bool	is_skeleton_node (const tree< AstNode >::iterator &) const
void	fillAstInformation ()
	Scan the tree to fill the information about variables, functions etc.
void	clearInfo ()
	Clear all information.
std::string	getChildValue (tree< AstNode >::iterator parent, const std::string &nodeName="T_STRING") const
	Going down one node, return the name of the value (may be function, class, variable, etc.).
unsigned	nbNestedVariables (const tree< AstNode >::iterator &iter) const
	Return the number of nested variables: the number of variable in the sub-tree.
void	functionMapping (const tree< AstNode >::iterator &it, const std::string &fctName)
	Get all the function names used in a function or method.
void	functionBoxing (const tree< AstNode >::iterator &it, const std::string &fctName)
	Box one function.
void	sourceBoxing (const tree< AstNode >::iterator &it)
	Source boxing.
bool	detectAssignment (const tree< AstNode >::iterator &it) const
	Detect if there is an assignment in the subtree.
bool	detectFunction (const tree< AstNode >::iterator &i) const
	Detect if there is a function declaration in the subtree.
std::list< VarBase >	getRightVariables (const tree< AstNode >::iterator &it, const VarBase &left)
	Must not be 'const' since it can write to the MapAssignements...
VarBase	getLeftVariable (const tree< AstNode >::iterator &it)
	Get the variable in the left of an assignment.
VarBase	getSimpleVariable (const tree< AstNode >::iterator &iter)
	Simply get the one variable with is on the subtree.
Protected Attributes
tree< AstNode >	tr
	Store the tree.
tree< AstNode >::iterator	root
	Iterator to the root of the tree.
MapFunctions	functions
	Function name to tree iterator.
MapVariables	variables
	Variable name to list of variable (VarBase) which depends on the context of the variable.
MapClasses	classes
	Class name to tree iterator.
MapAssignments	assign
	Relations within variables (contexted).
MapVarEquivalent	equivalences
std::map < std::string, BoxedFunction >	boxedFunction
	For one function, list of what function is used as input and what is used as output.
FunctionMapping	fctmap
	Function to list of function used in.
Ast *	ref
	Reference to another tree, used for in-skeleton transformation.
BoxedFunction	boxedSource
	Do a boxing of the current source code, this is helpful for non function based code (php,asp, etc.).
Private Member Functions
void	walk (xmlNode *a_node, tree< AstNode >::iterator parent)
	Walk into the XML tree in order to build the AST in-memory.
Friends
std::ostream &	operator<< (std::ostream &stream, const Ast &ast)
void	exportXML (const Ast &ast, const std::string &xmlName)

---

Constructor & Destructor Documentation

Ast::Ast

(

)

[inline]

Definition at line 199 of file AstContainer.h.

References ref.

: root(tr.begin()) { ref = 0;}

Ast::Ast

(

const Ast &

ast

)

[inline]

Definition at line 200 of file AstContainer.h.

{*this = ast;}

Ast::Ast

(

const std::string &

xmlFile

)

Ast::~Ast

(

)

[inline]

Definition at line 215 of file AstContainer.h.

{}

---

Member Function Documentation

void Ast::walk	(	xmlNode *	a_node,
		tree< AstNode >::iterator	parent
	)			[private]

Walk into the XML tree in order to build the AST in-memory.

Definition at line 698 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::append_child(), getContent(), and tr.

{
    xmlNode *cur_node = 0;
    tree<AstNode>::iterator iter = parent;
    for (cur_node = a_node; cur_node; cur_node = cur_node->next) 
    {
        if (cur_node->type == XML_ELEMENT_NODE) {
            string name((char *)cur_node->name);
            iter = tr.append_child(parent,AstNode(name));
        }
        else if (cur_node->type == XML_TEXT_NODE) {
            string content = getContent(cur_node);
            string name((char *)cur_node->name);
            if (content.length() > 0) {
                iter = tr.append_child(parent, AstNode(name, content));
            }
        }
        walk(cur_node->children, iter);
    }
}

Here is the call graph for this function:

bool Ast::is_skeleton_node

(

const tree< AstNode >::iterator &

it

)

const [protected]

Check whether the current node is a "skeleton node" or not A skeleton tree is a simplified one, derived from the AST

Definition at line 740 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::parent(), utils::start_with(), and tr.

Referenced by skeleton().

{
    string t = it->getType();
    if (t == "T_INLINE_HTML")
        return false;
    else if (t == "text") {
        // look at the parent, if it's T_VARIABLE or T_STRING, keep it
        tree<AstNode>::iterator parent = tr.parent(it);
        string pt = parent->getType();
        if (pt == "T_VARIABLE" || pt == "T_STRING" || pt == "T_CONSTANT_ENCAPSED_STRING")
            return true;
        return false;
    }
    else if ((t == "root" || t == "start" || t == "CHAR61" || t == "expr" || t == "top_statement_list"
    || t == "internal_functions_in_yacc" || t == "function_call" || t == "statement" || t == "unticked_statement"
    || utils::start_with(t, "T_")))
        return true;
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Ast::fillAstInformation

(

)

[protected]

Scan the tree to fill the information about variables, functions etc.

Definition at line 606 of file AstContainer.cpp.

References assign, tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::child(), classes, className(), detectAssignment(), tree< T, tree_node_allocator >::end(), equivalences, functionBoxing(), functionMapping(), functions, getChildValue(), getLeftVariable(), getRightVariables(), tree< T, tree_node_allocator >::number_of_children(), sourceBoxing(), tr, and variables.

Referenced by convert().

{
    tree<AstNode>::iterator iter = tr.begin();
    sourceBoxing(iter);
    tree<AstNode>::sibling_iterator textable;
    tree<AstNode>::fixed_depth_iterator fter = iter;
    for (;iter != tr.end(); ++iter)
    {
        string type = iter->getType();
        if (type == "unticked_class_declaration_statement")
        {   
            string className = getChildValue(iter, "T_STRING");
            if (classes.find(className) != classes.end())
                continue;
            classes.insert(make_pair(className, iter));
        }
        else if (type == "unticked_function_declaration_statement")
        {
            string funcName = getChildValue(iter, "T_STRING");
            if (functions.find(funcName) != functions.end())
                continue;
            functions.insert(make_pair(funcName, iter));
            // Fill the function mapping win this function
            functionMapping(iter, funcName);
            // Get the boxed functions
            functionBoxing(iter, funcName);
        }
        // Variables Names detection
        else if (type == "reference_variable")
        {
            tree<AstNode>::iterator next = iter; ++next;
            if (next->getType() != "compound_variable") {
                // variable with array: $_GET['foo'] => $_GET, [, 'foo', ]
                tree<AstNode>::iterator array = tr.child(iter, 0);
                tree<AstNode>::iterator index = tr.child(iter, 2);
                for(;array->getType() != "text"; ++array)
                    ;
                for(;index->getType() != "text"; ++index)
                    ;
                VarBase var(array->getValue(), iter, index->getValue());
                if (!(variables.find(var.name) != variables.end())) {
                    AstVarBaseList astFooIterList;
                    variables.insert(make_pair(var.name, astFooIterList));
                }
                variables.find(var.name)->second.push_back(var);
            }
        }
        else if (type == "T_VARIABLE")
        {
            textable = tr.begin(iter);
            if (textable->getType() == "text") {
                VarBase var(textable->getValue(), iter);
                if (!(variables.find(var.name) != variables.end())) {
                    AstVarBaseList astFooIterList;
                    variables.insert(make_pair(var.name, astFooIterList));
                }
                variables.find(var.name)->second.push_back(var);
            }
        }
    }
    for (iter = tr.begin();iter != tr.end(); ++iter) {
        // Assignments, variables relation
        if (detectAssignment(iter))
        {
            VarBase leftVariable = getLeftVariable(tr.child(iter, 0));
            unsigned nbchilds = tr.number_of_children(iter);
            list<VarBase> rightVariables = getRightVariables(tr.child(iter, nbchilds - 1), leftVariable);
            // Store the information
            // for r in rights | reverse:
            //      add ( left <- r )
            //      add (    r <- r + 1 )
            list<VarBase>::reverse_iterator prev = rightVariables.rbegin();
            for (list<VarBase>::reverse_iterator i=rightVariables.rbegin(); i!=rightVariables.rend();++i) {
                // add the link with the left variables
                assign.insert(make_pair(leftVariable, *i));
                if (!(i == rightVariables.rbegin()))
                    assign.insert(make_pair(*i, *prev));
                prev = i;
            }
            MapVarEquivalent::iterator rIter;
            for (rIter = equivalences.begin(); rIter != equivalences.end(); ++rIter)
                if (rIter->first == leftVariable) {
                    //print_current_list(rIter->second);
                }
            // get the next same_depth iterator since I explored all the children
            tree<AstNode>::fixed_depth_iterator fter = iter;
            iter = ++fter;
        }
    }

}

Here is the call graph for this function:

Here is the caller graph for this function:

void Ast::clearInfo

(

)

[protected]

Clear all information.

Definition at line 848 of file AstContainer.cpp.

References classes, functions, and variables.

Referenced by convert().

{
    classes = MapClasses();
    variables = MapVariables();
    functions = MapFunctions();
}

Here is the caller graph for this function:

std::string Ast::getChildValue	(	tree< AstNode >::iterator	parent,
		const std::string &	nodeName = "T_STRING"
	)			const [protected]

Going down one node, return the name of the value (may be function, class, variable, etc.).

Referenced by fillAstInformation().

Here is the caller graph for this function:

unsigned Ast::nbNestedVariables

(

const tree< AstNode >::iterator &

iter

)

const [protected]

Return the number of nested variables: the number of variable in the sub-tree.

Calculate the number of nested variables

Definition at line 105 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::end(), and tr.

Referenced by getRightVariables(), and getSubVariables().

{
    unsigned nbVars = 0;
    tree<AstNode>::iterator lter = tr.begin(iter);
    for (;lter!=tr.end(iter);++lter) {
        if (lter->getType() == "T_VARIABLE")
            ++nbVars;
    }
    return nbVars;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Ast::functionMapping	(	const tree< AstNode >::iterator &	it,
		const std::string &	fctName
	)			[protected]

Get all the function names used in a function or method.

Mapping one function to others. The other functions are all the function call in the function.

Definition at line 297 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::end(), fctmap, utils::start_with(), and tr.

Referenced by fillAstInformation().

{
    if (fctmap.find(fctName) != fctmap.end())
        return;
    else
    {
        list<string> related;
        for (tree<AstNode>::iterator iter = tr.begin(it); iter != tr.end(it); ++iter) {
            string t = iter->getType();
            if (t == "function_call") {
                tree<AstNode>::iterator son = tr.begin(iter);
                if (son->getType() == "T_STRING") {
                    tree<AstNode>::iterator  textable = tr.begin(son);
                    if (textable->getType() == "text") {
                        related.push_back(textable->getValue());
                    }
                }
            }
            else if (t == "unticked_statement") {
                tree<AstNode>::iterator son = tr.begin(iter);
                if (utils::start_with(son->getType(), "T_")) {
                    tree<AstNode>::iterator  textable = tr.begin(son);
                    if (textable->getType() == "text") {
                        related.push_back(textable->getValue());
                    }
                }
            }
        }
        // Insert into the fctmap
        fctmap.insert(make_pair(fctName, related));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Ast::functionBoxing	(	const tree< AstNode >::iterator &	it,
		const std::string &	fctName
	)			[protected]

Box one function.

Boxing a function. Get inputs/outputs in term of functions.

Definition at line 217 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::begin(), boxedFunction, detectAssignment(), tree< T, tree_node_allocator >::end(), BoxedFunction::input, BoxedFunction::output, utils::start_with(), and tr.

Referenced by fillAstInformation().

{
    if (boxedFunction.find(fctName) != boxedFunction.end())
        return;
    else
    {
        BoxedFunction bFct;
        // Get the input
        for (tree<AstNode>::iterator iter = tr.begin(it); iter != tr.end(it); ++iter)
        {
            if (detectAssignment(iter))
            {
                // check if the right side has a function, if so, this is an input
                for (tree<AstNode>::iterator jter = tr.begin(iter); jter != tr.end(iter); ++jter) {
                    string t = jter->getType();
                    if (t == "function_call") {
                        tree<AstNode>::iterator son = tr.begin(jter);
                        if (son->getType() == "T_STRING") {
                            tree<AstNode>::iterator  textable = tr.begin(son);
                            if (textable->getType() == "text") {
                                if (bFct.input.find(textable->getValue()) != bFct.input.end())
                                    continue;
                                //cout << "Add in the boxed input ( "<< fctName << " ): " <<  textable->getValue() << endl;
                                bFct.input.insert(make_pair(textable->getValue(), jter));
                            }
                        }
                    }
                    else if (t == "unticked_statement") {
                        tree<AstNode>::iterator son = tr.begin(jter);
                        if (utils::start_with(son->getType(), "T_")) {
                            tree<AstNode>::iterator  textable = tr.begin(son);
                            if (textable->getType() == "text") {
                                if (bFct.input.find(textable->getValue()) != bFct.input.end())
                                    continue;
                                //cout << "Add in the boxed input ( "<< fctName << " ): " <<  textable->getValue() << endl;
                                bFct.input.insert(make_pair(textable->getValue(), jter));
                            }
                        }
                    }
                }
            }
        }
        // Second pass to get the isolated calls, getting the output
        for (tree<AstNode>::iterator iter = tr.begin(it); iter != tr.end(it); ++iter) 
        {
            string t = iter->getType();
            if (t == "function_call") {
                tree<AstNode>::iterator son = tr.begin(iter);
                if (son->getType() == "T_STRING") {
                    tree<AstNode>::iterator  textable = tr.begin(son);
                    if (textable->getType() == "text") {
                        if (bFct.output.find(textable->getValue()) != bFct.output.end())
                            continue;
                        //cout << "Add in the boxed output ( "<< fctName << " ): " <<  textable->getValue() << endl;
                        bFct.output.insert(make_pair(textable->getValue(), iter));
                    }
                }
            }
            else if (t == "unticked_statement") {
                tree<AstNode>::iterator son = tr.begin(iter);
                if (utils::start_with(son->getType(), "T_")) {
                    tree<AstNode>::iterator  textable = tr.begin(son);
                    if (textable->getType() == "text") {
                        if (bFct.output.find(textable->getValue()) != bFct.output.end())
                            continue;
                        //cout << "Add in the boxed output ( "<< fctName << " ): " <<  textable->getValue() << endl;
                        bFct.output.insert(make_pair(textable->getValue(), iter));
                    }
                }
            }
        }
        boxedFunction.insert(make_pair(fctName, bFct));
        //cout << "box size = " << boxedFunction.size() << endl;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Ast::sourceBoxing

(

const tree< AstNode >::iterator &

it

)

[protected]

Source boxing.

Boxing a source code. Get inputs/outputs in term of functions.

Definition at line 138 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::begin(), boxedSource, detectAssignment(), tree< T, tree_node_allocator >::end(), BoxedFunction::input, BoxedFunction::output, utils::start_with(), and tr.

Referenced by fillAstInformation().

{
    // Get the input
    for (tree<AstNode>::iterator iter = tr.begin(it); iter != tr.end(it); ++iter)
    {
        // skip the functions
        if (iter->getType() == "unticked_function_declaration_statement") {
            iter = tr.end(iter);
        }
        else if (detectAssignment(iter))
        {
            // check if the right side has a function, if so, this is an input
            for (tree<AstNode>::iterator jter = tr.begin(iter); jter != tr.end(iter); ++jter) {
                string t = jter->getType();
                if (t == "function_call") {
                    tree<AstNode>::iterator son = tr.begin(jter);
                    if (son->getType() == "T_STRING") {
                        tree<AstNode>::iterator  textable = tr.begin(son);
                        if (textable->getType() == "text") {
                            if (boxedSource.input.find(textable->getValue()) != boxedSource.input.end())
                                continue;
                            //cout << "Add in the boxed input ( "<< fctName << " ): " <<  textable->getValue() << endl;
                            boxedSource.input.insert(make_pair(textable->getValue(), jter));
                        }
                    }
                }
                else if (t == "unticked_statement") {
                    tree<AstNode>::iterator son = tr.begin(jter);
                    if (utils::start_with(son->getType(), "T_")) {
                        tree<AstNode>::iterator  textable = tr.begin(son);
                        if (textable->getType() == "text") {
                            if (boxedSource.input.find(textable->getValue()) != boxedSource.input.end())
                                continue;
                            //cout << "Add in the boxed input ( "<< fctName << " ): " <<  textable->getValue() << endl;
                            boxedSource.input.insert(make_pair(textable->getValue(), jter));
                        }
                    }
                }
            }
        }
    }

    // Second pass to get the isolated calls, getting the output
    for (tree<AstNode>::iterator iter = tr.begin(it); iter != tr.end(it); ++iter) 
    {
        string t = iter->getType();
        if (t == "unticked_function_declaration_statement") {
            iter = tr.end(iter);
        }
        else if (t == "function_call") {
            tree<AstNode>::iterator son = tr.begin(iter);
            if (son->getType() == "T_STRING") {
                tree<AstNode>::iterator  textable = tr.begin(son);
                if (textable->getType() == "text") {
                    if (boxedSource.output.find(textable->getValue()) != boxedSource.output.end())
                        continue;
                    //cout << "Add in the boxed output ( "<< fctName << " ): " <<  textable->getValue() << endl;
                    boxedSource.output.insert(make_pair(textable->getValue(), iter));
                }
            }
        }
        else if (t == "unticked_statement") {
            tree<AstNode>::iterator son = tr.begin(iter);
            if (utils::start_with(son->getType(), "T_")) {
                tree<AstNode>::iterator  textable = tr.begin(son);
                if (textable->getType() == "text") {
                    if (boxedSource.output.find(textable->getValue()) != boxedSource.output.end())
                        continue;
                    //cout << "Add in the boxed output ( "<< fctName << " ): " <<  textable->getValue() << endl;
                    boxedSource.output.insert(make_pair(textable->getValue(), iter));
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Ast::detectAssignment

(

const tree< AstNode >::iterator &

iter

)

const [protected]

Detect if there is an assignment in the subtree.

Detect an assignment in the subtree

Definition at line 126 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::child(), tree< T, tree_node_allocator >::number_of_children(), and tr.

Referenced by fillAstInformation(), functionBoxing(), getRightVariables(), and sourceBoxing().

{
    if (tr.number_of_children(iter) == 3 && tr.child(iter, 1)->getType() == "CHAR61")
        return true;
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Ast::detectFunction

(

const tree< AstNode >::iterator &

i

)

const [protected]

Detect if there is a function declaration in the subtree.

Definition at line 760 of file AstContainer.cpp.

Referenced by trace().

                                                             {
    if (i->getType() == "function_call")
        return true;
    return false;
}

Here is the caller graph for this function:

list< VarBase > Ast::getRightVariables	(	const tree< AstNode >::iterator &	it,
		const VarBase &	left
	)			[protected]

Must not be 'const' since it can write to the MapAssignements...

Get in post-order the right variables assignments

Definition at line 427 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::child(), detectAssignment(), tree< T, tree_node_allocator >::end(), equivalences, getLeftVariable(), getSimpleVariable(), getSubVariables(), VarBase::name, nbNestedVariables(), tree< T, tree_node_allocator >::number_of_children(), and tr.

Referenced by fillAstInformation().

{

    list<VarBase> varBaseList;
    unsigned nestedVars = nbNestedVariables(it);
    if (nestedVars == 0)
        return varBaseList;
    else if (nestedVars == 1 && !detectAssignment(it)) {
        VarBase simple = getSimpleVariable(it);
        varBaseList.push_back(simple);
        return varBaseList;
    }
    else
    {
        // Go to the last right 'expr_without_variable'
        unsigned nbchilds = tr.number_of_children(it);
        tree<AstNode>::iterator iter = tr.child(it, nbchilds - 1);
        //
        if (detectAssignment(iter)) {
            // Assignment => Let's move to the right, and grab the left variable as a 'left variable'
            VarBase leftVar = getLeftVariable(tr.child(iter, 0));
            if (leftVar.name != "")
                varBaseList.push_back(leftVar);
            list<VarBase> rightVars = getRightVariables(tr.child(iter, 2), left);
            // merge the result
            for (list<VarBase>::const_iterator jt=rightVars.begin(); jt!=rightVars.end();++jt)
                varBaseList.push_back(*jt);
        }
        else {
            AstVarBaseList locVarList;
            // get all variables, put that in a equivalences
            for (tree<AstNode>::iterator jter = iter;jter != tr.end(iter); ++jter) {
                string type(jter->getType());
                if (type == "reference_variable")
                {
                    unsigned nbchilds = tr.number_of_children(jter);
                    if (nbchilds == 1) {
                        if (tr.child(jter, 0)->getType() == "compound_variable") {
                            // single variables
                            tree<AstNode>::iterator var = jter;
                            for(;var->getType() != "text"; ++var)
                                ;
                            //cerr << "I got this? " << var->getValue() << endl;
                            VarBase right(var->getValue(), it);
                            if (!(find(locVarList.begin(), locVarList.end(),right) != locVarList.end()))
                                locVarList.push_back(right);
                            jter = var;
                        }
                    }
                    else if (nbchilds == 4) {
                        // array ?
                        tree<AstNode>::iterator array = tr.child(jter, 0);
                        tree<AstNode>::iterator index = tr.child(jter, 2);
                        for(;array->getType() != "text" && array != tr.end(); ++array)
                            ;
                        for(;index->getType() != "text" && index != tr.end(); ++index)
                            ;
                        VarBase right(array->getValue(), it, index->getValue());
                        if (!(find(locVarList.begin(), locVarList.end(),right) != locVarList.end()))
                            locVarList.push_back(right);
                        jter = index;                               
                    }
                }
                else if (type == "expr_without_variable")
                {
                    //cerr << "expr_wo_var ";
                    unsigned nbchilds = tr.number_of_children(iter);
                    //cerr << nbchilds << endl;
                    for (unsigned c=0;c<nbchilds;++c)
                    {
                        list<VarBase> varBaseListTemp = getSubVariables(tr.child(iter, c));
                        if (varBaseListTemp.size() > 0) {
                            // merge the list
                            for (list<VarBase>::const_iterator jter=varBaseListTemp.begin();jter!=varBaseListTemp.end();++jter) {
                                if (find(locVarList.begin(),locVarList.end(),*jter) == locVarList.end())
                                    locVarList.push_back(*jter);
                            }
                        }
                    }

                /*
                    // go to the T_VARIABLE
                    tree<AstNode>::iterator var = jter;
                    for(;var->getType() != "T_VARIABLE"; ++var)
                        ;
                    var = tr.child(var, 0);
                    //cerr << "I got this? " << var->getValue() << endl;
                    VarBase right(var->getValue(), it);
                    if (!(find(locVarList.begin(), locVarList.end(),right) != locVarList.end()))
                        locVarList.push_back(right);
                */
                }
            }
            // local equivalences
            equivalences.insert(make_pair(left, locVarList));                   
        }
        return varBaseList;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

VarBase Ast::getLeftVariable

(

const tree< AstNode >::iterator &

iter

)

[protected]

Get the variable in the left of an assignment.

Get left variable name

Definition at line 576 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::child(), tree< T, tree_node_allocator >::end(), tree< T, tree_node_allocator >::number_of_children(), and tr.

Referenced by fillAstInformation(), and getRightVariables().

{
    tree<AstNode>::iterator it = iter;
    for (;it->getType() != "reference_variable"; ++it)
        ;
    unsigned nbchilds = tr.number_of_children(it);
    if (nbchilds == 1) {
        tree<AstNode>::iterator var = it;
        for(;var->getType() != "text"; ++var)
            ;
        return VarBase(var->getValue(), it);
    }
    else if (nbchilds == 4) {
        // $foo['var'] pattern detected!
        tree<AstNode>::iterator array = tr.child(it, 0);
        tree<AstNode>::iterator index = tr.child(it, 2);
        for(;array->getType() != "text" && array != tr.end(); ++array)
            ;
        for(;index->getType() != "text" && index != tr.end(); ++index)
            ;
        return VarBase(array->getValue(), it, index->getValue());
    }
    else {
        // Not supported
        cerr << "getLeftVariable, unsupported elemnts nb = " << *it << endl;
        return VarBase();
    }
    return VarBase();
}

Here is the call graph for this function:

Here is the caller graph for this function:

VarBase Ast::getSimpleVariable

(

const tree< AstNode >::iterator &

it

)

[protected]

Simply get the one variable with is on the subtree.

Get a simple variable name; we know that there is one expression with one variable inside. We need to get this!

Definition at line 531 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::child(), tree< T, tree_node_allocator >::end(), tree< T, tree_node_allocator >::number_of_children(), and tr.

Referenced by getRightVariables().

{
    tree<AstNode>::iterator iter = it;
    // go the the variable
    for (;iter != tr.end(it); ++iter) {
        if (iter->getType() == "reference_variable")
        {
            unsigned nbchilds = tr.number_of_children(iter);
            if (nbchilds == 1) {
                if (tr.child(iter, 0)->getType() == "compound_variable") {
                    // single variables
                    tree<AstNode>::iterator var = iter;
                    for(;var->getType() != "text"; ++var)
                        ;
                    return VarBase(var->getValue(), it);
                }
            }
            else if (nbchilds == 4) {
                // array ?
                tree<AstNode>::iterator array = tr.child(iter, 0);
                tree<AstNode>::iterator index = tr.child(iter, 2);
                for(;array->getType() != "text" && array != tr.end(); ++array)
                    ;
                for(;index->getType() != "text" && index != tr.end(); ++index)
                    ;
                return VarBase(array->getValue(), it, index->getValue());
            }
        }
        else if (iter->getType() == "expr_without_variable")
        {
            // go to the T_VARIABLE
            tree<AstNode>::iterator var = iter;
            for(;var->getType() != "T_VARIABLE"; ++var)
                ;
            var = tr.child(var, 0);
            return VarBase (var->getValue(), it);
        }
    }
    // backtrack for: strings, functions, class
    return VarBase();
}

Here is the call graph for this function:

Here is the caller graph for this function:

list< VarBase > Ast::getSubVariables

(

const tree< AstNode >::iterator &

it

)

const

Get the list of all subvariable.

Get in post-order all the variables

Definition at line 334 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::child(), tree< T, tree_node_allocator >::end(), nbNestedVariables(), tree< T, tree_node_allocator >::number_of_children(), and tr.

Referenced by getRightVariables(), and NumberSunkDiffuseInputs::operator()().

{
    list<VarBase> varBaseList;
    if (nbNestedVariables(it) < 1)
        return varBaseList;
    //cerr << "start:- getSubVars" << endl;
    string type;
    for (tree<AstNode>::iterator iter=tr.begin(it);iter!=tr.end(it) && iter!=tr.end();iter++)
    {
        type = iter->getType();
        //cout << "\t\t\t => type = " << type << endl;
        if (type == "reference_variable")
        {
            //cerr << "\tref_var ";
            unsigned nbchilds = tr.number_of_children(iter);
            //cerr << nbchilds << endl;
            if (nbchilds == 1) {
                //cout << '[' << iter->getType() << " -> " << tr.child(iter,0)->getType()  << ']' << endl;

                if (tr.child(iter, 0)->getType() == "compound_variable") {
                    // single variables
                    tree<AstNode>::iterator var = iter;
                    for(;var->getType() != "text" && var != tr.end(it); ++var)
                        ;
                    //cerr << setw(15) << "ref :- [" << var->getValue() << ',' << it;
                    varBaseList.push_back(VarBase(var->getValue(), it));
                    //cerr << " ]" << endl;
                    iter = var;
                }
            }
            else if (nbchilds == 4) {
                // array ?
                tree<AstNode>::iterator array = tr.child(iter, 0);
                tree<AstNode>::iterator index = tr.child(iter, 2);
                for(;array->getType() != "text" && array != tr.end(it); ++array)
                    ;
                for(;index->getType() != "text" && index != tr.end(it); ++index)
                    ;
                //cerr << setw(15) << "array:- [" << array->getValue() << ',' << it << ',' << index->getValue();
                varBaseList.push_back(VarBase(array->getValue(), it, index->getValue()));
                //cerr << " ]" << endl;
                iter = index;
            }
        }
        else if (type == "expr_without_variable" || type == "encaps_var")
        {
            //cerr << "\texpr_wo_var ";
            unsigned nbchilds = tr.number_of_children(iter);
            //cerr << nbchilds << endl;
            for (unsigned c=0;c<nbchilds;++c)
            {
                list<VarBase> varBaseListTemp = getSubVariables(tr.child(iter, c));
                if (varBaseListTemp.size() > 0) {
                    // merge the list
                    for (list<VarBase>::const_iterator jter=varBaseListTemp.begin();jter!=varBaseListTemp.end();++jter) {
                        if (find(varBaseList.begin(),varBaseList.end(),*jter) == varBaseList.end()) {
                            //cout << *jter << endl;
                            varBaseList.push_back(*jter);
                        }
                    }
                }
            }
            /*
            // go to the T_VARIABLE
            tree<AstNode>::iterator var = iter;
            for(;var->getType() != "T_VARIABLE" && var != tr.end(it) && var != tr.end(); ++var)
                ;
            var = tr.child(var, 0);
            cerr << setw(15) << "expr:- [" << var->getValue() << ',' << it;
            varBaseList.push_back(VarBase(var->getValue(), it));
            cerr << " ]" << endl;
            //iter = var;
            */
        }
        else if (type == "T_VARIABLE")
        {
            //cout << "TVariable" << endl;
            tree<AstNode>::iterator var = iter;
            for(;var->getType() != "text" && var != tr.end(it); ++var)
                ;
            //cerr << setw(15) << "ref :- [" << var->getValue() << ',' << it;
            varBaseList.push_back(VarBase(var->getValue(), it));
            //cerr << " ]" << endl;
            iter = var;
        }
    }
    //cerr << "end:- getSubVars" << endl;
    return varBaseList;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Ast& Ast::operator=

(

const Ast &

ast

)

[inline]

Definition at line 202 of file AstContainer.h.

References assign, classes, equivalences, functions, ref, root, tr, and variables.

                                   {
        if (this != &ast) {
            tr = ast.tr;
            root = ast.root;
            functions = ast.functions;
            variables = ast.variables;
            classes   = ast.classes;
            equivalences = ast.equivalences;
            assign = ast.assign;
            ref = ast.ref;
        }
        return *this;   
    }

tree<AstNode>* Ast::getTreePtr

(

)

[inline]

Definition at line 217 of file AstContainer.h.

References tr.

Referenced by applyModification().

{ return (&tr); }

Here is the caller graph for this function:

const tree<AstNode>* Ast::getTreeConstPtr

(

)

const [inline]

Definition at line 218 of file AstContainer.h.

References tr.

Referenced by ControlFlow::operator()(), NumberSunkDiffuseInputs::operator()(), NumberDiffuseInputs::operator()(), and NumberInput::operator()().

{ return (const tree<AstNode>*)(&tr); }

Here is the caller graph for this function:

std::map<std::string, BoxedFunction> Ast::getBoxedFunctions

(

)

const [inline]

Definition at line 220 of file AstContainer.h.

References boxedFunction.

Referenced by NumberSunkDiffuseInputs::operator()(), NumberResources::operator()(), and NumberSinks::operator()().

                                                                      {
        return boxedFunction;
    }

Here is the caller graph for this function:

FunctionMapping Ast::getMappedFunctions

(

)

const [inline]

Definition at line 223 of file AstContainer.h.

References fctmap.

                                                      {
        return fctmap;
    }

std::list<std::string> Ast::getVariableNames

(

)

const [inline]

Get names informations.

Definition at line 227 of file AstContainer.h.

References variables.

                                                       {
        // extract the keys of the map 'variables'
        std::list<std::string> ret;
        for(MapVariables::const_iterator iter = variables.begin(); iter != variables.end(); ++iter)
            ret.push_back(iter->first);
        return ret;
    }

std::list<std::string> Ast::getFunctionNames

(

)

const [inline]

Definition at line 234 of file AstContainer.h.

References functions.

                                                       {
        std::list<std::string> ret;
        for(MapFunctions::const_iterator iter = functions.begin(); iter != functions.end(); ++iter)
            ret.push_back(iter->first);
        return ret;
    }

std::list<std::string> Ast::getClassNames

(

)

const [inline]

Definition at line 240 of file AstContainer.h.

References classes.

                                                    {
        std::list<std::string> ret;
        for(MapClasses::const_iterator iter = classes.begin(); iter != classes.end(); ++iter)
            ret.push_back(iter->first);
        return ret;
    }

Ast Ast::skeleton

(

)

const

Definition at line 803 of file AstContainer.cpp.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::end(), is_skeleton_node(), tree< T, tree_node_allocator >::parent(), ref, tree< T, tree_node_allocator >::reparent(), and tr.

{
    Ast temp(*this);
    temp.ref = const_cast<Ast *>(this);
    for (tree<AstNode>::iterator iter=temp.tr.begin(); iter!=temp.tr.end();++iter)
    {
        if (!temp.is_skeleton_node(iter)) {
            // just delete it with reparent
            temp.tr.reparent(temp.tr.parent(iter), iter);
        }
    }
    return temp;    
}

Here is the call graph for this function:

void Ast::trace

(

const std::string &

varName

)

const

Definition at line 767 of file AstContainer.cpp.

References assign, tree< T, tree_node_allocator >::begin(), detectFunction(), tree< T, tree_node_allocator >::parent(), print_current_list(), tr, and variables.

{
    // Find that variables
    AstVarBaseList obsVars, totalVars;
    MapVariables::const_iterator pos=variables.find(varName);
    if (pos != variables.end())
        obsVars = pos->second;
    // check with the assignments to see whether we should look for other variables
    totalVars = obsVars;
    for (MapAssignments::const_iterator iter=assign.begin();iter!=assign.end();++iter) 
    {
        for (AstVarBaseList::iterator jter=totalVars.begin();jter!=totalVars.end();++jter)
        {
            //cerr << "What about?" << iter->second << " , " << *jter << endl;
            if (iter->second.name == jter->name) {
                if (find(totalVars.begin(), totalVars.end(), iter->first) == totalVars.end())
                    totalVars.push_back(iter->first);               
            }
        }
    }
    print_current_list(totalVars);
    // For each variable in the domain, look for the functions, calls etc.
    for (AstVarBaseList::iterator iter=totalVars.begin(); iter!=totalVars.end();++iter) {
        cerr << *iter << endl;
        // take this variable and rewind it!
        tree<AstNode>::iterator nter = iter->position;
        do {
            nter = tr.parent(nter);
            // Check for functions
            if (detectFunction(nter)) {
                cerr << nter << endl;
            }
        } while (nter != tr.begin());           
    }
}

Here is the call graph for this function:

void Ast::apply

(

Obfuscator *

obs

)

Definition at line 66 of file AstContainer.cpp.

References classes, functions, tr, and variables.

Referenced by main().

                               {
    obs->operator()(tr, &classes, &variables, &functions);
}

Here is the caller graph for this function:

StringBuffer Ast::convert

(

Translation *

obs

)

Definition at line 70 of file AstContainer.cpp.

References assign, classes, clearInfo(), equivalences, fillAstInformation(), functions, tr, and variables.

Referenced by main().

                                          {
    clearInfo();
    fillAstInformation();
    return obs->operator()(tr, &classes, &variables, &functions, &assign, &equivalences);
}

Here is the call graph for this function:

Here is the caller graph for this function:

MetricResult Ast::compute

(

Metric *

metric

)

const

Definition at line 77 of file AstContainer.cpp.

References assign, classes, equivalences, functions, tr, and variables.

Referenced by computeMetrics().

{
    return metric->operator()(tr, &classes, &variables, &functions, &assign, &equivalences);
}

Here is the caller graph for this function:

void Ast::printInfo

(

std::ostream &

stream

)

const

Referenced by main().

Here is the caller graph for this function:

---

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	stream,
		const Ast &	ast
	)			[friend]

void exportXML	(	const Ast &	ast,
		const std::string &	xmlName
	)			[friend]

---

Field Documentation

tree<AstNode> Ast::tr [protected]

Store the tree.

Definition at line 124 of file AstContainer.h.

Referenced by apply(), compute(), convert(), detectAssignment(), exportXML(), fillAstInformation(), functionBoxing(), functionMapping(), getLeftVariable(), getRightVariables(), getSimpleVariable(), getSubVariables(), getTreeConstPtr(), getTreePtr(), is_skeleton_node(), nbNestedVariables(), operator<<(), operator=(), skeleton(), sourceBoxing(), trace(), and walk().

tree<AstNode>::iterator Ast::root [protected]

Iterator to the root of the tree.

Definition at line 126 of file AstContainer.h.

Referenced by operator=().

MapFunctions Ast::functions [protected]

Function name to tree iterator.

Definition at line 128 of file AstContainer.h.

Referenced by apply(), clearInfo(), compute(), convert(), fillAstInformation(), getFunctionNames(), and operator=().

MapVariables Ast::variables [protected]

Variable name to list of variable (VarBase) which depends on the context of the variable.

Definition at line 130 of file AstContainer.h.

Referenced by apply(), clearInfo(), compute(), convert(), fillAstInformation(), getVariableNames(), operator=(), and trace().

MapClasses Ast::classes [protected]

Class name to tree iterator.

Definition at line 132 of file AstContainer.h.

Referenced by apply(), clearInfo(), compute(), convert(), fillAstInformation(), getClassNames(), and operator=().

MapAssignments Ast::assign [protected]

Relations within variables (contexted).

Definition at line 134 of file AstContainer.h.

Referenced by compute(), convert(), fillAstInformation(), operator=(), and trace().

MapVarEquivalent Ast::equivalences [protected]

For the assignments, I need an equivalence between some variables $a = foo($b,$c,$d) with foo as a black box then, the variables b,c,d are equivalent given that $a variable

Definition at line 137 of file AstContainer.h.

Referenced by compute(), convert(), fillAstInformation(), getRightVariables(), and operator=().

std::map<std::string, BoxedFunction> Ast::boxedFunction [protected]

For one function, list of what function is used as input and what is used as output.

Definition at line 139 of file AstContainer.h.

Referenced by functionBoxing(), and getBoxedFunctions().

FunctionMapping Ast::fctmap [protected]

Function to list of function used in.

Definition at line 141 of file AstContainer.h.

Referenced by functionMapping(), and getMappedFunctions().

Ast* Ast::ref [protected]

Reference to another tree, used for in-skeleton transformation.

Definition at line 143 of file AstContainer.h.

Referenced by Ast(), operator=(), and skeleton().

BoxedFunction Ast::boxedSource [protected]

Do a boxing of the current source code, this is helpful for non function based code (php,asp, etc.).

Definition at line 145 of file AstContainer.h.

Referenced by sourceBoxing().

---

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

• php-oracle/AstContainer.h
• php-oracle/AstContainer.cpp

---