void ast_printer::visitFunctionNode( FunctionNode* node ) {
if(node->name() == "<top>") {
indent_ = -1;
node->body()->visit(this);
return;
}
stream_ << endl;
stream_ << get_indent_line() << "function " << typeToName(node->returnType()) << " " << node->name() << "(";
for (unsigned int j = 0; j < node->parametersNumber(); ++j) {
if (j > 0) stream_ << ", ";
stream_ << typeToName(node->parameterType(j)) << " " << node->parameterName(j);
}
stream_ << ") ";
if (node->body()->nodes() > 0 && node->body()->nodeAt(0)->isNativeCallNode()) {
node->body()->nodeAt(0)->visit(this);
} else {
stream_ << "{" << endl;
node->body()->visit(this);
stream_ << "}" << endl;
needSemicolon = false;
}
}
void castImpl(VarType from, VarType to, Bytecode* bc, AstNode* node) {
if (from == VT_DOUBLE && to == VT_INT) {
bc->addInsn(BC_D2I);
} else if (from == VT_INT && to == VT_DOUBLE) {
bc->addInsn(BC_I2D);
} else if (from != to) {
throw TranslationException(node, "Illegal type: expected -- %s, actual -- %s",
typeToName(to), typeToName(from));
}
}
virtual void visitFunctionNode(FunctionNode *node)
{
if (node->name() != AstFunction::top_name) {
out << "function " << typeToName(node->returnType()) << " " << node->name() << "(";
for (uint32_t i = 0; i < node->parametersNumber(); i++) {
out << typeToName(node->parameterType(i)) << " " << node->parameterName(i);
if (i + 1 < node->parametersNumber()) {
out << ", ";
}
}
out << ") ";
}
node->body()->visit(this);
}
void Printer::printBlockContents(BlockNode* node) {
// functions delcarations
Scope::FunctionIterator funIt(node->scope());
while (funIt.hasNext()) {
funIt.next()->node()->visit(this);
out << '\n';
}
// variables declarations
Scope::VarIterator varIt(node->scope());
while (varIt.hasNext()) {
AstVar* var = varIt.next();
out << typeToName(var->type())
<< " " << var->name() << ";\n";
}
// nodes
for (size_t i = 0; i < node->nodes(); ++i) {
AstNode* subNode = node->nodeAt(i);
subNode->visit(this);
if (!subNode->isIfNode() &&
!subNode->isWhileNode() &&
!subNode->isForNode()) {
out << ';';
}
out << '\n';
}
}
void ast_printer::visitBlockNode( BlockNode* node ) {
//Border border("blockNode", stream_);
++indent_;
Scope::VarIterator var_iter(node->scope());
bool hasVarDeclaration = var_iter.hasNext();
while(var_iter.hasNext()) {
AstVar const * var = var_iter.next();
stream_ << get_indent_line() << typeToName(var->type()) << " " << var->name() <<";" << endl;
}
if(hasVarDeclaration)
stream_ << endl;
Scope::FunctionIterator func(node->scope());
while(func.hasNext()) func.next()->node()->visit(this);
for (uint32_t i = 0; i < node->nodes(); ++i)
{
stream_ << get_indent_line();
node->nodeAt(i)->visit(this);
if (needSemicolon) {
stream_ << ";";
}
stream_ << endl;
needSemicolon = true;
}
--indent_;
}
void SourceByASTPrinter::visitFunctionNode(FunctionNode *node){
cout<<"function "<<typeToName(node->returnType())<<" "<< node->name()<<"(";
int paramNumber = node->parametersNumber();
for (int i = 0; i < paramNumber; ++i) {
cout<<typeToName(node->parameterType(i))<<" "<<node->parameterName(i);
if(i < paramNumber - 1) cout<<",";
}
cout<<")";
if (node->body()->nodeAt(0)->isNativeCallNode()) {
node->body()->nodeAt(0)->visit(this);
cout<< std::endl;
} else {
node->body()->visit(this);
}
}
void ASTAnalyzer::visitFunctionNode(FunctionNode* node) {
output << "function " << typeToName(node->returnType()) << ' ' << node->name();
output << '(';
for (size_t i = 0; i < node->parametersNumber(); ++i) {
output << typeToName(node->parameterType(i)) << ' ' << node->parameterName(i);
if (i != node->parametersNumber() - 1) {
output << ", ";
}
}
output << ')';
if (node->body()->nodeAt(0)->isNativeCallNode()) {
node->body()->nodeAt(0)->visit(this);
} else {
node->body()->visit(this);
}
}
void PrettyPrinter::visitFunctionNode(FunctionNode *node)
{
m_out << "function " << typeToName(node->returnType())
<< " " << node->name() << "(";
for (uint32_t i = 0; i != node->parametersNumber(); ++i)
{
m_out << typeToName(node->parameterType(i)) << " "
<< node->parameterName(i);
if (i != node->parametersNumber() - 1) m_out << ", ";
}
m_out << ") ";
if (node->body()->nodes() && node->body()->nodeAt(0)->isNativeCallNode())
node->body()->nodeAt(0)->visit(this);
else
node->body()->visit(this);
m_out << std::endl;
}
void printVars(Scope *scope)
{
Scope::VarIterator iter(scope);
while (iter.hasNext()) {
AstVar *astVar = iter.next();
out << typeToName(astVar->type()) << " " << astVar->name() << ";" << endl;
}
}
virtual void visitFunctionNode(FunctionNode * node) {
if (node->name() != AstFunction::top_name) {
addIndent();
out<< "function ";
out<< typeToName(node->returnType())<< " ";
out<< node->name()<< "(";
for (size_t i = 0; i < node->parametersNumber(); ++i) {
out<< typeToName(node->parameterType(i));
if (i + 1 < node->parametersNumber()) {
out<< ", ";
}
}
out<< ") ";
}
node->body()->visit(this);
}
void variableDeclaration(Scope* scope) {
Scope::VarIterator iter(scope);
while (iter.hasNext()) {
AstVar* x = iter.next();
indent();
_output << typeToName(x->type()) << " "
<< x->name() << ";"
<< endl;
}
}
void BytecodeTranslatorVisitor::tryCast(VarType to) {
static Instruction castTable[VAR_TYPES_NUMBER][VAR_TYPES_NUMBER] = {BC_INVALID};
castTable[VT_INT][VT_DOUBLE] = BC_I2D;
castTable[VT_DOUBLE][VT_INT] = BC_D2I;
VarType from = topType();
if (from == to) return;
Instruction cast = castTable[from][to];
if (!cast)
ERROR(string("Cast error from ") + typeToName(from) +
" to " + typeToName(to));
warningIf(cast == BC_D2I, "Casting double to int. I warned you!");
EMIT(cast);
popType();
pushType(to);
}
void Code::disassemble(ostream& out, FunctionFilter* filter) {
for (uint32_t i = 0; i < _functions.size(); i++) {
TranslatedFunction* function = _functions[i];
bool match = filter ? filter->matches(function) : true;
if (match) {
out << "function [" << function->id() << "] "
<< typeToName(function->returnType())
<< " " << function->name() << "(";
for (uint32_t i = 0; i < function->parametersNumber(); i++) {
out << typeToName(function->parameterType(i));
if (i + 1 < function->parametersNumber()) {
out << ", ";
}
}
out << ")" << endl;
function->disassemble(out);
}
}
}
void ASTAnalyzer::printScopeDeclarations (Scope* scope) {
Scope::FunctionIterator fuctions(scope);
while (fuctions.hasNext()) {
fuctions.next()->node()->visit(this);
}
Scope::VarIterator vars(scope);
while (vars.hasNext()) {
AstVar* var = vars.next();
output << typeToName(var->type()) << " " << var->name() << ";\n";
}
}
virtual void visitFunctionNode(FunctionNode* node) {
if (node->name() != AstFunction::top_name) {
_output << "function "
<< typeToName(node->returnType()) << " "
<< node->name()
<< "(";
for (uint32_t i = 0; i < node->parametersNumber(); i++) {
if (i != 0)
_output << ", ";
_output << typeToName(node->parameterType(i))
<< " " << node->parameterName(i);
}
_output << ")";
}
if (node->body()->nodeAt(0)->isNativeCallNode())
visitNativeCallNode(node->body()->nodeAt(0)->asNativeCallNode());
else {
node->body()->visit(this);
_output << endl;
}
}
Prerequisite::~Prerequisite()
{
if (DEBUG)
qDebug("Prerequisite::~Prerequisite(): name %s, type %d (%s), message %s",
qPrintable(_name), _type, qPrintable(typeToName(_type)),
qPrintable(_message));
if (_dependency)
{
delete _dependency;
_dependency = 0;
}
}
void Printer::visitFunctionNode(FunctionNode* node) {
out << "function " << typeToName(node->returnType())
<< " " << node->name() << "(";
// parameters
for (size_t i = 0; i < node->parametersNumber(); ++i) {
out << typeToName(node->parameterType(i)) << " "
<< node->parameterName(i);
if (i != node->parametersNumber() - 1)
out << ", ";
}
out << ") ";
// body
if (node->body()->nodeAt(0)->isNativeCallNode()) {
node->body()->nodeAt(0)->visit(this);
out << "\n";
} else {
node->body()->visit(this);
}
}
void AstPrinter::printFunction(AstFunction *function) {
print("function ");
print(typeToName(function->returnType()));
print(" ");
print(function->name());
print("(");
for(uint32_t i = 0; i < function->parametersNumber(); i++) {
if (i != 0)
print(", ");
print(typeToName(function->parameterType(i)));
print(" ");
print(function->parameterName(i));
}
print(") ");
BlockNode *block = function->node()->body();
if (block->nodeAt(0) && block->nodeAt(0)->isNativeCallNode()) {
block->nodeAt(0)->visit(this);
print("\n");
} else {
function->node()->body()->visit(this);
}
}
virtual void visitFunctionNode(FunctionNode* node) {
os << "function";
os << " " << typeToName(node->returnType()) << " ";
os << node->name();
os << "(";
for(uint32_t i = 0; i < node->parametersNumber(); ++i) {
if(i != 0) {
os << ", ";
}
os << typeToName(node->parameterType(i)) << " ";
os << node->parameterName(i);
}
os << ") ";
if(node->body()->nodes() > 0 && node->body()->nodeAt(0)->isNativeCallNode()) {
node->body()->nodeAt(0)->visit(this);
} else {
node->body()->visit(this);
}
}
void visitScope(Scope * scope) {
Scope::VarIterator varIter(scope);
while (varIter.hasNext()) {
addIndent();
AstVar * var = varIter.next();
out<< typeToName(var->type())<< " "<< var->name()<< ";"<< endl;
}
Scope::FunctionIterator funcIter(scope);
while (funcIter.hasNext()) {
funcIter.next()->node()->visit(this);
}
}
QDomElement Prerequisite::createElement(QDomDocument & doc)
{
QDomElement elem = doc.createElement("prerequisite");
QDomElement elemThis;
elem.setAttribute("name", _name);
elem.setAttribute("type", typeToName(_type));
switch (_type)
{
case Query:
elemThis = doc.createElement("query");
elemThis.appendChild(doc.createTextNode(_query));
elem.appendChild(elemThis);
break;
case License:
break;
case Dependency:
elemThis = doc.createElement("dependson");
elemThis.setAttribute("name", _dependency->name());
if (! _dependency->developer().isEmpty())
elemThis.setAttribute("developer", _dependency->developer());
if (! _dependency->version().isEmpty())
elemThis.setAttribute("version", _dependency->version());
break;
default:
break;
}
if (! _message.isEmpty())
{
elemThis = doc.createElement("message");
elemThis.appendChild(doc.createTextNode(_message));
elem.appendChild(elemThis);
}
QList<PrerequisiteProvider>::iterator it = _providers.begin();
for(; it != _providers.end(); ++it)
{
if((*it).isValid())
elem.appendChild((*it).createElement(doc));
}
return elem;
}
void PrettyPrinter::printScope(Scope *scope)
{
std::string indentation(m_indent, ' ');
//why constructor doesn't get const pointer?
Scope::VarIterator ivar(scope);
//Java-style iterators in C++?
while (ivar.hasNext())
{
AstVar *var = ivar.next();
m_out << indentation << typeToName(var->type()) << " "
<< var->name() << ";" << std::endl;
}
Scope::FunctionIterator ifun(scope);
while (ifun.hasNext()) ifun.next()->node()->visit(this);
}
void AstPrinter::printScopeDeclarations(Scope* scope) {
Scope::VarIterator varIterator(scope);
while(varIterator.hasNext()) {
AstVar *var = varIterator.next();
print(typeToName(var->type()));
print(" ");
print(var->name());
print(";\n");
}
Scope::FunctionIterator funcIterator(scope);
while(funcIterator.hasNext()) {
AstFunction *func = funcIterator.next();
printFunction(func);
}
print("\n");
}
void BytecodeVisitor::visitForNode(ForNode *node) {
LOG_Visitor("visitForNode");
VariableInContextDescriptor variableDescriptor = context->getVariableDescriptor(node->var()->name());
BinaryOpNode *innerExpression = (BinaryOpNode *) node->inExpr();
if (innerExpression->kind() != tRANGE) {
throw TranslationError(string("Incorrect binary operation in for-expression. Exptected: RANGE, got: ")
+ tokenStr(innerExpression->kind()), node->position());
}
if (node->var()->type() != VT_INT) {
throw TranslationError(string("Incorrect type of for-variable. Exptected: INT, got: ")
+ typeToName(node->var()->type()), node->position());
}
innerExpression->left()->visit(this);
bc()->addInsn(BC_ILOADM1);
bc()->addInsn(BC_IADD);
storeVariable(variableDescriptor, innerExpression);
Label begin(bc());
Label end(bc());
{
bc()->bind(begin);
loadVariable(variableDescriptor, innerExpression);
bc()->addInsn(BC_ILOAD1);
bc()->addInsn(BC_IADD);
storeVariable(variableDescriptor, innerExpression);
//condition
innerExpression->right()->visit(this);
loadVariable(variableDescriptor, innerExpression);
bc()->addInsn(BC_SWAP);
// goto end if greater
bc()->addBranch(BC_IFICMPG, end);
node->body()->visit(this);
bc()->addBranch(BC_JA, begin);
}
bc()->bind(end);
}
void printScope(Scope * scope) {
Scope::VarIterator varIt(scope);
while(varIt.hasNext()) {
AstVar* var = varIt.next();
os << indent();
os << typeToName(var->type()) << " " << var->name() << ";" << endl;
}
Scope::FunctionIterator funcIt(scope);
while(funcIt.hasNext()) {
AstFunction* func = funcIt.next();
os << indent();
func->node()->visit(this);
}
}
void SourceByASTPrinter::visitBlockNodeWithoutBraces(BlockNode *node){
Scope::VarIterator vIt(node->scope());
while(vIt.hasNext()) {
AstVar *var = vIt.next();
cout<<typeToName(var->type())<<" "<< var->name()<< ";"<<endl;
}
Scope::FunctionIterator fIt(node->scope());
while(fIt.hasNext()) {
fIt.next()->node()->visit(this);
}
int nodesNumber = node->nodes();
for (int i = 0; i < nodesNumber; ++i) {
AstNode *nodeAt = node->nodeAt(i);
nodeAt->visit(this);
if(!nodeAt->isForNode() && !nodeAt->isIfNode() && !nodeAt->isWhileNode())
cout<<";"<<endl;
}
}
Prerequisite::Prerequisite(const QDomElement & elem)
{
_dependency = 0;
_message = QString::null;
_name = elem.attribute("name");
_query = QString::null;
_type = nameToType(elem.attribute("type"));
QDomNodeList nList = elem.childNodes();
for(int n = 0; n < nList.count(); ++n)
{
QDomElement elemThis = nList.item(n).toElement();
if(elemThis.tagName() == "query")
_query = elemThis.text();
else if(elemThis.tagName() == "message")
_message = elemThis.text();
else if(elemThis.tagName() == "providedby")
{
PrerequisiteProvider provider(elemThis);
if(provider.isValid())
_providers.append(provider);
}
else if (elemThis.tagName() == "dependson")
_dependency = new DependsOn(elemThis.attribute("name"),
elemThis.attribute("version"),
elemThis.attribute("developer"));
else
{
// ERROR?
}
}
if (DEBUG)
qDebug("Prerequisite(QDomElement&): name %s, type %d (%s), message %s, "
"dependency %p (%s %s %s), query %s",
qPrintable(_name), _type, qPrintable(typeToName(_type)),
qPrintable(_message), _dependency,
qPrintable(_dependency ? _dependency->name() : QString()),
qPrintable(_dependency ? _dependency->version() : QString()),
qPrintable(_dependency ? _dependency->developer(): QString()),
qPrintable(_query));
}
void BytecodeTranslatorVisitor::ensureTopType(VarType expected) const {
if (topType() != expected)
ERROR(string("Expected ") + typeToName(expected));
}
void BytecodeTranslatorVisitor::popType(VarType expected) {
if (topType() != expected)
ERROR(string("Expected: ") + typeToName(expected) +
", got: " + typeToName(topType()));
popType();
}
void BytecodeVisitor::visitUnaryOpNode(UnaryOpNode *node) {
LOG_Visitor("visitUnaryOpNode");
node->operand()->visit(this);
switch (node->kind()) {
case tSUB: {
if (!isNumericType(topOfStackType)) {
throw TranslationError(string("Incorrect type for SUB inside unary-node: ") + typeToName(topOfStackType), node->position());
}
bc()->addInsn(topOfStackType == VT_DOUBLE ? BC_DNEG : BC_INEG);
break;
}
case tNOT: {
if (topOfStackType != VT_INT && topOfStackType != VT_STRING) {
throw TranslationError(string("Incorrect type for NOT inside unary-node: ") + typeToName(topOfStackType), node->position());
}
cast(VT_INT, node, "cast in unary op node");
bc()->addInsn(BC_ILOAD0);
bc()->addInsn(BC_ICMP);
break;
}
default:
throw TranslationError(string("Unknown unary operation token: ") + tokenStr(node->kind()), node->position());
}
}
