/************************************************************************* * * * Extension for YAP Prolog * * * * Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * * * * Yap Prolog was developed at NCCUP - Universidade do Porto * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * * ************************************************************************** * * * File: jit_debugpreds.c * * comments: Debugging predicates * * * * Last rev: 2013-10-18 * *************************************************************************/ #include "jit_predicates.hh" static Int p_no_print_instruction( USES_REGS1 ); static Int p_no_print_basic_instruction( USES_REGS1 ); static Int p_no_print_std_instruction( USES_REGS1 ); static Int p_no_print_standard_instruction( USES_REGS1 ); static Int p_print_instruction( USES_REGS1 ); static Int p_print_basic_instruction( USES_REGS1 ); static Int p_print_std_instruction( USES_REGS1 ); static Int p_print_standard_instruction( USES_REGS1 ); static Int p_print_instruction_msg_before( USES_REGS1 ); static Int p_print_basic_instruction_msg_before( USES_REGS1 ); static Int p_print_std_instruction_msg_before( USES_REGS1 ); static Int p_print_standard_instruction_msg_before( USES_REGS1 ); static Int p_print_instruction_msg_after( USES_REGS1 ); static Int p_print_basic_instruction_msg_after( USES_REGS1 ); static Int p_print_std_instruction_msg_after( USES_REGS1 ); static Int p_print_standard_instruction_msg_after( USES_REGS1 ); static Int p_print_instruction3( USES_REGS1 ); static Int p_print_basic_instruction3( USES_REGS1 ); static Int p_print_std_instruction3( USES_REGS1 ); static Int p_print_standard_instruction3( USES_REGS1 ); static Int p_print_profiled_instruction( USES_REGS1 ); static Int p_print_traced_instruction( USES_REGS1 ); static Int p_print_pfd_instruction( USES_REGS1 ); static Int p_print_profiled_instruction_msg_before( USES_REGS1 ); static Int p_print_traced_instruction_msg_before( USES_REGS1 ); static Int p_print_pfd_instruction_msg_before( USES_REGS1 ); static Int p_print_profiled_instruction_msg_after( USES_REGS1 ); static Int p_print_traced_instruction_msg_after( USES_REGS1 ); static Int p_print_pfd_instruction_msg_after( USES_REGS1 ); static Int p_print_profiled_instruction3( USES_REGS1 ); static Int p_print_traced_instruction3( USES_REGS1 ); static Int p_print_pfd_instruction3( USES_REGS1 ); static Int p_print_native_instruction( USES_REGS1 ); static Int p_print_ntv_instruction( USES_REGS1 ); static Int p_print_native_instruction_msg_before( USES_REGS1 ); static Int p_print_ntv_instruction_msg_before( USES_REGS1 ); static Int p_print_native_instruction_msg_after( USES_REGS1 ); static Int p_print_ntv_instruction_msg_after( USES_REGS1 ); static Int p_print_native_instruction3( USES_REGS1 ); static Int p_print_ntv_instruction3( USES_REGS1 ); static Int p_no_print_basic_block( USES_REGS1 ); static Int p_no_print_basicblock( USES_REGS1 ); static Int p_no_print_bb( USES_REGS1 ); static Int p_print_basic_block( USES_REGS1 ); static Int p_print_basicblock( USES_REGS1 ); static Int p_print_bb( USES_REGS1 ); static Int p_print_basic_block_msg_before( USES_REGS1 ); static Int p_print_basicblock_msg_before( USES_REGS1 ); static Int p_print_bb_msg_before( USES_REGS1 ); static Int p_print_basic_block_msg_after( USES_REGS1 ); static Int p_print_basicblock_msg_after( USES_REGS1 ); static Int p_print_bb_msg_after( USES_REGS1 ); static Int p_print_basic_block3( USES_REGS1 ); static Int p_print_basicblock3( USES_REGS1 ); static Int p_print_bb3( USES_REGS1 ); static Int p_print_native_basic_block( USES_REGS1 ); static Int p_print_native_basicblock( USES_REGS1 ); static Int p_print_native_bb( USES_REGS1 ); static Int p_print_native_basic_block_msg_before( USES_REGS1 ); static Int p_print_native_basicblock_msg_before( USES_REGS1 ); static Int p_print_native_bb_msg_before( USES_REGS1 ); static Int p_print_native_basic_block_msg_after( USES_REGS1 ); static Int p_print_native_basicblock_msg_after( USES_REGS1 ); static Int p_print_native_bb_msg_after( USES_REGS1 ); static Int p_print_native_basic_block3( USES_REGS1 ); static Int p_print_native_basicblock3( USES_REGS1 ); static Int p_print_native_bb3( USES_REGS1 ); static Int p_no_print_clause( USES_REGS1 ); static Int p_print_clause( USES_REGS1 ); static Int p_no_print_intermediate( USES_REGS1 ); static Int p_print_intermediate( USES_REGS1 ); static Int p_print_intermediate_to_std( USES_REGS1 ); static Int p_print_intermediate_to_std1( USES_REGS1 ); static Int p_print_intermediate_to_file( USES_REGS1 ); static Int p_print_intermediate_to_file1( USES_REGS1 ); static Int p_no_print_llva( USES_REGS1 ); static Int p_print_llva_before( USES_REGS1 ); static Int p_print_llva_after( USES_REGS1 ); static Int p_no_print_me( USES_REGS1 ); static Int p_print_me( USES_REGS1 ); static Int p_default_debug( USES_REGS1 ); static Int p_print_default_predicate_msgs( USES_REGS1 ); static Int p_print_all_predicate_msgs( USES_REGS1 ); static Int p_print_info_predicate_msgs( USES_REGS1 ); static Int p_print_success_predicate_msgs( USES_REGS1 ); static Int p_print_warning_predicate_msgs( USES_REGS1 ); static Int p_print_error_predicate_msgs( USES_REGS1 ); static Int p_no_print_all_predicate_msgs( USES_REGS1 ); static Int p_no_print_info_predicate_msgs( USES_REGS1 ); static Int p_no_print_success_predicate_msgs( USES_REGS1 ); static Int p_no_print_warning_predicate_msgs( USES_REGS1 ); static Int p_no_print_error_predicate_msgs( USES_REGS1 ); static Int p_print_predicate_msgs( USES_REGS1 ); static Int p_exit_on_warning( USES_REGS1 ); static Int p_disable_on_warning( USES_REGS1 ); static Int p_exit_on_error( USES_REGS1 ); static Int p_no_exit_on_warning( USES_REGS1 ); static Int p_enable_on_warning( USES_REGS1 ); static Int p_no_exit_on_error( USES_REGS1 ); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wimplicit-function-declaration" static Int p_no_print_instruction( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ if (ExpEnv.debug_struc.pyaam_##OP.msg_before) free((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before); \ if (ExpEnv.debug_struc.pyaam_##OP.msg_after) free((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after); \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)NO_PLACE; \ ExpEnv.debug_struc.pyaam_##OP.msg_before = 0; \ ExpEnv.debug_struc.pyaam_##OP.msg_after = 0; \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_instruction / no_print_basic_instruction / no_print_std_instruction / no_print_standard_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_instruction / no_print_basic_instruction / no_print_std_instruction / no_print_standard_instruction"); return FALSE; } } static Int p_no_print_basic_instruction( USES_REGS1 ) { return p_no_print_instruction(); } static Int p_no_print_std_instruction( USES_REGS1 ) { return p_no_print_instruction(); } static Int p_no_print_standard_instruction( USES_REGS1 ) { return p_no_print_instruction(); } static Int p_print_instruction( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); return FALSE; } } static Int p_print_basic_instruction( USES_REGS1 ) { return p_print_instruction(); } static Int p_print_std_instruction( USES_REGS1 ) { return p_print_instruction(); } static Int p_print_standard_instruction( USES_REGS1 ) { return p_print_instruction(); } static Int p_print_instruction_msg_before( USES_REGS1 ) { Term t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_before / print_basic_instruction_msg_before / print_std_instruction_msg_before / print_standard_instruction_msg_before"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_before / print_basic_instruction_msg_before / print_std_instruction_msg_before / print_standard_instruction_msg_before"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_before / print_basic_instruction_msg_before / print_std_instruction_msg_before / print_standard_instruction_msg_before"); return FALSE; } } static Int p_print_basic_instruction_msg_before( USES_REGS1 ) { return p_print_instruction_msg_before(); } static Int p_print_std_instruction_msg_before( USES_REGS1 ) { return p_print_instruction_msg_before(); } static Int p_print_standard_instruction_msg_before( USES_REGS1 ) { return p_print_instruction_msg_before(); } static Int p_print_instruction_msg_after( USES_REGS1 ) { Term t = Deref(ARG2); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_after / print_basic_instruction_msg_after / print_std_instruction_msg_after / print_standard_instruction_msg_after"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_after / print_basic_instruction_msg_after / print_std_instruction_msg_after / print_standard_instruction_msg_after"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction_msg_after / print_basic_instruction_msg_after / print_std_instruction_msg_after / print_standard_instruction_msg_after"); return FALSE; } } static Int p_print_basic_instruction_msg_after( USES_REGS1 ) { return p_print_instruction_msg_after(); } static Int p_print_std_instruction_msg_after( USES_REGS1 ) { return p_print_instruction_msg_after(); } static Int p_print_standard_instruction_msg_after( USES_REGS1 ) { return p_print_instruction_msg_after(); } static Int p_print_instruction3( USES_REGS1 ) { Term t = Deref(ARG3); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); return FALSE; } t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_instruction / print_basic_instruction / print_std_instruction / print_standard_instruction"); return FALSE; } } static Int p_print_basic_instruction3( USES_REGS1 ) { return p_print_instruction3(); } static Int p_print_std_instruction3( USES_REGS1 ) { return p_print_instruction3(); } static Int p_print_standard_instruction3( USES_REGS1 ) { return p_print_instruction3(); } static Int p_print_profiled_instruction( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction / print_traced_instruction / print_pfd_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction / print_traced_instruction / print_pfd_instruction"); return FALSE; } } static Int p_print_traced_instruction( USES_REGS1 ) { return p_print_profiled_instruction(); } static Int p_print_pfd_instruction( USES_REGS1 ) { return p_print_profiled_instruction(); } static Int p_print_profiled_instruction_msg_before( USES_REGS1 ) { Term t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_before / print_traced_instruction_msg_before / print_pfd_instruction_msg_before"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_before / print_traced_instruction_msg_before / print_pfd_instruction_msg_before"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_before / print_traced_instruction_msg_before / print_pfd_instruction_msg_before"); return FALSE; } } static Int p_print_traced_instruction_msg_before( USES_REGS1 ) { return p_print_profiled_instruction_msg_before(); } static Int p_print_pfd_instruction_msg_before( USES_REGS1 ) { return p_print_profiled_instruction_msg_before(); } static Int p_print_profiled_instruction_msg_after( USES_REGS1 ) { Term t = Deref(ARG2); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_after / print_traced_instruction_msg_after / print_pfd_instruction_msg_after"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_after / print_traced_instruction_msg_after / print_pfd_instruction_msg_after"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction_msg_after / print_traced_instruction_msg_after / print_pfd_instruction_msg_after"); return FALSE; } } static Int p_print_traced_instruction_msg_after( USES_REGS1 ) { return p_print_profiled_instruction_msg_after(); } static Int p_print_pfd_instruction_msg_after( USES_REGS1 ) { return p_print_profiled_instruction_msg_after(); } static Int p_print_profiled_instruction3( USES_REGS1 ) { Term t = Deref(ARG3); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); return FALSE; } t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_PROFILED_INTERPRETER; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_PROFILED_INTERPRETER; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_profiled_instruction/ print_traced_instruction / print_pfd_instruction"); return FALSE; } } static Int p_print_traced_instruction3( USES_REGS1 ) { return p_print_profiled_instruction3(); } static Int p_print_pfd_instruction3( USES_REGS1 ) { return p_print_profiled_instruction3(); } static Int p_print_native_instruction( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); return FALSE; } } static Int p_print_ntv_instruction( USES_REGS1 ) { return p_print_native_instruction(); } static Int p_print_native_instruction_msg_before( USES_REGS1 ) { Term t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_before / print_ntv_instruction_msg_before"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_before / print_ntv_instruction_msg_before"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_before / print_ntv_instruction_msg_before"); return FALSE; } } static Int p_print_ntv_instruction_msg_before( USES_REGS1 ) { return p_print_native_instruction_msg_before(); } static Int p_print_native_instruction_msg_after( USES_REGS1 ) { Term t = Deref(ARG2); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_after / print_ntv_instruction_msg_after"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_after / print_ntv_instruction_msg_after"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction_msg_after / print_ntv_instruction_msg_after"); return FALSE; } } static Int p_print_ntv_instruction_msg_after( USES_REGS1 ) { return p_print_native_instruction_msg_after(); } static Int p_print_native_instruction3( USES_REGS1 ) { Term t = Deref(ARG3); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); return FALSE; } t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strop = (char*)malloc(100*sizeof(char)); #define OPCODE(OP,TYPE) \ strcpy(strop, #OP); \ UPPER_ENTRY(strop); \ if (strcmp(str, strop) == 0) { \ ExpEnv.debug_struc.pyaam_##OP.msg_before = (CELL)malloc((strlen(msgb)+1)*sizeof(char)); \ ExpEnv.debug_struc.pyaam_##OP.msg_after = (CELL)malloc((strlen(msga)+2)*sizeof(char)); \ if (!ExpEnv.debug_struc.pyaam_##OP.print) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pyaam_##OP.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_before), msgb); \ strcpy(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), msga); \ strcat(((char*)ExpEnv.debug_struc.pyaam_##OP.msg_after), "\n"); \ } #include "YapAppliedOpcodes.h" #undef OPCODE else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_instruction / print_ntv_instruction"); return FALSE; } } static Int p_print_ntv_instruction3( USES_REGS1 ) { return p_print_native_instruction3(); } static Int p_no_print_basic_block( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ if (ExpEnv.debug_struc.pbbs_##BB.msg_before) free((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before); \ if (ExpEnv.debug_struc.pbbs_##BB.msg_after) free((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after);\ ExpEnv.debug_struc.pbbs_##BB.print = (Int)NO_PLACE; \ ExpEnv.debug_struc.pbbs_##BB.msg_before = 0; \ ExpEnv.debug_struc.pbbs_##BB.msg_after = 0; \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_basic_block / no_print_basicblock / no_print_bb"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_basic_block / no_print_basicblock / no_print_bb"); return FALSE; } } static Int p_no_print_basicblock( USES_REGS1 ) { return p_no_print_basic_block(); } static Int p_no_print_bb( USES_REGS1 ) { return p_no_print_basic_block(); } static Int p_print_basic_block( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); return FALSE; } } static Int p_print_basicblock( USES_REGS1 ) { return p_print_basic_block(); } static Int p_print_bb( USES_REGS1 ) { return p_print_basic_block(); } static Int p_print_basic_block_msg_before( USES_REGS1 ) { Term t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_before / print_basicblock_msg_before / print_bb_msg_before"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_before / print_basicblock_msg_before / print_bb_msg_before"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_before / print_basicblock_msg_before / print_bb_msg_before"); return FALSE; } } static Int p_print_basicblock_msg_before( USES_REGS1 ) { return p_print_basic_block_msg_before(); } static Int p_print_bb_msg_before( USES_REGS1 ) { return p_print_basic_block_msg_before(); } static Int p_print_basic_block_msg_after( USES_REGS1 ) { Term t = Deref(ARG2); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_after / print_basicblock_msg_after / print_bb_msg_after"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_after / print_basicblock_msg_after / print_bb_msg_after"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block_msg_after / print_basicblock_msg_after / print_bb_msg_after"); return FALSE; } } static Int p_print_basicblock_msg_after( USES_REGS1 ) { return p_print_basic_block_msg_after(); } static Int p_print_bb_msg_after( USES_REGS1 ) { return p_print_basic_block_msg_after(); } static Int p_print_basic_block3( USES_REGS1 ) { Term t = Deref(ARG3); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); return FALSE; } t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= ((Int)ON_INTERPRETER | (Int)ON_PROFILED_INTERPRETER); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_basic_block / print_basicblock / print_bb"); return FALSE; } } static Int p_print_basicblock3( USES_REGS1 ) { return p_print_basic_block3(); } static Int p_print_bb3( USES_REGS1 ) { return p_print_basic_block3(); } static Int p_print_native_basic_block( USES_REGS1 ) { Term t = Deref(ARG1); if (IsAtomTerm(t)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); UPPER_ENTRY(str); if (strcmp(str, "ALL") == 0) { #define BBLOCK(BB) \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK return TRUE; } Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } else if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } } static Int p_print_native_basicblock( USES_REGS1 ) { return p_print_native_basic_block(); } static Int p_print_native_bb( USES_REGS1 ) { return p_print_native_basic_block(); } static Int p_print_native_basic_block_msg_before( USES_REGS1 ) { Term t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_before / print_native_basicblock_msg_before / print_native_bb_msg_before"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_before / print_native_basicblock_msg_before / print_native_bb_msg_before"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_before / print_native_basicblock_msg_before / print_native_bb_msg_before"); return FALSE; } } static Int p_print_native_basicblock_msg_before( USES_REGS1 ) { return p_print_native_basic_block_msg_before(); } static Int p_print_native_bb_msg_before( USES_REGS1 ) { return p_print_native_basic_block_msg_before(); } static Int p_print_native_basic_block_msg_after( USES_REGS1 ) { Term t = Deref(ARG2); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_after / print_native_basicblock_msg_after / print_native_bb_msg_after"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_after / print_native_basicblock_msg_after / print_native_bb_msg_after"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block_msg_after / print_native_basicblock_msg_after / print_native_bb_msg_after"); return FALSE; } } static Int p_print_native_basicblock_msg_after( USES_REGS1 ) { return p_print_native_basic_block_msg_after(); } static Int p_print_native_bb_msg_after( USES_REGS1 ) { return p_print_native_basic_block_msg_after(); } static Int p_print_native_basic_block3( USES_REGS1 ) { Term t = Deref(ARG3); char *msga; if (IsAtomTerm(t)) { msga = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msga, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } t = Deref(ARG2); char *msgb; if (IsAtomTerm(t)) { msgb = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msgb, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); char *strbb = (char*)malloc(100*sizeof(char)); #define BBLOCK(BB) \ strcpy(strbb, #BB); \ UPPER_ENTRY(strbb); \ if (strcmp(str, strbb) == 0) { \ ExpEnv.debug_struc.pbbs_##BB.msg_before = (CELL)malloc(sizeof(char)); \ ExpEnv.debug_struc.pbbs_##BB.msg_after = (CELL)malloc(2*sizeof(char)); \ if (!ExpEnv.debug_struc.pbbs_##BB.print) \ ExpEnv.debug_struc.pbbs_##BB.print = (Int)ON_NATIVE; \ else \ ExpEnv.debug_struc.pbbs_##BB.print |= (Int)ON_NATIVE; \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_before), ""); \ strcpy(((char*)ExpEnv.debug_struc.pbbs_##BB.msg_after), "\n"); \ } #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } } static Int p_print_native_basicblock3( USES_REGS1 ) { return p_print_native_basic_block3(); } static Int p_print_native_bb3( USES_REGS1 ) { return p_print_native_basic_block3(); } static Int p_no_print_clause( USES_REGS1 ) { if (ExpEnv.debug_struc.pmainclause_on_head.msg_before) free((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before); if (ExpEnv.debug_struc.pmainclause_on_head.msg_after) free((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after); ExpEnv.debug_struc.pmainclause_on_head.print = (Int)NO_PLACE; ExpEnv.debug_struc.pmainclause_on_head.msg_before = 0; ExpEnv.debug_struc.pmainclause_on_head.msg_after = 0; return TRUE; } static Int p_print_clause( USES_REGS1 ) { Term t = Deref(ARG1); if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); if (strcmp(str, "STANDARD") == 0 || strcmp(str, "STD") == 0) { ExpEnv.debug_struc.pmainclause_on_head.msg_before = (CELL)malloc(sizeof(char)); ExpEnv.debug_struc.pmainclause_on_head.msg_after = (CELL)malloc(2*sizeof(char)); if (!ExpEnv.debug_struc.pmainclause_on_head.print) ExpEnv.debug_struc.pmainclause_on_head.print = (Int)ON_INTERPRETER; else ExpEnv.debug_struc.pmainclause_on_head.print |= (Int)ON_INTERPRETER; strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before), ""); strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after), "\n"); } else if (strcmp(str, "PROFILED") == 0 || strcmp(str, "PFD") == 0) { ExpEnv.debug_struc.pmainclause_on_head.msg_before = (CELL)malloc(sizeof(char)); ExpEnv.debug_struc.pmainclause_on_head.msg_after = (CELL)malloc(2*sizeof(char)); if (!ExpEnv.debug_struc.pmainclause_on_head.print) ExpEnv.debug_struc.pmainclause_on_head.print = (Int)ON_PROFILED_INTERPRETER; else ExpEnv.debug_struc.pmainclause_on_head.print |= (Int)ON_PROFILED_INTERPRETER; strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before), ""); strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after), "\n"); } else if (strcmp(str, "NATIVE") == 0 || strcmp(str, "NTV") == 0) { ExpEnv.debug_struc.pmainclause_on_head.msg_before = (CELL)malloc(sizeof(char)); ExpEnv.debug_struc.pmainclause_on_head.msg_after = (CELL)malloc(2*sizeof(char)); if (!ExpEnv.debug_struc.pmainclause_on_head.print) ExpEnv.debug_struc.pmainclause_on_head.print = (Int)ON_NATIVE; else ExpEnv.debug_struc.pmainclause_on_head.print |= (Int)ON_NATIVE; strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_before), ""); strcpy(((char*)ExpEnv.debug_struc.pmainclause_on_head.msg_after), "\n"); } else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_native_basic_block / print_native_basicblock / print_native_bb"); return FALSE; } } static Int p_no_print_intermediate( USES_REGS1 ) { if (ExpEnv.debug_struc.pprint_intermediate.std_name) free((char*)ExpEnv.debug_struc.pprint_intermediate.std_name); if (ExpEnv.debug_struc.pprint_intermediate.file_name) free((char*)ExpEnv.debug_struc.pprint_intermediate.file_name); ExpEnv.debug_struc.pprint_intermediate.print_to_std = 0; ExpEnv.debug_struc.pprint_intermediate.print_to_file = 0; ExpEnv.debug_struc.pprint_intermediate.std_name = 0; ExpEnv.debug_struc.pprint_intermediate.file_name = 0; return TRUE; } static Int p_print_intermediate( USES_REGS1 ) { ExpEnv.debug_struc.pprint_intermediate.print_to_std = 1; ExpEnv.debug_struc.pprint_intermediate.std_name = (CELL)malloc(7*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.std_name), "STDOUT"); return TRUE; } static Int p_print_intermediate_to_std( USES_REGS1 ) { ExpEnv.debug_struc.pprint_intermediate.print_to_std = 1; ExpEnv.debug_struc.pprint_intermediate.std_name = (CELL)malloc(7*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.std_name), "STDOUT"); return TRUE; } static Int p_print_intermediate_to_std1( USES_REGS1 ) { Term t = Deref(ARG1); if (IsAtomTerm(t)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); UPPER_ENTRY(str); if (strcmp(str, "STDOUT") == 0 || strcmp(str, "STDERR") == 0) { ExpEnv.debug_struc.pprint_intermediate.print_to_std = 1; ExpEnv.debug_struc.pprint_intermediate.std_name = (CELL)malloc(strlen(str)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.std_name), str); return TRUE; } Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_intermediate_to_std"); return FALSE; } } static Int p_print_intermediate_to_file( USES_REGS1 ) { ExpEnv.debug_struc.pprint_intermediate.print_to_file = 1; ExpEnv.debug_struc.pprint_intermediate.file_name = (CELL)malloc(7*sizeof(char)); if (Yap_ExecutionMode == MIXED_MODE) strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "trace"); else strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "clause"); return TRUE; } static Int p_print_intermediate_to_file1( USES_REGS1 ) { Term t = Deref(ARG1); if (IsAtomTerm(t)) { char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); ExpEnv.debug_struc.pprint_intermediate.print_to_file = 1; ExpEnv.debug_struc.pprint_intermediate.file_name = (CELL)malloc(strlen(str)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), str); return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_intermediate_to_file"); return FALSE; } } static Int p_no_print_llva( USES_REGS1 ) { ExpEnv.debug_struc.pprint_llva.print_llva_before = 0; ExpEnv.debug_struc.pprint_llva.print_llva_after = 0; return TRUE; } static Int p_print_llva_before( USES_REGS1 ) { ExpEnv.debug_struc.pprint_llva.print_llva_before = 1; return TRUE; } static Int p_print_llva_after( USES_REGS1 ) { ExpEnv.debug_struc.pprint_llva.print_llva_after = 1; return TRUE; } static Int p_no_print_me( USES_REGS1 ) { Term t = Deref(ARG1); if (IsAtomTerm(t)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); UPPER_ENTRY(str); if (strcmp(str, "INTERPRETEDBACKTRACK") == 0) free((char*)ExpEnv.debug_struc.pprint_me.interpreted_backtrack); if (strcmp(str, "PROFILEDINTERPRETEDBACKTRACK") == 0 || strcmp(str, "TRACEDINTERPRETEDBACKTRACK") == 0) free((char*)ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack); else if (strcmp(str, "NATIVEBACKTRACK") == 0) free((char*)ExpEnv.debug_struc.pprint_me.native_backtrack); else if (strcmp(str, "TREATIHEAP") == 0) free((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_heap); else if (strcmp(str, "TREATNHEAP") == 0) free((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap); else if (strcmp(str, "TREATITRAIL") == 0) free((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_trail); else if (strcmp(str, "TREATNTRAIL") == 0) free((char*)ExpEnv.debug_struc.pprint_me.native_treat_trail); else if (strcmp(str, "CRITICALS") == 0) free((char*)ExpEnv.debug_struc.pprint_me.criticals); else if (strcmp(str, "ATCOMPILATION") == 0) free((char*)ExpEnv.debug_struc.pprint_me.at_compilation); else if (strcmp(str, "ATRECOMPILATION") == 0) free((char*)ExpEnv.debug_struc.pprint_me.at_recompilation); else if (strcmp(str, "NATIVERUNINIT") == 0) free((char*)ExpEnv.debug_struc.pprint_me.nativerun_init); else if (strcmp(str, "NATIVERUNEXITBYSUCCESS") == 0) free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success); else if (strcmp(str, "NATIVERUNEXITBYFAIL") == 0) free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail); else if (strcmp(str, "NATIVERUNEXIT") == 0) { free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success); free((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail); } else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"no_print_me"); return FALSE; } } static Int p_print_me( USES_REGS1 ) { Term t = Deref(ARG2); char *msg; if (IsAtomTerm(t)) { msg = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(msg, AtomName(AtomOfTerm(t))); } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_me"); return FALSE; } t = Deref(ARG1); if (IsAtomTerm(t)) { int i = 0, j = 0; char *tmp; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); UPPER_ENTRY(str); if (strcmp(str, "INTERPRETEDBACKTRACK") == 0) { ExpEnv.debug_struc.pprint_me.interpreted_backtrack = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.interpreted_backtrack), msg); } else if (strcmp(str, "PROFILEDINTERPRETEDBACKTRACK") == 0 || strcmp(str, "TRACEDINTERPRETEDBACKTRACK") == 0) { ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack), msg); } else if (strcmp(str, "NATIVEBACKTRACK") == 0) { ExpEnv.debug_struc.pprint_me.native_backtrack = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.native_backtrack), msg); } else if (strcmp(str, "TREATIHEAP") == 0) { ExpEnv.debug_struc.pprint_me.interpreted_treat_heap = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_heap), msg); } else if (strcmp(str, "TREATNHEAP") == 0) { ExpEnv.debug_struc.pprint_me.native_treat_heap = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.native_treat_heap), msg); } else if (strcmp(str, "TREATITRAIL") == 0) { ExpEnv.debug_struc.pprint_me.interpreted_treat_trail = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.interpreted_treat_trail), msg); } else if (strcmp(str, "TREATNTRAIL") == 0) { ExpEnv.debug_struc.pprint_me.native_treat_trail = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.native_treat_trail), msg); } else if (strcmp(str, "CRITICALS") == 0) { ExpEnv.debug_struc.pprint_me.criticals = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.criticals), msg); } else if (strcmp(str, "ATCOMPILATION") == 0) { ExpEnv.debug_struc.pprint_me.at_compilation = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.at_compilation), msg); } else if (strcmp(str, "ATRECOMPILATION") == 0) { ExpEnv.debug_struc.pprint_me.at_recompilation = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.at_recompilation), msg); } else if (strcmp(str, "NATIVERUNINIT") == 0) { ExpEnv.debug_struc.pprint_me.nativerun_init = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_init), msg); } else if (strcmp(str, "NATIVERUNEXITBYSUCCESS") == 0) { ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success), msg); } else if (strcmp(str, "NATIVERUNEXITBYFAIL") == 0) { ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail), msg); } else if (strcmp(str, "NATIVERUNEXIT") == 0) { ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success), msg); ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = (CELL)malloc(strlen(msg)*sizeof(char)); strcpy(((char*)ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail), msg); } else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_me"); return FALSE; } } static Int p_default_debug( USES_REGS1 ) { #define OPCODE(OP,TYPE) \ ExpEnv.debug_struc.pyaam_##OP.print = (Int)NO_PLACE; \ ExpEnv.debug_struc.pyaam_##OP.msg_before = 0; \ ExpEnv.debug_struc.pyaam_##OP.msg_after = 0; #include "YapAppliedOpcodes.h" #undef OPCODE #define BBLOCK(BB) \ ExpEnv.debug_struc.pbbs_##BB.print = (Int)NO_PLACE; \ ExpEnv.debug_struc.pbbs_##BB.msg_before = 0; \ ExpEnv.debug_struc.pbbs_##BB.msg_after = 0; #include "Yap_AppliedBasicBlocks.h" #undef BBLOCK ExpEnv.debug_struc.pmainclause_on_head.print = (Int)NO_PLACE; ExpEnv.debug_struc.pmainclause_on_head.msg_before = 0; ExpEnv.debug_struc.pmainclause_on_head.msg_after = 0; ExpEnv.debug_struc.pprint_intermediate.print_to_std = 0; ExpEnv.debug_struc.pprint_intermediate.print_to_file = 0; ExpEnv.debug_struc.pprint_intermediate.std_name = 0; ExpEnv.debug_struc.pprint_intermediate.file_name = 0; ExpEnv.debug_struc.pprint_llva.print_llva_before = 0; ExpEnv.debug_struc.pprint_llva.print_llva_after = 0; ExpEnv.debug_struc.pprint_me.interpreted_backtrack = 0; ExpEnv.debug_struc.pprint_me.profiled_interpreted_backtrack = 0; ExpEnv.debug_struc.pprint_me.native_backtrack = 0; ExpEnv.debug_struc.pprint_me.interpreted_treat_heap = 0; ExpEnv.debug_struc.pprint_me.native_treat_heap = 0; ExpEnv.debug_struc.pprint_me.interpreted_treat_trail = 0; ExpEnv.debug_struc.pprint_me.native_treat_trail = 0; ExpEnv.debug_struc.pprint_me.criticals = 0; ExpEnv.debug_struc.pprint_me.at_compilation = 0; ExpEnv.debug_struc.pprint_me.at_recompilation = 0; ExpEnv.debug_struc.pprint_me.nativerun_init = 0; ExpEnv.debug_struc.pprint_me.nativerun_exit_by_success = 0; ExpEnv.debug_struc.pprint_me.nativerun_exit_by_fail = 0; ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 0; ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 1; ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 1; return TRUE; } static Int p_print_default_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; return TRUE; } static Int p_print_all_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; return TRUE; } static Int p_print_info_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; return TRUE; } static Int p_print_success_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; return TRUE; } static Int p_print_warning_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; return TRUE; } static Int p_print_error_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; return TRUE; } static Int p_no_print_all_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 0; ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 0; return TRUE; } static Int p_no_print_info_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 0; return TRUE; } static Int p_no_print_success_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 0; return TRUE; } static Int p_no_print_warning_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 0; return TRUE; } static Int p_no_print_error_predicate_msgs( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 0; return TRUE; } static Int p_print_predicate_msgs( USES_REGS1 ) { int i = 0, j = 0; char *tmp; Term t = Deref(ARG1); if (IsAtomTerm(t)) { char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); UPPER_ENTRY(str); if (strcmp(str, "ALL") == 0) { ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; return TRUE; } Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } else if (IsPairTerm(t)) { Term u = HeadOfTermCell(t); u = Deref(u); while (1) { if (IsAtomTerm(u)) { int i = 0, j = 0; char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(u))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(u))); UPPER_ENTRY(str); if (strcmp(str, "INFO") == 0 || strcmp(str, "INFORMATION") == 0) ExpEnv.debug_struc.act_predicate_msgs.info_msgs = 1; else if (strcmp(str, "SUCCESS") == 0) ExpEnv.debug_struc.act_predicate_msgs.success_msgs = 1; else if (strcmp(str, "WARNING") == 0) ExpEnv.debug_struc.act_predicate_msgs.warning_msgs = 1; else if (strcmp(str, "ERROR") == 0) ExpEnv.debug_struc.act_predicate_msgs.error_msgs = 1; else { Yap_Error(OUT_OF_KNOWNRANGE_ERROR,u,""); return FALSE; } } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_predicate_msgs"); return FALSE; } t = TailOfTermCell(t); t = Deref(t); if (IsAtomTerm(t)) break; u = HeadOfTermCell(t); u = Deref(u); } return TRUE; } else { Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"print_predicate_msgs"); return FALSE; } } static Int p_exit_on_warning( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 1; return TRUE; } static Int p_disable_on_warning( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 1; return TRUE; } static Int p_exit_on_error( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 1; return TRUE; } static Int p_no_exit_on_warning( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_actions.exit_on_warning = 0; return TRUE; } static Int p_enable_on_warning( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_actions.disable_on_warning = 0; return TRUE; } static Int p_no_exit_on_error( USES_REGS1 ) { ExpEnv.debug_struc.act_predicate_actions.exit_on_error = 0; return TRUE; } #pragma GCC diagnostic pop void Yap_InitJitDebugPreds( USES_REGS1 ) { Yap_InitCPred("no_print_instruction", 1, p_no_print_instruction, SafePredFlag); Yap_InitCPred("no_print_basic_instruction", 1, p_no_print_basic_instruction, SafePredFlag); Yap_InitCPred("no_print_std_instruction", 1, p_no_print_std_instruction, SafePredFlag); Yap_InitCPred("no_print_standard_instruction", 1, p_no_print_standard_instruction, SafePredFlag); Yap_InitCPred("print_instruction", 1, p_print_instruction, SafePredFlag); Yap_InitCPred("print_basic_instruction", 1, p_print_basic_instruction, SafePredFlag); Yap_InitCPred("print_std_instruction", 1, p_print_std_instruction, SafePredFlag); Yap_InitCPred("print_standard_instruction", 1, p_print_standard_instruction, SafePredFlag); Yap_InitCPred("print_instruction_msg_before", 2, p_print_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_basic_instruction_msg_before", 2, p_print_basic_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_std_instruction_msg_before", 2, p_print_std_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_standard_instruction_msg_before", 2, p_print_standard_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_instruction_msg_after", 2, p_print_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_basic_instruction_msg_after", 2, p_print_basic_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_std_instruction_msg_after", 2, p_print_std_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_standard_instruction_msg_after", 2, p_print_standard_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_instruction", 3, p_print_instruction3, SafePredFlag); Yap_InitCPred("print_basic_instruction", 3, p_print_basic_instruction3, SafePredFlag); Yap_InitCPred("print_std_instruction", 3, p_print_std_instruction3, SafePredFlag); Yap_InitCPred("print_standard_instruction", 3, p_print_standard_instruction3, SafePredFlag); Yap_InitCPred("print_profiled_instruction", 1, p_print_profiled_instruction, SafePredFlag); Yap_InitCPred("print_traced_instruction", 1, p_print_traced_instruction, SafePredFlag); Yap_InitCPred("print_pfd_instruction", 1, p_print_pfd_instruction, SafePredFlag); Yap_InitCPred("print_profiled_instruction_msg_before", 2, p_print_profiled_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_traced_instruction_msg_before", 2, p_print_traced_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_pfd_instruction_msg_before", 2, p_print_pfd_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_profiled_instruction_msg_after", 2, p_print_profiled_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_traced_instruction_msg_after", 2, p_print_traced_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_pfd_instruction_msg_after", 2, p_print_pfd_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_profiled_instruction", 3, p_print_profiled_instruction3, SafePredFlag); Yap_InitCPred("print_traced_instruction", 3, p_print_traced_instruction3, SafePredFlag); Yap_InitCPred("print_pfd_instruction", 3, p_print_pfd_instruction3, SafePredFlag); Yap_InitCPred("print_native_instruction", 1, p_print_native_instruction, SafePredFlag); Yap_InitCPred("print_ntv_instruction", 1, p_print_ntv_instruction, SafePredFlag); Yap_InitCPred("print_native_instruction_msg_before", 2, p_print_native_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_ntv_instruction_msg_before", 2, p_print_ntv_instruction_msg_before, SafePredFlag); Yap_InitCPred("print_native_instruction_msg_after", 2, p_print_native_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_ntv_instruction_msg_after", 2, p_print_ntv_instruction_msg_after, SafePredFlag); Yap_InitCPred("print_native_instruction", 3, p_print_native_instruction3, SafePredFlag); Yap_InitCPred("print_ntv_instruction", 3, p_print_ntv_instruction3, SafePredFlag); Yap_InitCPred("no_print_basic_block", 1, p_no_print_basic_block, SafePredFlag); Yap_InitCPred("no_print_basicblock", 1, p_no_print_basicblock, SafePredFlag); Yap_InitCPred("no_print_bb", 1, p_no_print_bb, SafePredFlag); Yap_InitCPred("print_basic_block", 1, p_print_basic_block, SafePredFlag); Yap_InitCPred("print_basicblock", 1, p_print_basicblock, SafePredFlag); Yap_InitCPred("print_bb", 1, p_print_bb, SafePredFlag); Yap_InitCPred("print_basic_block_msg_before", 2, p_print_basic_block_msg_before, SafePredFlag); Yap_InitCPred("print_basicblock_msg_before", 2, p_print_basicblock_msg_before, SafePredFlag); Yap_InitCPred("print_bb_msg_before", 2, p_print_bb_msg_before, SafePredFlag); Yap_InitCPred("print_basic_block_msg_after", 2, p_print_basic_block_msg_after, SafePredFlag); Yap_InitCPred("print_basicblock_msg_after", 2, p_print_basicblock_msg_after, SafePredFlag); Yap_InitCPred("print_bb_msg_after", 2, p_print_bb_msg_after, SafePredFlag); Yap_InitCPred("print_basic_block", 3, p_print_basic_block3, SafePredFlag); Yap_InitCPred("print_basicblock", 3, p_print_basicblock3, SafePredFlag); Yap_InitCPred("print_bb", 3, p_print_bb3, SafePredFlag); Yap_InitCPred("print_native_basic_block", 1, p_print_native_basic_block, SafePredFlag); Yap_InitCPred("print_native_basicblock", 1, p_print_native_basicblock, SafePredFlag); Yap_InitCPred("print_native_bb", 1, p_print_native_bb, SafePredFlag); Yap_InitCPred("print_native_basic_block_msg_before", 2, p_print_native_basic_block_msg_before, SafePredFlag); Yap_InitCPred("print_native_basicblock_msg_before", 2, p_print_native_basicblock_msg_before, SafePredFlag); Yap_InitCPred("print_native_bb_msg_before", 2, p_print_native_bb_msg_before, SafePredFlag); Yap_InitCPred("print_native_basic_block_msg_after", 2, p_print_native_basic_block_msg_after, SafePredFlag); Yap_InitCPred("print_native_basicblock_msg_after", 2, p_print_native_basicblock_msg_after, SafePredFlag); Yap_InitCPred("print_native_bb_msg_after", 2, p_print_native_bb_msg_after, SafePredFlag); Yap_InitCPred("print_native_basic_block", 3, p_print_native_basic_block3, SafePredFlag); Yap_InitCPred("print_native_basicblock", 3, p_print_native_basicblock3, SafePredFlag); Yap_InitCPred("print_native_bb", 3, p_print_native_bb3, SafePredFlag); Yap_InitCPred("no_print_clause", 0, p_no_print_clause, SafePredFlag); Yap_InitCPred("print_clause", 1, p_print_clause, SafePredFlag); Yap_InitCPred("no_print_intermediate", 0, p_no_print_intermediate, SafePredFlag); Yap_InitCPred("print_intermediate", 0, p_print_intermediate, SafePredFlag); Yap_InitCPred("print_intermediate_to_std", 0, p_print_intermediate_to_std, SafePredFlag); Yap_InitCPred("print_intermediate_to_std", 1, p_print_intermediate_to_std1, SafePredFlag); Yap_InitCPred("print_intermediate_to_file", 0, p_print_intermediate_to_file, SafePredFlag); Yap_InitCPred("print_intermediate_to_file", 1, p_print_intermediate_to_file1, SafePredFlag); Yap_InitCPred("no_print_llva", 0, p_no_print_llva, SafePredFlag); Yap_InitCPred("print_llva_before", 0, p_print_llva_before, SafePredFlag); Yap_InitCPred("print_llva_after", 0, p_print_llva_after, SafePredFlag); Yap_InitCPred("no_print_me", 1, p_no_print_me, SafePredFlag); Yap_InitCPred("print_me", 2, p_print_me, SafePredFlag); Yap_InitCPred("default_debug", 0, p_default_debug, SafePredFlag); Yap_InitCPred("print_default_predicate_msgs", 0, p_print_default_predicate_msgs, SafePredFlag); Yap_InitCPred("print_all_predicate_msgs", 0, p_print_all_predicate_msgs, SafePredFlag); Yap_InitCPred("print_info_predicate_msgs", 0, p_print_info_predicate_msgs, SafePredFlag); Yap_InitCPred("print_success_predicate_msgs", 0, p_print_success_predicate_msgs, SafePredFlag); Yap_InitCPred("print_warning_predicate_msgs", 0, p_print_warning_predicate_msgs, SafePredFlag); Yap_InitCPred("print_error_predicate_msgs", 0, p_print_error_predicate_msgs, SafePredFlag); Yap_InitCPred("no_print_all_predicate_msgs", 0, p_no_print_all_predicate_msgs, SafePredFlag); Yap_InitCPred("no_print_info_predicate_msgs", 0, p_no_print_info_predicate_msgs, SafePredFlag); Yap_InitCPred("no_print_success_predicate_msgs", 0, p_no_print_success_predicate_msgs, SafePredFlag); Yap_InitCPred("no_print_warning_predicate_msgs", 0, p_no_print_warning_predicate_msgs, SafePredFlag); Yap_InitCPred("no_print_error_predicate_msgs", 0, p_no_print_error_predicate_msgs, SafePredFlag); Yap_InitCPred("print_predicate_msgs", 1, p_print_predicate_msgs, SafePredFlag); Yap_InitCPred("exit_on_warning", 0, p_exit_on_warning, SafePredFlag); Yap_InitCPred("disable_on_warning", 0, p_disable_on_warning, SafePredFlag); Yap_InitCPred("exit_on_error", 0, p_exit_on_error, SafePredFlag); Yap_InitCPred("no_exit_on_warning", 0, p_no_exit_on_warning, SafePredFlag); Yap_InitCPred("enable_on_warning", 0, p_enable_on_warning, SafePredFlag); Yap_InitCPred("no_exit_on_error", 0, p_no_exit_on_error, SafePredFlag); }