Translation.cpp File Reference

#include "AstNode.h"
#include "tree.h"
#include "AstContainer.h"
#include "Translation.h"
#include <vector>
#include <list>
#include <string>
#include <map>
#include <fstream>

Include dependency graph for Translation.cpp:

Go to the source code of this file.

Defines
#define	CPPHEADERSIZE   2
Functions
string	cppBufferize (const string &__in)
string	indent (unsigned nbIndent)
std::ostream &	operator<< (std::ostream &stream, const StringBuffer &b)
string	varname (const string &phpname, bool correctQuote=false)
string	getNodeValue (const tree< AstNode >::iterator &start, const string &type, const tree< AstNode > &tr)
tree< AstNode >::iterator	getNodeIter (const tree< AstNode >::iterator &start, const string &type, const tree< AstNode > &tr)
bool	functionReturnValue (const tree< AstNode >::iterator &start, const tree< AstNode > &tr)
bool	isAChildrenOf (const tree< AstNode >::iterator &start, const string &type, const tree< AstNode > &tr)
bool	classAssignement (const tree< AstNode >::iterator &start, const tree< AstNode > &t)
string	className (const tree< AstNode >::iterator &start, const tree< AstNode > &t)
string	subVarName (const tree< AstNode >::iterator &it, const tree< AstNode > &tr)
void	writeSiblingsCPP (const tree< AstNode > &t, const tree< AstNode >::iterator &iRoot, StringBuffer &buf, bool inString=false, bool inFct=false, bool inMain=false, bool inClass=false, bool inFctCall=false)
void	writeCPP (const tree< AstNode > &tr, StringBuffer &buf)
void	addFunctionCpp (const tree< AstNode >::iterator &start, const tree< AstNode > &tr, StringBuffer &buffer, bool fromClass=false, const string cname="")
void	addClassCpp (const tree< AstNode >::iterator &start, const tree< AstNode > &tr, StringBuffer &buffer)
Variables
list< string >	classVarNames
const string	cppheader [2]

---

Define Documentation

#define CPPHEADERSIZE   2

Definition at line 33 of file Translation.cpp.

Referenced by Ast2Cpp::operator()().

---

Function Documentation

void addClassCpp	(	const tree< AstNode >::iterator &	start,
		const tree< AstNode > &	tr,
		StringBuffer &	buffer
	)

Definition at line 394 of file Translation.cpp.

References addFunctionCpp(), tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::child(), tree< T, tree_node_allocator >::end(), getNodeIter(), getNodeValue(), tree< T, tree_node_allocator >::number_of_children(), and utils::start_with().

Referenced by Ast2Cpp::operator()().

{
    // Check for the class name
    string cname, extend="";
    cname = getNodeValue(start, "T_STRING", tr);
    tree<AstNode>::iterator extends = getNodeIter(start, "extends_from", tr);
    
    buffer << "class " + cname;

    if (tr.number_of_children(extends) > 0) {
        for (tree<AstNode>::iterator iter=tr.begin(extends);iter!=tr.end(extends);++iter) {
            if (iter->getType() == "T_STRING") {
                extend = tr.child(iter, 0)->getValue();
                break;
            }
        }
        buffer << " : public " + extend;
    }
    buffer << "{\n";

    tree<AstNode>::iterator methodList = getNodeIter(start, "class_statement_list", tr);
    // Add the methods in the content

    map<string, tree<AstNode>::iterator> specialFunctions;

    // Check if there is contructor
    for (tree<AstNode>::iterator iter=tr.begin(methodList);iter!=tr.end(methodList);++iter) {
        if (iter->getType() == "class_statement") {
            for (tree<AstNode>::iterator jter=tr.begin(iter);jter!=tr.end(iter);++jter) {
                if (jter->getType() == "T_STRING") {
                    jter = tr.child(jter, 0);
                    if (jter->getType() == "text" && utils::start_with(jter->getValue(), "__")) {
                        // special function
                        specialFunctions.insert(make_pair(jter->getValue(), iter));
                        break;
                    }
                }
            }
        }
    }
    
    // Add the function definitions
    for (tree<AstNode>::iterator iter=tr.begin(methodList);iter!=tr.end(methodList);++iter)
    {
        if (iter->getType() == "class_statement")
        {
            //cout << "One call to method? declaration..." << endl;
            addFunctionCpp(iter, tr, buffer, true, cname);
        }
    }

    if (specialFunctions.find("__construct") == specialFunctions.end()) {
        // write the default constructor
        buffer << ("\n " + cname + "() {}\n");
    }
    if (specialFunctions.find("__destruct") == specialFunctions.end()) {
        // write the default constructor
        buffer << ("\n ~" + cname + "() {}\n");
    }
    buffer << ("\n " + cname + "(const "+ cname + "& ____c) {}\n");
    buffer << "\n};\n";
}

