void AST_t::replace(AST_t ast)
{
if (ast._ast == NULL)
{
internal_error("Trying to replace a tree with an empty tree", 0);
}
if (this->_ast == NULL)
{
internal_error("Trying to replace an empty tree with another tree", 0);
}
if (ASTType(ast._ast) == AST_NODE_LIST)
{
// If the replacement is a list but the original is not, let's check two cases
// maybe this list is a one-element list or not.
if (ASTType(this->_ast) != AST_NODE_LIST)
{
// If it is a one element list
if (ASTSon0(ast._ast) == NULL)
{
// then replace the whole thing with the list information
AST_t repl_tree(ASTSon1(ast._ast));
replace_with(repl_tree);
}
// If this is not a one-element list then try to replace using
// a typical replace_in_list but this may fail sometimes
// because we'll look for the first enclosing list
else
{
// Maybe we should yield a message here
// std::cerr << "Warning: Replacing a non-list tree at '"
// << this->get_locus()
// << "' with a list tree of more than one element" << std::endl;
replace_in_list(ast);
}
}
// If both are lists is easy
else
{
replace_in_list(ast);
}
}
// If the thing being replaced is a list, but the replacement
// is not, then convert the latter into a list
else if (ASTType(_ast) == AST_NODE_LIST
&& ASTType(_ast) != AST_NODE_LIST)
{
// Create a single element list
AST single(ASTListLeaf(ast._ast));
replace_in_list(single);
}
// Otherwise replace directly. Neither the replaced nor the replacement
// are lists in this case.
else
{
replace_with(ast);
}
}
AST_t ASTIterator::item()
{
if (_current == NULL)
{
return AST();
}
else
{
return AST(ASTSon1(_current));
}
}
ObjectList<AST_t> AST_t::children() const
{
ObjectList<AST_t> result;
result.append(AST_t(ASTSon0(_ast)));
result.append(AST_t(ASTSon1(_ast)));
result.append(AST_t(ASTSon2(_ast)));
result.append(AST_t(ASTSon3(_ast)));
return result;
}
AST AST_t::get_list_of_extensible_block(AST node)
{
switch ((int)ASTType(node))
{
case AST_COMPOUND_STATEMENT :
{
// This can be null
return ASTSon0(node);
break;
}
case AST_CLASS_SPECIFIER :
{
// This can be null
return ASTSon1(node);
break;
}
case AST_TRANSLATION_UNIT :
{
// This can be null
return ASTSon0(node);
break;
}
case AST_NAMESPACE_DEFINITION :
{
// This can be null
return ASTSon1(node);
break;
}
case AST_NODE_LIST :
{
return node;
break;
}
}
return NULL;
}
static void ast_dump_html_rec(AST a, FILE* f, const char* root_id, int id_node)
{
if (a == NULL)
return;
char current_id_node[64];
memset(current_id_node, 0, sizeof(current_id_node));
snprintf(current_id_node, 63, "%s.%d", root_id, id_node);
current_id_node[63] = '\0';
fprintf(f, "<div id=\"%s\" class=\"node\" style=\"display: none;\">\n"
"<div class=\"node_info\">"
"<span id=\"%s.handle\" class=\"handle\">+</span>"
"<span id=\"%s.kind\" class=\"node_kind\">%s</span>"
"<span id=\"%s.locus\" class=\"node_locus\">%s</span>",
current_id_node, // div
current_id_node, // handle
current_id_node, ast_node_type_name(ASTType(a)),
current_id_node, mini_strip_html(ast_location(a))
); // kind
if (ASTText(a) != NULL)
{
fprintf(f,
"<span id=\"%s.text\" class=\"node_text\">%s</span>",
current_id_node,
mini_strip_html(ASTText(a)));
}
fprintf(f, "</div>\n");
if (ASTType(a) == AST_NODE_LIST)
{
fprintf(f, "%s", "<div class=\"node_list\">");
int k = 0;
AST list = a, iter;
for_each_element(list, iter)
{
AST element = ASTSon1(iter);
ast_dump_html_rec(element, f, current_id_node, k);
k++;
}
static void compute_nodecl_parse_c_type(AST type_id, const decl_context_t* decl_context, nodecl_t* nodecl_output)
{
nodecl_t nodecl_out_type = nodecl_null();
type_t* type_info = NULL;
gather_decl_spec_t gather_info;
memset(&gather_info, 0, sizeof(gather_info));
AST type_specifier_seq = ASTSon0(type_id);
AST abstract_decl = ASTSon1(type_id);
build_scope_decl_specifier_seq(type_specifier_seq, &gather_info, &type_info,
decl_context, &nodecl_out_type);
type_t* declarator_type = type_info;
compute_declarator_type(abstract_decl, &gather_info, type_info,
&declarator_type, decl_context, &nodecl_out_type);
*nodecl_output = nodecl_make_type(declarator_type, ast_get_locus(type_id));
}
static void fortran_simplify_tree_stmt(AST a, AST *out)
{
// FIXME: Think ways of improving this
switch (ASTType(a))
{
case AST_ALLOCATE_STATEMENT:
case AST_ARITHMETIC_IF_STATEMENT:
case AST_ASSIGNED_GOTO_STATEMENT:
case AST_BREAK_STATEMENT:
case AST_CLOSE_STATEMENT:
case AST_COMPUTED_GOTO_STATEMENT:
case AST_CONTINUE_STATEMENT:
case AST_DEALLOCATE_STATEMENT:
case AST_EMPTY_STATEMENT:
case AST_EXPRESSION_STATEMENT:
case AST_GOTO_STATEMENT:
case AST_IO_STATEMENT:
case AST_LABEL_ASSIGN_STATEMENT:
case AST_NULLIFY_STATEMENT:
case AST_OPEN_STATEMENT:
case AST_PRINT_STATEMENT:
case AST_READ_STATEMENT:
case AST_RETURN_STATEMENT:
case AST_STOP_STATEMENT:
case AST_PAUSE_STATEMENT:
case AST_WRITE_STATEMENT:
case AST_PRAGMA_CUSTOM_DIRECTIVE:
{
// Simple copy
*out = ast_copy_with_scope_link(a, CURRENT_COMPILED_FILE->scope_link);
break;
}
case AST_BLOCK_CONSTRUCT:
{
AST block = ASTSon1(a);
AST new_block = NULL;
AST it;
for_each_element(block, it)
{
AST stmt = ASTSon1(it);
AST new_stmt = NULL;
fortran_simplify_tree_stmt(stmt, &new_stmt);
if (new_stmt != NULL)
{
new_block = ASTList(new_block, new_stmt);
}
}
*out = ASTMake1(AST_COMPOUND_STATEMENT, new_block, ASTFileName(a), ASTLine(a), NULL);
break;
}
case AST_COMPOUND_STATEMENT:
{
AST list = ASTSon0(a);
AST new_list = NULL;
AST it;
for_each_element(list, it)
{
AST stmt = ASTSon1(it);
AST new_stmt = NULL;
fortran_simplify_tree_stmt(stmt, &new_stmt);
if (new_stmt != NULL)
{
new_list = ASTList(new_list, new_stmt);
}
}
*out = ASTMake1(AST_COMPOUND_STATEMENT, new_list, ASTFileName(a), ASTLine(a), NULL);
break;
}
