2477 lines
84 KiB
C
2477 lines
84 KiB
C
/*************************************************************************
|
|
* *
|
|
* 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);
|
|
}
|