Here is the call graph for this function:

Here is the caller graph for this function:

void addFunctionCpp	(	const tree< AstNode >::iterator &	start,
		const tree< AstNode > &	tr,
		StringBuffer &	buffer,
		bool	fromClass = false,
		const string	cname = ""
	)

Definition at line 336 of file Translation.cpp.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::child(), tree< T, tree_node_allocator >::end(), functionReturnValue(), getNodeIter(), getNodeValue(), tree< T, tree_node_allocator >::number_of_children(), utils::start_with(), varname(), and writeSiblingsCPP().

Referenced by addClassCpp(), and Ast2Cpp::operator()().

{
    string fname;
    vector<string> paramVars;
    bool returnValue = functionReturnValue(start, tr);
    fname = getNodeValue(start, "T_STRING", tr);
    
    if (fromClass)
    {
        if (utils::start_with(fname,"__")) {
            // looks like a constructor, copy etc.
            if (fname == "__construct")
                fname = cname;
            else if (fname == "__destruct")
                fname = "~" + cname;
            else if (fname == "__clone") // I'll do by myself!
                return;
        }
    }

    tree<AstNode>::iterator params = getNodeIter(start, "parameter_list", tr);
    if (tr.number_of_children(params) > 0) {
        // fill paramVars
        for (tree<AstNode>::iterator iter=tr.begin(params);iter!=tr.end(params);++iter) {
            if (iter->getType() == "T_VARIABLE") {
                paramVars.push_back(varname(tr.child(iter, 0)->getValue()));
            }
        }
    }
    string decl = "";
    if (returnValue)
        decl += "PhpObject ";
    else if (fname != cname)
        decl += "void ";
    decl += fname;
    decl += "( ";
    unsigned t = paramVars.size();
    if (t > 0) {
        decl += ("PhpObject& loc_" + paramVars[0]);
        for (unsigned i=1;i<t;i++)
        decl += (", PhpObject& " + paramVars[i]);
    }
    decl += " ) {\n";
    buffer << (decl);
    StringBuffer localFuncContent;
    tree<AstNode>::iterator content;

    content = getNodeIter(start, "inner_statement_list", tr);

    writeSiblingsCPP(tr, content, localFuncContent, false, true);
    for (vector<string>::const_iterator iter=paramVars.begin();iter!=paramVars.end();++iter) {
        localFuncContent.replace(" " + *iter + " ", " loc_" + *iter + " ");
    }
    buffer << localFuncContent;
    buffer << ("}\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool classAssignement	(	const tree< AstNode >::iterator &	start,
		const tree< AstNode > &	t
	)

Definition at line 179 of file Translation.cpp.

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

Referenced by writeSiblingsCPP().

                                                                                  {
    for (tree<AstNode>::iterator iter=t.begin(start);iter!=t.end(start);++iter) {
        if (iter->getType() == "T_NEW") {
            return true;
        }
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

string className	(	const tree< AstNode >::iterator &	start,
		const tree< AstNode > &	t
	)

Definition at line 188 of file Translation.cpp.

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

Referenced by Ast::fillAstInformation(), and writeSiblingsCPP().

                                                                             {
    for (tree<AstNode>::iterator iter=t.begin(start);iter!=t.end(start);++iter) {
        if (iter->getType() == "class_name_reference") {
            for (tree<AstNode>::iterator jter=t.begin(iter);jter!=t.end(iter);++jter) {
                if (jter->getType() == "text") {
                    return jter->getValue();
                }
            }
            return string();
        }
    }
    return string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

string cppBufferize

(

const string &

__in

)

Definition at line 40 of file Translation.cpp.

                                        {
    string buf = "";

    return buf;
}

bool functionReturnValue	(	const tree< AstNode >::iterator &	start,
		const tree< AstNode > &	tr
	)

Definition at line 155 of file Translation.cpp.

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

Referenced by addFunctionCpp().

{
    for (tree<AstNode>::iterator iter=tr.begin(start);iter!=tr.end(start);++iter) {
        if (iter->getType() == "T_RETURN") {
            tree<AstNode>::iterator p = tr.parent(iter);
            if (tr.number_of_children(p) > 2)
                return true;
        }
    }
    return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tree<AstNode>::iterator getNodeIter	(	const tree< AstNode >::iterator &	start,
		const string &	type,
		const tree< AstNode > &	tr
	)

Definition at line 146 of file Translation.cpp.

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

Referenced by addClassCpp(), addFunctionCpp(), and writeSiblingsCPP().

{
    for (tree<AstNode>::iterator iter=tr.begin(start);iter!=tr.end(start);++iter) {
        if (iter->getType() == type)
            return iter;
    }
    return tr.end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

string getNodeValue	(	const tree< AstNode >::iterator &	start,
		const string &	type,
		const tree< AstNode > &	tr
	)

Definition at line 131 of file Translation.cpp.

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

Referenced by addClassCpp(), addFunctionCpp(), and writeSiblingsCPP().

{
    for (tree<AstNode>::iterator iter=tr.begin(start);iter!=tr.end(start);++iter) {
        if (iter->getType() == type) {
            for (;iter->getType() != "text" && iter!=tr.end(start);++iter)
                ;
            if (iter->getType() == "text")
                return iter->getValue();
            else
                return string();
        }
    }
    return string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

string indent

(

unsigned

nbIndent

)

Definition at line 46 of file Translation.cpp.

Referenced by StringBuffer::format().

                                 {
    string r = "";
    for (unsigned i=0;i<nbIndent;i++)
        r += '\t';
    return r;
}

Here is the caller graph for this function:

bool isAChildrenOf	(	const tree< AstNode >::iterator &	start,
		const string &	type,
		const tree< AstNode > &	tr
	)

Definition at line 167 of file Translation.cpp.

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

{
    unsigned nC = tr.number_of_children(start);
    if (nC > 0) {
        for (unsigned i=0;i<nC;i++) {
            if (tr.child(start, i)->getType() == type)
                return true;
        }
    }
    return false;
}

Here is the call graph for this function:

std::ostream& operator<<	(	std::ostream &	stream,
		const StringBuffer &	b
	)

Definition at line 110 of file Translation.cpp.

                                                                  {
    stream << b.buffer << std::endl;
    return stream;
}

string subVarName	(	const tree< AstNode >::iterator &	it,
		const tree< AstNode > &	tr
	)

Definition at line 203 of file Translation.cpp.

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

Referenced by writeSiblingsCPP().

{
    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 (var->getValue());
                }
            }
            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 array->getValue() + "[" + 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 var->getValue();
        }
    }
    // backtrack for: strings, functions, class
    return string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

string varname	(	const string &	phpname,
		bool	correctQuote = false
	)

Definition at line 116 of file Translation.cpp.

Referenced by addFunctionCpp(), Ast2Cpp::operator()(), and writeSiblingsCPP().

                                                                 {
    string name;
    for (string::const_iterator i=phpname.begin();i!=phpname.end();++i) {
        if (*i == '$')
            continue;
        else if (correctQuote and *i == '\'')
            name += '"';
        else
            name += *i;
    }
    return name;
}

Here is the caller graph for this function:

void writeCPP	(	const tree< AstNode > &	tr,
		StringBuffer &	buf
	)

Definition at line 323 of file Translation.cpp.

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

{
    if (tr.empty()) {
        throw length_error("writeCPP - The AST tree is empty");
        return;
    }
    for(tree<AstNode>::sibling_iterator iRoots = tr.begin(); iRoots != tr.end(); iRoots++) {
        writeSiblingsCPP(tr,iRoots,buf);
    }
}

Here is the call graph for this function:

void writeSiblingsCPP	(	const tree< AstNode > &	t,
		const tree< AstNode >::iterator &	iRoot,
		StringBuffer &	buf,
		bool	inString = false,
		bool	inFct = false,
		bool	inMain = false,
		bool	inClass = false,
		bool	inFctCall = false
	)

Definition at line 245 of file Translation.cpp.

References tree< T, tree_node_allocator >::begin(), tree< T, tree_node_allocator >::child(), classAssignement(), className(), classVarNames, tree< T, tree_node_allocator >::empty(), tree< T, tree_node_allocator >::end(), getNodeIter(), getNodeValue(), tree< T, tree_node_allocator >::number_of_children(), tree< T, tree_node_allocator >::parent(), subVarName(), and varname().

Referenced by addFunctionCpp(), Ast2Cpp::operator()(), and writeCPP().

{
    if(t.empty())
        return;
    string type = iRoot->getType();
    if (type == "root") {
        tree<AstNode>::sibling_iterator iChildren = t.begin(iRoot);
        writeSiblingsCPP(t,iChildren,buf,inString,inFct,inMain,inClass,inFctCall);
    }
    else if (t.number_of_children(iRoot) == 0) {
        if (iRoot->getValue().length() > 0) {
            if (iRoot->getValue() == ".") { /* concatenate transformation */  buf << " + "; }
            else if (t.parent(iRoot)->getType() == "T_ENCAPSED_AND_WHITESPACE")
                buf << (varname(iRoot->getValue(), false) + " ");
            else
                buf << (varname(iRoot->getValue(), true) + " ");
        }
    }
    else {
        int siblingNum;
        tree<AstNode>::sibling_iterator iChildren;
        if (type == "T_ECHO" or type == "T_INCLUDE" or type == "T_PRINT") {
            // gotta be a function
            tree<AstNode>::iterator parent = t.parent(iRoot); // go to the parent in order to get all information
            string funcName = getNodeValue(parent, type, t);
            string contentNodeName = "echo_expr_list";
            if (type == "T_INCLUDE" or type == "T_PRINT") {
                contentNodeName = "expr";
            }
            // must be always true, otherwise, the AST is ill-formed
            buf << (funcName + "(");
            writeSiblingsCPP(t,getNodeIter(parent, contentNodeName, t),buf,inString,inFct,inMain,inClass,inFctCall);
            buf << "); ";
        }
        else if (type == "expr_without_variable" && t.number_of_children(iRoot) == 3 
        &&       t.child(iRoot,1)->getType() == "CHAR61"
        &&       classAssignement(t.child(iRoot,2), t)) { // assignement + class + new 
            string cname = className(t.child(iRoot,2), t);
            if (cname.length() > 0) {
                string v = varname(subVarName(t.child(iRoot,0), t));
                buf << cname << "* " << v << " = new " << cname << "()\n";
                classVarNames.push_back(v);
            }
            else {
                for (iChildren = t.begin(iRoot), siblingNum = 0; iChildren != t.end(iRoot); ++iChildren)
                {
                    string subtype = iChildren->getType();
                    if (subtype == "T_ECHO" or subtype == "T_INCLUDE" or subtype == "T_PRINT") {
                        writeSiblingsCPP(t,iChildren,buf,inString,inFct,inMain,inClass,inFctCall);
                        break;
                    }
                    else if (inMain && (subtype == "unticked_function_declaration_statement" ||  subtype == "unticked_class_declaration_statement")) {
                        continue;
                    }
                    else
                        writeSiblingsCPP(t,iChildren,buf,inString,inFct,inMain,inClass,inFctCall);
                }
            }
        }
        else {
            for (iChildren = t.begin(iRoot), siblingNum = 0; iChildren != t.end(iRoot); ++iChildren)
            {
                string subtype = iChildren->getType();
                if (subtype == "T_ECHO" or subtype == "T_INCLUDE" or subtype == "T_PRINT") {
                    writeSiblingsCPP(t,iChildren,buf,inString,inFct,inMain,inClass,inFctCall);
                    break;
                }
                else if (inMain && (subtype == "unticked_function_declaration_statement" ||  subtype == "unticked_class_declaration_statement")) {
                    continue;
                }
                else
                    writeSiblingsCPP(t,iChildren,buf,inString,inFct,inMain,inClass,inFctCall);
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

list<string> classVarNames

Definition at line 30 of file Translation.cpp.

Referenced by Ast2Cpp::operator()(), and writeSiblingsCPP().

const string cppheader[2]

Initial value:

 {
    "#include <iostream>\n",
    "#include \"libphp.h\"\n\n"
}

Definition at line 34 of file Translation.cpp.

Referenced by Ast2Cpp::operator()().

---