void print_rows(TopItem *root, int nmemb, int mask_length)
{
int i;
void (*print_function)(TopItem *);
if (mask_length == 32)
print_function = print_row;
else
print_function = print_row_agg;
print_function(0);
for ( i = 0; i < nmemb; ++i, ++root ) {
print_function(root);
}
}
void print_object (STREAM stream, D instance, BOOL escape_p, int print_depth) {
enum dylan_type_enum type = dylan_type(instance);
switch (type) {
case integer_type:
print_integer(stream, instance, escape_p, print_depth); break;
case character_type:
print_character(stream, instance, escape_p, print_depth); break;
case float_type:
print_float (stream, instance, escape_p, print_depth); break;
case dylan_boolean_type:
print_boolean(stream, instance, escape_p, print_depth); break;
case string_type:
print_string (stream, instance, escape_p, print_depth); break;
case vector_type:
print_vector(stream, instance, escape_p, print_depth); break;
case pair_type:
print_pair(stream, instance, escape_p, print_depth); break;
case empty_list_type:
print_empty_list(stream, instance, escape_p, print_depth); break;
case symbol_type:
print_symbol(stream, instance, escape_p, print_depth); break;
case simple_condition_type:
print_simple_condition(stream, instance, escape_p, print_depth); break;
case class_type:
print_class(stream, instance, escape_p, print_depth); break;
case function_type:
print_function(stream, instance, escape_p, print_depth); break;
case unknown_type:
format(stream, "?%lx", instance); break;
default:
print_user_defined(stream, instance, escape_p, print_depth); break;
}
}
void
xref_output()
{
Symbol **symbols, *symp;
size_t i, num;
num = collect_symbols(&symbols, is_var, 0);
qsort(symbols, num, sizeof(*symbols), compare);
/* produce xref output */
for (i = 0; i < num; i++) {
symp = symbols[i];
switch (symp->type) {
case SymIdentifier:
print_function(symp);
break;
case SymToken:
print_type(symp);
break;
case SymUndefined:
break;
}
}
free(symbols);
}
static void walk_functions(tree_set *visited, const struct cgraph_node *node)
{
struct cgraph_edge *e;
const_tree caller;
if (!node)
return;
caller = NODE_DECL(node);
if (pointer_set_insert(visited, caller))
return;
for (e = node->callees; e; e = e->next_callee) {
const struct cgraph_node *next_node;
tree callee = gimple_call_fndecl(e->call_stmt);
if (DECL_BUILT_IN(callee))
continue;
print_function(caller, callee);
next_node = cgraph_get_node(callee);
walk_functions(visited, next_node);
}
}
void print_data(char * filename, void print_function (FILE *, void *, int), double * data, int n, int p, int P)
{
FILE * fp;
int dummy = 0xcafe;
MPI_Status status;
if (p == 0)
{
//Create file
fp = fopen(filename, "w");
}
else
{
MPI_Recv(&dummy, 1, MPI_INTEGER, p-1, 88, MPI_COMM_WORLD, &status);
//Append file
fp = fopen(filename, "a");
}
fprintf(fp, "On process P: %d\n", p);
print_function(fp, data, n);
fclose(fp);
if (p != P-1)
{
MPI_Send(&dummy, 1, MPI_INTEGER, p+1, 88, MPI_COMM_WORLD);
}
}
void ALL::order_function_big(const int string_length,const int& length_dis,const int ID_length,vector<int>& record_array,int string_score_remain,int flag){
if(string_score_remain==0){
char advise_string[101];
//cout<<"string_length="<<string_length<<endl;
strncpy(advise_string,save_used_ID,ID_length);
advise_string[string_length]='\0';
//cout<<"advise_string="<<advise_string<<endl;
int i;
for(i=ID_length;i<string_length;i++){
//cout<<"flag="<<flag<<" "<<endl;
record_array.push_back(i);
}
print_function(record_array,advise_string,0);
for(i;i>ID_length;i--){record_array.pop_back();}
return;
}
if(flag>=string_length){return;}
//===============================
if(string_score_remain>=(ID_length-flag)){
for(flag;flag<ID_length;flag++){
record_array.push_back(flag);
order_function_big(string_length,length_dis,ID_length,record_array,string_score_remain-(ID_length-flag),flag+1);
record_array.pop_back();
}
}
else{
order_function_big(string_length,length_dis,ID_length,record_array,string_score_remain,flag+1);
}
//================================
return;
}
int main()
{
std::ofstream out_file;
out_file.open("cpp_mylang.cpp");
out_file<<"\n#include<iostream>\n\nint main()\n{";
std::ifstream in_file;
in_file.open("hello-world.mylang");
std::string line;
int lno = 1;
while(getline(in_file, line))
{
trim(line);
if( not line.empty() )
{
bool is_semicolon = true;
std::vector<std::string> tokens = tokenize(line, is_semicolon);
if(!is_semicolon) {std::cout<<"hello-world.mylang : error "<<lno<<" expected ;\n"; break; }
if(not (print_function(tokens, out_file) or scan_function(tokens, out_file)) )
{
for(auto s : tokens)
std::cout<<s;
std::cout<<"hello-world.mylang : error line : "<<lno<<"\n" ;
break;
}
}
++lno;
}
out_file << "\n}";
}
int main(void)
{
struct generic_tag var;
var.type = CHARACTER;
var.shared.c = '$';
print_function( var );
var.type = FLOAT;
var.shared.f = (float) 12345.67890;
print_function( var );
var.type = 'x';
var.shared.i = 111;
print_function( var );
return 0;
}
void deep_print(const Value& obj,
int(*print_function)(json_printer*, int, const char *, uint32_t)) {
switch (obj.type_) {
case Type::Null: {
print_function(&printer_, JSON_NULL, nullptr, 0);
break;
}
case Type::Boolean: {
print_function(&printer_, obj.value_.bool_val ? JSON_TRUE : JSON_FALSE, nullptr, 0);
break;
}
case Type::Integer: {
std::string str = detail::to_string(obj.value_.int_val);
print_function(&printer_, JSON_INT, str.c_str(), static_cast<uint32_t>(str.size()));
break;
}
case Type::Double:{
std::string str = detail::to_string(obj.value_.dbl_val);
print_function(&printer_, JSON_FLOAT, str.c_str(), static_cast<uint32_t>(str.size()));
break;
}
case Type::String: {
print_function(&printer_, JSON_STRING, obj.value_.str_val.c_str(), static_cast<uint32_t>(obj.value_.str_val.size()));
break;
}
case Type::Array: {
print_function(&printer_, JSON_ARRAY_BEGIN, nullptr, 0);
Value::const_array_iterator it = obj.value_.arr_val.begin(), end = obj.value_.arr_val.end();
for (; it != end; ++it) {
deep_print(*it, print_function);
}
print_function(&printer_, JSON_ARRAY_END, nullptr, 0);
break;
}
case Type::Object: {
print_function(&printer_, JSON_OBJECT_BEGIN, nullptr, 0);
Value::const_iterator it = obj.value_.map_val.begin(), end = obj.value_.map_val.end();
for (; it != end; ++it) {
print_function(&printer_, JSON_KEY, it->first.c_str(), static_cast<uint32_t>(it->first.length()));
deep_print(it->second, print_function);
}
print_function(&printer_, JSON_OBJECT_END, nullptr, 0);
break;
}
}
}
void print_list(List *l, void (*print_function)(void *))
{
Node *tmp = l->head;
while (tmp) {
print_function(tmp->data);
tmp = tmp->next;
}
printf("\n");
}
void
print(Printer& p, Define_decl const* d)
{
print_function(p, d, "define");
print_space(p);
print(p, '{');
print_nested(p, d->blocks());
print(p, '}');
}
void __cyg_profile_func_enter (void *func, void *caller)
{
int n;
depth++;
for (n = 0; n < depth; n++) printf (" ");
printf ("|-> ");
print_function(func);
printf ("\n");
}
/*Prints s. Behaviour (how to print each element) is defined on print_function*/
void print_stack (stack s, void (*print_function) (void*elem)) {
pnodos temp = s.first;
while (temp != NULL) {
print_function (temp->elem);
temp = temp->next;
}
printf ("\n");
}
/*Prints s. Behaviour (how to print each element) is defined on print_function*/
void print_queue (queue s, void (*print_function) (void*elem)) {
pqnodos temp = s.first;
while (temp != NULL) {
print_function (temp->elem);
temp = temp->next;
}
printf ("\n");
}
void print_function_set(ADCL_fnctset_t *fnctset)
{
int i;
printf("\n");
printf("Function Set Name: %s", fnctset->fs_name);
for(i=0;i<(fnctset->fs_maxnum);i++) {
printf("\n");
print_function(fnctset->fs_fptrs[i]);
}
printf("\n");
}
int main()
{
std::string aString("A simple string");
std::cout << aString << std::endl;
print_function(aString.c_str());
return 0;
}
void ALL::print_function(vector<int>& record_array,char *advise_string,int flag){
if(flag>=record_array.size()){return;}
for(int i=0;i<=61;i++){
advise_string[ record_array[flag] ]=antiTranslate(i);
print_function(record_array,advise_string,flag+1);
int now=translate(advise_string[0]);
if( findTree(tree[now],advise_string,0,strlen(advise_string)-1)<0 ){
char *tmp=new char[101];
strcpy(tmp,advise_string);
TEN.push_back(tmp);
}
}
return;
}
static void
switch_on_type(struct mlist *mlp, struct tdesc *tdp, char *format, int level)
{
boolean_t allocated = B_FALSE;
if (format == NULL) {
allocated = B_TRUE;
format = uc(mlp->name);
}
switch (tdp->type) {
case INTRINSIC:
print_intrinsic(mlp, tdp, format, level);
break;
case POINTER:
print_pointer(mlp, tdp, format, level);
break;
case ARRAY:
print_array(mlp, tdp, format, level);
break;
case FUNCTION:
print_function(mlp, tdp, format, level);
break;
case UNION:
print_union(mlp, tdp, format, level);
break;
case ENUM:
print_enum(mlp, tdp, format, level);
break;
case FORWARD:
print_forward(mlp, tdp, format, level);
break;
case TYPEOF:
print_typeof(mlp, tdp, format, level);
break;
case STRUCT:
print_struct(mlp, tdp, format, level);
break;
case VOLATILE:
print_volatile(mlp, tdp, format, level);
break;
default:
fprintf(stderr, "Switch to Unknown type\n");
error = B_TRUE;
break;
}
if (allocated)
free(format);
}
int add_function(char *path, char *hpath)
{
char *raw;
if ((raw = get_src(path)) == NULL)
{
free(path);
path = NULL;
return (-1);
}
print_function(raw);
fprintf(stderr, "Writed %s%s%s'functions into %s%s%s\n", GREEN, path, WHITE, GREEN, hpath, WHITE);
free(raw);
free(path);
path = NULL;
return (0);
}
/*
* helper functions to print instructions
*/
void print_fop(struct filter_op *fop, u_int32 eip)
{
switch (fop->opcode) {
case FOP_TEST:
print_test(fop, eip);
break;
case FOP_ASSIGN:
print_assign(fop, eip);
break;
case FOP_INC:
print_inc(fop, eip);
break;
case FOP_DEC:
print_dec(fop, eip);
break;
case FOP_FUNC:
print_function(fop, eip);
break;
case FOP_JMP:
fprintf(stdout, "%04lu: JUMP ALWAYS to %04d\n", (unsigned long)eip, fop->op.jmp);
break;
case FOP_JTRUE:
fprintf(stdout, "%04lu: JUMP IF TRUE to %04d\n", (unsigned long)eip, fop->op.jmp);
break;
case FOP_JFALSE:
fprintf(stdout, "%04lu: JUMP IF FALSE to %04d\n", (unsigned long)eip, fop->op.jmp);
break;
case FOP_EXIT:
fprintf(stdout, "%04lu: EXIT\n", (unsigned long)eip);
break;
default:
fprintf(stderr, "UNDEFINED OPCODE (%d) !!\n", fop->opcode);
exit(-1);
break;
}
}
void DisassemblerContext::run_term(const ValuePtr<>& term) {
switch (term->term_type()) {
case term_function: {
ValuePtr<Function> function = value_cast<Function>(term);
setup_term_name(function);
setup_function(function);
build_unique_names();
print_definitions(m_global_definitions, "", true);
print_function(function);
break;
}
case term_block: {
ValuePtr<Block> block = value_cast<Block>(term);
m_in_function_mode = true;
setup_term_name(block);
setup_block(block);
build_unique_names();
print_block(block, m_global_definitions);
break;
}
default:
m_in_function_mode = true;
setup_term_definition(term);
build_unique_names();
print_definitions(m_global_definitions);
switch (term->term_type()) {
case term_instruction:
case term_phi:
case term_function_parameter:
case term_recursive:
print_term_definition(term, true);
break;
default:
break;
}
break;
}
}
void ALL::order_function(const int string_length,const int& length_dis,const int ID_length,vector<int>& record_array,int string_score_remain,int flag){
if(string_score_remain==0){
char advise_string[101];
strncpy(advise_string,save_used_ID,string_length);
advise_string[string_length]='\0';
//cout<<"advise_string="<<advise_string<<endl;
int now=translate(advise_string[0]);
if(record_array.size()==0){
if(findTree(tree[now],advise_string,0,strlen(advise_string)-1)<0&& strcmp(advise_string," ")!=0){
char *tmp = new char [101];
strcpy(tmp, advise_string);
TEN.push_back(tmp);
}
}
print_function(record_array,advise_string,0);
return;
}
//cout<<"string_length= "<<string_length<<" "<<"flag= "<<flag<<endl;
//cout<<"string_score_remain="<<string_score_remain<<endl;
if(flag>=string_length){return;}
//===============================
if(string_score_remain>=(string_length-flag)){
//cout<<"enter if and "<<"string_length= "<<string_length<<" "<<"flag= "<<flag<<endl;
for(flag;flag<string_length;flag++){
/*cout<<"string_score_remain="<<string_score_remain<<" ";
cout<<"flag= "<<flag<<endl;
cout<<"string_length-flag="<<string_length-flag<<endl;*/
record_array.push_back(flag);
order_function(string_length,length_dis,ID_length,record_array,string_score_remain-(string_length-flag),flag+1);
record_array.pop_back();
}
}
else{
//cout<<"enter else"<<endl;
order_function(string_length,length_dis,ID_length,record_array,string_score_remain,flag+1);
}
//================================
return;
}
int print_actions (Action * actions)
{
printf("\n\nACTION %s:\n", actions->name);
print_var_list("Parameters", actions->param);
print_function("Preconditions", actions->pre);
print_function("Add effects", actions->add);
print_function("Delete effects", actions->del);
while (actions->next)
{
actions = actions->next;
printf("\n\nACTION %s:\n", actions->name);
print_var_list("Parameters", actions->param);
print_function("Preconditions", actions->pre);
print_function("Add effects", actions->add);
print_function("Delete effects", actions->del);
}
}
static void print_entity(const entity_t *entity)
{
print_indent();
switch (entity->kind) {
case ENTITY_FUNCTION:
print_function(&entity->function);
break;
case ENTITY_CONCEPT:
print_concept(&entity->concept);
break;
case ENTITY_VARIABLE:
print_variable(&entity->variable);
break;
case ENTITY_TYPEALIAS:
print_typealias(&entity->typealias);
break;
case ENTITY_CONSTANT:
print_constant(&entity->constant);
break;
case ENTITY_CONCEPT_FUNCTION:
case ENTITY_FUNCTION_PARAMETER:
case ENTITY_ERROR:
// TODO
fprintf(out, "some entity of type '%s'\n",
get_entity_kind_name(entity->kind));
break;
case ENTITY_TYPE_VARIABLE:
case ENTITY_LABEL:
break;
case ENTITY_INVALID:
fprintf(out, "invalid entity (%s)\n",
get_entity_kind_name(entity->kind));
break;
}
}
void
print(Printer& p, Declare_decl const* d)
{
print_function(p, d, "declare");
}
void DisassemblerContext::print_term_definition(const ValuePtr<>& term, bool global) {
*m_output << name(term) << " = ";
switch (term->term_type()) {
case term_functional: {
if (global)
*m_output << "define ";
print_functional_term(value_cast<FunctionalValue>(term), false);
*m_output << ";\n";
break;
}
case term_function_type: {
if (global)
*m_output << "define ";
print_function_type_term(value_cast<FunctionType>(term), false);
*m_output << ";\n";
break;
}
case term_instruction: {
print_instruction_term(value_cast<Instruction>(term));
break;
}
case term_phi: {
print_phi_term(value_cast<Phi>(term));
break;
}
case term_global_variable: {
ValuePtr<GlobalVariable> gvar = value_cast<GlobalVariable>(term);
*m_output << "global ";
if (gvar->constant())
*m_output << "const ";
print_term(gvar->value_type(), true);
if (gvar->value()) {
*m_output << ' ';
print_term(gvar->value(), true);
}
*m_output << ";\n";
return;
}
case term_function: {
print_function(value_cast<Function>(term));
return;
}
case term_function_parameter: {
ValuePtr<FunctionParameter> parameter = value_cast<FunctionParameter>(term);
ValuePtr<Function> function = parameter->function();
unsigned n = 0;
for (Function::ParameterList::const_iterator ii = function->parameters().begin(), ie = function->parameters().end(); ii != ie; ++ii, ++n) {
if (parameter == *ii) {
*m_output << "[function parameter " << n << "]\n";
return;
}
}
*m_output << "[invalid function parameter]\n";
return;
}
case term_apply: {
if (global)
*m_output << "define ";
print_apply_term(value_cast<ApplyType>(term), false);
*m_output << ";\n";
return;
}
case term_exists: {
if (global)
*m_output << "define ";
print_exists(value_cast<Exists>(term), false);
*m_output << ";\n";
return;
}
case term_recursive: {
print_recursive(value_cast<RecursiveType>(term));
return;
}
case term_recursive_parameter: *m_output << "[recursive parameter]\n"; return;
case term_parameter_placeholder: *m_output << "[parameter placeholder]\n"; return;
case term_upref_null: *m_output << "upref_null\n"; return;
default:
PSI_FAIL("unexpected term type - cannot print a definition");
}
}