StgPtr
printStackObj( StgPtr sp )
{
/*debugBelch("Stack[%d] = ", &stgStack[STACK_SIZE] - sp); */
StgClosure* c = (StgClosure*)(*sp);
printPtr((StgPtr)*sp);
if (c == (StgClosure*)&stg_ctoi_R1p_info) {
debugBelch("\t\t\tstg_ctoi_ret_R1p_info\n" );
} else
if (c == (StgClosure*)&stg_ctoi_R1n_info) {
debugBelch("\t\t\tstg_ctoi_ret_R1n_info\n" );
} else
if (c == (StgClosure*)&stg_ctoi_F1_info) {
debugBelch("\t\t\tstg_ctoi_ret_F1_info\n" );
} else
if (c == (StgClosure*)&stg_ctoi_D1_info) {
debugBelch("\t\t\tstg_ctoi_ret_D1_info\n" );
} else
if (c == (StgClosure*)&stg_ctoi_V_info) {
debugBelch("\t\t\tstg_ctoi_ret_V_info\n" );
} else
if (get_itbl(c)->type == BCO) {
debugBelch("\t\t\t");
debugBelch("BCO(...)\n");
}
else {
debugBelch("\t\t\t");
printClosure ( (StgClosure*)(*sp));
}
sp += 1;
return sp;
}
STATIC_INLINE void
printStdObjHdr( const StgClosure *obj, char* tag )
{
debugBelch("%s(",tag);
printPtr((StgPtr)obj->header.info);
#ifdef PROFILING
debugBelch(", %s", obj->header.prof.ccs->cc->label);
#endif
}
static void
printSmallBitmap( StgPtr spBottom, StgPtr payload, StgWord bitmap, nat size )
{
nat i;
for(i = 0; i < size; i++, bitmap >>= 1 ) {
debugBelch(" stk[%ld] (%p) = ", (long)(spBottom-(payload+i)), payload+i);
if ((bitmap & 1) == 0) {
printPtr((P_)payload[i]);
debugBelch("\n");
} else {
debugBelch("Word# %" FMT_Word "\n", (W_)payload[i]);
}
}
}
static void
printThunkPayload( StgThunk *obj )
{
StgWord i, j;
const StgInfoTable* info;
info = get_itbl((StgClosure *)obj);
for (i = 0; i < info->layout.payload.ptrs; ++i) {
debugBelch(", ");
printPtr((StgPtr)obj->payload[i]);
}
for (j = 0; j < info->layout.payload.nptrs; ++j) {
debugBelch(", %pd#",obj->payload[i+j]);
}
debugBelch(")\n");
}
static void
printLargeBitmap( StgPtr spBottom, StgPtr payload, StgLargeBitmap* large_bitmap, nat size )
{
StgWord bmp;
nat i, j;
i = 0;
for (bmp=0; i < size; bmp++) {
StgWord bitmap = large_bitmap->bitmap[bmp];
j = 0;
for(; i < size && j < BITS_IN(W_); j++, i++, bitmap >>= 1 ) {
debugBelch(" stk[%" FMT_Word "] (%p) = ", (W_)(spBottom-(payload+i)), payload+i);
if ((bitmap & 1) == 0) {
printPtr((P_)payload[i]);
debugBelch("\n");
} else {
debugBelch("Word# %" FMT_Word "\n", (W_)payload[i]);
}
}
}
}
std::string
Basics::
print(size_t indent) const
{
std::string i0(indent * 4, ' ');
std::string i1(++indent * 4, ' ');
std::stringstream ss;
ss << "{\n"
<< i1 << "boolean: " << boolean << '\n'
<< i1 << "integer: " << integer << '\n'
<< i1 << "floating: " << floating << '\n'
<< i1 << "string: " << string << '\n'
<< i1 << "stringPtr: " << printPtr(stringPtr) << '\n'
<< i1 << "stringShared: " << printPtr(stringShared) << '\n'
<< i1 << "nullPtr: " << printPtr(nullPtr) << '\n'
<< i1 << "nullShared: " << printPtr(nullShared) << '\n'
<< i1 << "skip: " << skip << '\n'
<< i1 << "alias: " << alias << '\n'
<< i1 << "custom: " << custom.print() << '\n';
ss << i1 << "vector: " << vector.size() << "[ ";
for (const auto& item : vector) ss << item << ' ';
ss << "]\n";
ss << i1 << "vectorPtr: " << vectorPtr.size() << "[ ";
for (const auto& item : vectorPtr) ss << printPtr(item) << ' ';
ss << "]\n";
ss << i1 << "map: " << map.size() << "[ ";
for (const auto& entry : map) ss << entry.first << ':' << entry.second << ' ';
ss << "]\n";
ss << i1 << "mapPtr: " << mapPtr.size() << "[ ";
for (const auto& entry : mapPtr) ss << entry.first << ':' << printPtr(entry.second) << ' ';
ss << "]\n";
ss << i1 << "next: " << (next ? next->print(indent) : "nil") << '\n';
ss << i0 << "}";
return ss.str();
}
void printObj( StgClosure *obj )
{
debugBelch("Object "); printPtr((StgPtr)obj); debugBelch(" = ");
printClosure(obj);
}
void
printClosure( const StgClosure *obj )
{
const StgInfoTable *info;
obj = UNTAG_CONST_CLOSURE(obj);
info = get_itbl(obj);
switch ( info->type ) {
case INVALID_OBJECT:
barf("Invalid object");
case CONSTR:
case CONSTR_1_0: case CONSTR_0_1:
case CONSTR_1_1: case CONSTR_0_2: case CONSTR_2_0:
case CONSTR_STATIC:
case CONSTR_NOCAF_STATIC:
{
StgWord i, j;
const StgConInfoTable *con_info = get_con_itbl (obj);
debugBelch("%s(", GET_CON_DESC(con_info));
for (i = 0; i < info->layout.payload.ptrs; ++i) {
if (i != 0) debugBelch(", ");
printPtr((StgPtr)obj->payload[i]);
}
for (j = 0; j < info->layout.payload.nptrs; ++j) {
if (i != 0 || j != 0) debugBelch(", ");
debugBelch("%p#", obj->payload[i+j]);
}
debugBelch(")\n");
break;
}
case FUN:
case FUN_1_0: case FUN_0_1:
case FUN_1_1: case FUN_0_2: case FUN_2_0:
case FUN_STATIC:
debugBelch("FUN/%d(",(int)itbl_to_fun_itbl(info)->f.arity);
printPtr((StgPtr)obj->header.info);
#ifdef PROFILING
debugBelch(", %s", obj->header.prof.ccs->cc->label);
#endif
printStdObjPayload(obj);
break;
case PRIM:
debugBelch("PRIM(");
printPtr((StgPtr)obj->header.info);
printStdObjPayload(obj);
break;
case MUT_PRIM:
debugBelch("MUT_PRIM(");
printPtr((StgPtr)obj->header.info);
printStdObjPayload(obj);
break;
case THUNK:
case THUNK_1_0: case THUNK_0_1:
case THUNK_1_1: case THUNK_0_2: case THUNK_2_0:
case THUNK_STATIC:
/* ToDo: will this work for THUNK_STATIC too? */
#ifdef PROFILING
printThunkObject((StgThunk *)obj,GET_PROF_DESC(info));
#else
printThunkObject((StgThunk *)obj,"THUNK");
#endif
break;
case THUNK_SELECTOR:
printStdObjHdr(obj, "THUNK_SELECTOR");
debugBelch(", %p)\n", ((StgSelector *)obj)->selectee);
break;
case BCO:
disassemble( (StgBCO*)obj );
break;
case AP:
{
StgAP* ap = (StgAP*)obj;
StgWord i;
debugBelch("AP("); printPtr((StgPtr)ap->fun);
for (i = 0; i < ap->n_args; ++i) {
debugBelch(", ");
printPtr((P_)ap->payload[i]);
}
debugBelch(")\n");
break;
}
case PAP:
{
StgPAP* pap = (StgPAP*)obj;
StgWord i;
debugBelch("PAP/%d(",(int)pap->arity);
printPtr((StgPtr)pap->fun);
for (i = 0; i < pap->n_args; ++i) {
debugBelch(", ");
printPtr((StgPtr)pap->payload[i]);
}
debugBelch(")\n");
break;
}
case AP_STACK:
{
StgAP_STACK* ap = (StgAP_STACK*)obj;
StgWord i;
debugBelch("AP_STACK("); printPtr((StgPtr)ap->fun);
for (i = 0; i < ap->size; ++i) {
debugBelch(", ");
printPtr((P_)ap->payload[i]);
}
debugBelch(")\n");
break;
}
case IND:
debugBelch("IND(");
printPtr((StgPtr)((StgInd*)obj)->indirectee);
debugBelch(")\n");
break;
case IND_STATIC:
debugBelch("IND_STATIC(");
printPtr((StgPtr)((StgInd*)obj)->indirectee);
debugBelch(")\n");
break;
case BLACKHOLE:
debugBelch("BLACKHOLE(");
printPtr((StgPtr)((StgInd*)obj)->indirectee);
debugBelch(")\n");
break;
/* Cannot happen -- use default case.
case RET_BCO:
case RET_SMALL:
case RET_BIG:
case RET_FUN:
*/
case UPDATE_FRAME:
{
StgUpdateFrame* u = (StgUpdateFrame*)obj;
debugBelch("%s(", info_update_frame(obj));
printPtr((StgPtr)GET_INFO((StgClosure *)u));
debugBelch(",");
printPtr((StgPtr)u->updatee);
debugBelch(")\n");
break;
}
case CATCH_FRAME:
{
StgCatchFrame* u = (StgCatchFrame*)obj;
debugBelch("CATCH_FRAME(");
printPtr((StgPtr)GET_INFO((StgClosure *)u));
debugBelch(",");
printPtr((StgPtr)u->handler);
debugBelch(")\n");
break;
}
case UNDERFLOW_FRAME:
{
StgUnderflowFrame* u = (StgUnderflowFrame*)obj;
debugBelch("UNDERFLOW_FRAME(");
printPtr((StgPtr)u->next_chunk);
debugBelch(")\n");
break;
}
case STOP_FRAME:
{
StgStopFrame* u = (StgStopFrame*)obj;
debugBelch("STOP_FRAME(");
printPtr((StgPtr)GET_INFO((StgClosure *)u));
debugBelch(")\n");
break;
}
case ARR_WORDS:
{
StgWord i;
debugBelch("ARR_WORDS(\"");
for (i=0; i<arr_words_words((StgArrBytes *)obj); i++)
debugBelch("%" FMT_Word, (W_)((StgArrBytes *)obj)->payload[i]);
debugBelch("\")\n");
break;
}
case MUT_ARR_PTRS_CLEAN:
debugBelch("MUT_ARR_PTRS_CLEAN(size=%" FMT_Word ")\n", (W_)((StgMutArrPtrs *)obj)->ptrs);
break;
case MUT_ARR_PTRS_DIRTY:
debugBelch("MUT_ARR_PTRS_DIRTY(size=%" FMT_Word ")\n", (W_)((StgMutArrPtrs *)obj)->ptrs);
break;
case MUT_ARR_PTRS_FROZEN:
debugBelch("MUT_ARR_PTRS_FROZEN(size=%" FMT_Word ")\n", (W_)((StgMutArrPtrs *)obj)->ptrs);
break;
case SMALL_MUT_ARR_PTRS_CLEAN:
debugBelch("SMALL_MUT_ARR_PTRS_CLEAN(size=%" FMT_Word ")\n",
(W_)((StgSmallMutArrPtrs *)obj)->ptrs);
break;
case SMALL_MUT_ARR_PTRS_DIRTY:
debugBelch("SMALL_MUT_ARR_PTRS_DIRTY(size=%" FMT_Word ")\n",
(W_)((StgSmallMutArrPtrs *)obj)->ptrs);
break;
case SMALL_MUT_ARR_PTRS_FROZEN:
debugBelch("SMALL_MUT_ARR_PTRS_FROZEN(size=%" FMT_Word ")\n",
(W_)((StgSmallMutArrPtrs *)obj)->ptrs);
break;
case MVAR_CLEAN:
case MVAR_DIRTY:
{
StgMVar* mv = (StgMVar*)obj;
debugBelch("MVAR(head=%p, tail=%p, value=%p)\n", mv->head, mv->tail, mv->value);
break;
}
case TVAR:
{
StgTVar* tv = (StgTVar*)obj;
debugBelch("TVAR(value=%p, wq=%p, num_updates=%" FMT_Word ")\n", tv->current_value, tv->first_watch_queue_entry, tv->num_updates);
break;
}
case MUT_VAR_CLEAN:
{
StgMutVar* mv = (StgMutVar*)obj;
debugBelch("MUT_VAR_CLEAN(var=%p)\n", mv->var);
break;
}
case MUT_VAR_DIRTY:
{
StgMutVar* mv = (StgMutVar*)obj;
debugBelch("MUT_VAR_DIRTY(var=%p)\n", mv->var);
break;
}
case WEAK:
debugBelch("WEAK(");
debugBelch(" key=%p value=%p finalizer=%p",
(StgPtr)(((StgWeak*)obj)->key),
(StgPtr)(((StgWeak*)obj)->value),
(StgPtr)(((StgWeak*)obj)->finalizer));
debugBelch(")\n");
/* ToDo: chase 'link' ? */
break;
case TSO:
debugBelch("TSO(");
debugBelch("%lu (%p)",(unsigned long)(((StgTSO*)obj)->id), (StgTSO*)obj);
debugBelch(")\n");
break;
case STACK:
debugBelch("STACK");
break;
#if 0
/* Symptomatic of a problem elsewhere, have it fall-through & fail */
case EVACUATED:
debugBelch("EVACUATED(");
printClosure((StgEvacuated*)obj->evacuee);
debugBelch(")\n");
break;
#endif
case COMPACT_NFDATA:
debugBelch("COMPACT_NFDATA(size=%" FMT_Word ")\n",
(W_)((StgCompactNFData *)obj)->totalDataW * sizeof(W_));
break;
default:
//barf("printClosure %d",get_itbl(obj)->type);
debugBelch("*** printClosure: unknown type %d ****\n",
(int)get_itbl(obj)->type );
barf("printClosure %d",get_itbl(obj)->type);
return;
}
}
int
disInstr ( StgBCO *bco, int pc )
{
int i;
StgWord16 instr;
StgWord16* instrs = (StgWord16*)(bco->instrs->payload);
StgArrWords* literal_arr = bco->literals;
StgWord* literals = (StgWord*)(&literal_arr->payload[0]);
StgMutArrPtrs* ptrs_arr = bco->ptrs;
StgPtr* ptrs = (StgPtr*)(&ptrs_arr->payload[0]);
instr = instrs[pc++];
if (instr & bci_FLAG_LARGE_ARGS) {
debugBelch ("LARGE ");
}
#define BCO_NEXT instrs[pc++]
#define BCO_NEXT_32 (pc += 2)
#define BCO_READ_NEXT_32 (BCO_NEXT_32, (((StgWord) instrs[pc-2]) << 16) \
+ ( (StgWord) instrs[pc-1]))
#define BCO_NEXT_64 (pc += 4)
#define BCO_READ_NEXT_64 (BCO_NEXT_64, (((StgWord) instrs[pc-4]) << 48) \
+ (((StgWord) instrs[pc-3]) << 32) \
+ (((StgWord) instrs[pc-2]) << 16) \
+ ( (StgWord) instrs[pc-1]))
#if WORD_SIZE_IN_BITS == 32
#define BCO_NEXT_WORD BCO_NEXT_32
#define BCO_READ_NEXT_WORD BCO_READ_NEXT_32
#elif WORD_SIZE_IN_BITS == 64
#define BCO_NEXT_WORD BCO_NEXT_64
#define BCO_READ_NEXT_WORD BCO_READ_NEXT_64
#else
#error Cannot cope with WORD_SIZE_IN_BITS being nether 32 nor 64
#endif
#define BCO_GET_LARGE_ARG ((instr & bci_FLAG_LARGE_ARGS) ? BCO_READ_NEXT_WORD : BCO_NEXT)
switch (instr & 0xff) {
case bci_BRK_FUN:
debugBelch ("BRK_FUN " ); printPtr( ptrs[instrs[pc]] );
debugBelch (" %d ", instrs[pc+1]); printPtr( ptrs[instrs[pc+2]] ); debugBelch("\n" );
pc += 3;
break;
case bci_SWIZZLE:
debugBelch("SWIZZLE stkoff %d by %d\n",
instrs[pc], (signed int)instrs[pc+1]);
pc += 2; break;
case bci_CCALL:
debugBelch("CCALL marshaller at 0x%" FMT_Word "\n",
literals[instrs[pc]] );
pc += 1; break;
case bci_STKCHECK: {
StgWord stk_words_reqd = BCO_GET_LARGE_ARG + 1;
debugBelch("STKCHECK %" FMT_Word "\n", (W_)stk_words_reqd );
break;
}
case bci_PUSH_L:
debugBelch("PUSH_L %d\n", instrs[pc] );
pc += 1; break;
case bci_PUSH_LL:
debugBelch("PUSH_LL %d %d\n", instrs[pc], instrs[pc+1] );
pc += 2; break;
case bci_PUSH_LLL:
debugBelch("PUSH_LLL %d %d %d\n", instrs[pc], instrs[pc+1],
instrs[pc+2] );
pc += 3; break;
case bci_PUSH_G:
debugBelch("PUSH_G " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n" );
pc += 1; break;
case bci_PUSH_ALTS:
debugBelch("PUSH_ALTS " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_ALTS_P:
debugBelch("PUSH_ALTS_P " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_ALTS_N:
debugBelch("PUSH_ALTS_N " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_ALTS_F:
debugBelch("PUSH_ALTS_F " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_ALTS_D:
debugBelch("PUSH_ALTS_D " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_ALTS_L:
debugBelch("PUSH_ALTS_L " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_ALTS_V:
debugBelch("PUSH_ALTS_V " ); printPtr( ptrs[instrs[pc]] );
debugBelch("\n");
pc += 1; break;
case bci_PUSH_UBX:
debugBelch("PUSH_UBX ");
for (i = 0; i < instrs[pc+1]; i++)
debugBelch("0x%" FMT_Word " ", literals[i + instrs[pc]] );
debugBelch("\n");
pc += 2; break;
case bci_PUSH_APPLY_N:
debugBelch("PUSH_APPLY_N\n");
break;
case bci_PUSH_APPLY_V:
debugBelch("PUSH_APPLY_V\n");
break;
case bci_PUSH_APPLY_F:
debugBelch("PUSH_APPLY_F\n");
break;
case bci_PUSH_APPLY_D:
debugBelch("PUSH_APPLY_D\n");
break;
case bci_PUSH_APPLY_L:
debugBelch("PUSH_APPLY_L\n");
break;
case bci_PUSH_APPLY_P:
debugBelch("PUSH_APPLY_P\n");
break;
case bci_PUSH_APPLY_PP:
debugBelch("PUSH_APPLY_PP\n");
break;
case bci_PUSH_APPLY_PPP:
debugBelch("PUSH_APPLY_PPP\n");
break;
case bci_PUSH_APPLY_PPPP:
debugBelch("PUSH_APPLY_PPPP\n");
break;
case bci_PUSH_APPLY_PPPPP:
debugBelch("PUSH_APPLY_PPPPP\n");
break;
case bci_PUSH_APPLY_PPPPPP:
debugBelch("PUSH_APPLY_PPPPPP\n");
break;
case bci_SLIDE:
debugBelch("SLIDE %d down by %d\n", instrs[pc], instrs[pc+1] );
pc += 2; break;
case bci_ALLOC_AP:
debugBelch("ALLOC_AP %d words\n", instrs[pc] );
pc += 1; break;
case bci_ALLOC_AP_NOUPD:
debugBelch("ALLOC_AP_NOUPD %d words\n", instrs[pc] );
pc += 1; break;
case bci_ALLOC_PAP:
debugBelch("ALLOC_PAP %d arity, %d words\n",
instrs[pc], instrs[pc+1] );
pc += 2; break;
case bci_MKAP:
debugBelch("MKAP %d words, %d stkoff\n", instrs[pc+1],
instrs[pc] );
pc += 2; break;
case bci_MKPAP:
debugBelch("MKPAP %d words, %d stkoff\n", instrs[pc+1],
instrs[pc] );
pc += 2; break;
case bci_UNPACK:
debugBelch("UNPACK %d\n", instrs[pc] );
pc += 1; break;
case bci_PACK:
debugBelch("PACK %d words with itbl ", instrs[pc+1] );
printPtr( (StgPtr)literals[instrs[pc]] );
debugBelch("\n");
pc += 2; break;
case bci_TESTLT_I: {
unsigned int discr = BCO_NEXT;
int failto = BCO_GET_LARGE_ARG;
debugBelch("TESTLT_I %" FMT_Int ", fail to %d\n", literals[discr], failto);
break;
}
case bci_TESTEQ_I:
debugBelch("TESTEQ_I %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
instrs[pc+1]);
pc += 2; break;
case bci_TESTLT_F:
debugBelch("TESTLT_F %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
instrs[pc+1]);
pc += 2; break;
case bci_TESTEQ_F:
debugBelch("TESTEQ_F %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
instrs[pc+1]);
pc += 2; break;
case bci_TESTLT_D:
debugBelch("TESTLT_D %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
instrs[pc+1]);
pc += 2; break;
case bci_TESTEQ_D:
debugBelch("TESTEQ_D %" FMT_Int ", fail to %d\n", literals[instrs[pc]],
instrs[pc+1]);
pc += 2; break;
case bci_TESTLT_P:
debugBelch("TESTLT_P %d, fail to %d\n", instrs[pc],
instrs[pc+1]);
pc += 2; break;
case bci_TESTEQ_P:
debugBelch("TESTEQ_P %d, fail to %d\n", instrs[pc],
instrs[pc+1]);
pc += 2; break;
case bci_CASEFAIL:
debugBelch("CASEFAIL\n" );
break;
case bci_JMP:
debugBelch("JMP to %d\n", instrs[pc]);
pc += 1; break;
case bci_ENTER:
debugBelch("ENTER\n");
break;
case bci_RETURN:
debugBelch("RETURN\n" );
break;
case bci_RETURN_P:
debugBelch("RETURN_P\n" );
break;
case bci_RETURN_N:
debugBelch("RETURN_N\n" );
break;
case bci_RETURN_F:
debugBelch("RETURN_F\n" );
break;
case bci_RETURN_D:
debugBelch("RETURN_D\n" );
break;
case bci_RETURN_L:
debugBelch("RETURN_L\n" );
break;
case bci_RETURN_V:
debugBelch("RETURN_V\n" );
break;
default:
barf("disInstr: unknown opcode %u", (unsigned int) instr);
}
return pc;
}
void
printStackChunk( StgPtr sp, StgPtr spBottom )
{
StgWord bitmap;
const StgInfoTable *info;
ASSERT(sp <= spBottom);
for (; sp < spBottom; sp += stack_frame_sizeW((StgClosure *)sp)) {
info = get_itbl((StgClosure *)sp);
switch (info->type) {
case UPDATE_FRAME:
case CATCH_FRAME:
case UNDERFLOW_FRAME:
case STOP_FRAME:
printObj((StgClosure*)sp);
continue;
case RET_DYN:
{
StgRetDyn* r;
StgPtr p;
StgWord dyn;
nat size;
r = (StgRetDyn *)sp;
dyn = r->liveness;
debugBelch("RET_DYN (%p)\n", r);
p = (P_)(r->payload);
printSmallBitmap(spBottom, sp,
RET_DYN_LIVENESS(r->liveness),
RET_DYN_BITMAP_SIZE);
p += RET_DYN_BITMAP_SIZE + RET_DYN_NONPTR_REGS_SIZE;
for (size = RET_DYN_NONPTRS(dyn); size > 0; size--) {
debugBelch(" stk[%ld] (%p) = ", (long)(spBottom-p), p);
debugBelch("Word# %ld\n", (long)*p);
p++;
}
for (size = RET_DYN_PTRS(dyn); size > 0; size--) {
debugBelch(" stk[%ld] (%p) = ", (long)(spBottom-p), p);
printPtr(p);
p++;
}
continue;
}
case RET_SMALL:
debugBelch("RET_SMALL (%p)\n", info);
bitmap = info->layout.bitmap;
printSmallBitmap(spBottom, sp+1,
BITMAP_BITS(bitmap), BITMAP_SIZE(bitmap));
continue;
case RET_BCO: {
StgBCO *bco;
bco = ((StgBCO *)sp[1]);
debugBelch("RET_BCO (%p)\n", sp);
printLargeBitmap(spBottom, sp+2,
BCO_BITMAP(bco), BCO_BITMAP_SIZE(bco));
continue;
}
case RET_BIG:
barf("todo");
case RET_FUN:
{
StgFunInfoTable *fun_info;
StgRetFun *ret_fun;
ret_fun = (StgRetFun *)sp;
fun_info = get_fun_itbl(ret_fun->fun);
debugBelch("RET_FUN (%p) (type=%d)\n", ret_fun->fun, (int)fun_info->f.fun_type);
switch (fun_info->f.fun_type) {
case ARG_GEN:
printSmallBitmap(spBottom, sp+2,
BITMAP_BITS(fun_info->f.b.bitmap),
BITMAP_SIZE(fun_info->f.b.bitmap));
break;
case ARG_GEN_BIG:
printLargeBitmap(spBottom, sp+2,
GET_FUN_LARGE_BITMAP(fun_info),
GET_FUN_LARGE_BITMAP(fun_info)->size);
break;
default:
printSmallBitmap(spBottom, sp+2,
BITMAP_BITS(stg_arg_bitmaps[fun_info->f.fun_type]),
BITMAP_SIZE(stg_arg_bitmaps[fun_info->f.fun_type]));
break;
}
continue;
}
default:
debugBelch("unknown object %d\n", (int)info->type);
barf("printStackChunk");
}
}
}
int main(int argc, char* argv[])
{
std::string url = "http://127.0.0.1:8080";
std::string username;
std::string password;
int c=0;
while ((c = getopt (argc, argv, "hu:p:")) != -1)
{
switch (c)
{
case 'u': username = optarg; break;
case 'p': password = optarg; break;
case 'h':
std::cout << argv[0] << " [-u username] [-p password] url" << std::endl;
exit(0);
break;
}
}
if (optind<argc)
{
url = argv[optind];
}
std::cout << "Connecting to " << url << std::endl;
// create connection to devicemgmt.wsdl server
DeviceBindingProxy deviceProxy(url.c_str());
// call Device::GetDeviceInformation
std::cout << "=>Device::GetDeviceInformation" << std::endl;
_tds__GetDeviceInformation tds__GetDeviceInformation;
_tds__GetDeviceInformationResponse tds__GetDeviceInformationResponse;
addSecurity(deviceProxy.soap, username, password);
if (deviceProxy.GetDeviceInformation(&tds__GetDeviceInformation, &tds__GetDeviceInformationResponse) == SOAP_OK)
{
std::cout << "\tManufacturer:" << tds__GetDeviceInformationResponse.Manufacturer << std::endl;
}
else
{
deviceProxy.soap_stream_fault(std::cerr);
}
// call Device::GetHostname
std::cout << "=>Device::GetHostname" << std::endl;
_tds__GetHostname tds__GetHostname;
_tds__GetHostnameResponse tds__GetHostnameResponse;
addSecurity(deviceProxy.soap, username, password);
if (deviceProxy.GetHostname(&tds__GetHostname, &tds__GetHostnameResponse) == SOAP_OK)
{
std::cout << "\tHostname:" << tds__GetHostnameResponse.HostnameInformation->Name->c_str() << std::endl;
}
else
{
deviceProxy.soap_stream_fault(std::cerr);
}
// call Device::GetNetworkInterfaces
std::cout << "=>Device::GetNetworkInterfaces" << std::endl;
_tds__GetNetworkInterfaces tds__GetNetworkInterfaces;
_tds__GetNetworkInterfacesResponse tds__GetNetworkInterfacesResponse;
addSecurity(deviceProxy.soap, username, password);
if (deviceProxy.GetNetworkInterfaces(&tds__GetNetworkInterfaces, &tds__GetNetworkInterfacesResponse) == SOAP_OK)
{
for (auto iface : tds__GetNetworkInterfacesResponse.NetworkInterfaces)
{
if (iface->Info != NULL)
{
std::cout << "\t" << iface->Info->Name->c_str() << " " << iface->Info->HwAddress << std::endl;
}
if ( (iface->IPv4 != NULL) && (iface->IPv4->Config != NULL) )
{
for (auto addr : iface->IPv4->Config->Manual)
{
std::cout << "\tIP:" << addr->Address << "/" << addr->PrefixLength << std::endl;
}
}
}
}
else
{
deviceProxy.soap_stream_fault(std::cerr);
}
// call Device::GetServices
std::cout << "=>Device::GetServices" << std::endl;
_tds__GetServices tds__GetServices;
tds__GetServices.IncludeCapability = true;
_tds__GetServicesResponse tds__GetServicesResponse;
addSecurity(deviceProxy.soap, username, password);
if (deviceProxy.GetServices(&tds__GetServices, &tds__GetServicesResponse) == SOAP_OK)
{
for (auto service : tds__GetServicesResponse.Service)
{
std::cout << "\tns:" << service->Namespace << " " << service->XAddr << " Version:" << service->Version->Major << "." << service->Version->Minor << std::endl;
if (service->Capabilities)
{
std::cout << "\t" << service->Capabilities->__any << std::endl;
}
}
}
// call Device::GetCapabilities
std::cout << "=>Device::GetCapabilities" << std::endl;
_tds__GetCapabilities tds__GetCapabilities;
_tds__GetCapabilitiesResponse tds__GetCapabilitiesResponse;
addSecurity(deviceProxy.soap, username, password);
if (deviceProxy.GetCapabilities(&tds__GetCapabilities, &tds__GetCapabilitiesResponse) == SOAP_OK)
{
std::unique_ptr<ImagingBindingProxy> imagingProxy;
if ( (tds__GetCapabilitiesResponse.Capabilities->Extension != NULL) && (tds__GetCapabilitiesResponse.Capabilities->Imaging != NULL) )
{
std::cout << "\tImaging Url:" << tds__GetCapabilitiesResponse.Capabilities->Imaging->XAddr << std::endl;
imagingProxy.reset(new ImagingBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Imaging->XAddr.c_str()));
}
std::unique_ptr<ReplayBindingProxy> replayProxy;
if ( (tds__GetCapabilitiesResponse.Capabilities->Extension != NULL) && (tds__GetCapabilitiesResponse.Capabilities->Extension->Replay != NULL) )
{
std::cout << "\tReplay Url:" << tds__GetCapabilitiesResponse.Capabilities->Extension->Replay->XAddr << std::endl;
replayProxy.reset(new ReplayBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Extension->Replay->XAddr.c_str()));
}
std::unique_ptr<MediaBindingProxy> mediaProxy;
if (tds__GetCapabilitiesResponse.Capabilities->Media != NULL)
{
std::cout << "\tMedia Url:" << tds__GetCapabilitiesResponse.Capabilities->Media->XAddr << std::endl;
mediaProxy.reset(new MediaBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Media->XAddr.c_str()));
}
std::unique_ptr<ReceiverBindingProxy> receiverProxy;
if ( (tds__GetCapabilitiesResponse.Capabilities->Extension != NULL) && (tds__GetCapabilitiesResponse.Capabilities->Extension->Receiver != NULL) )
{
std::cout << "\tReceiver Url:" << tds__GetCapabilitiesResponse.Capabilities->Extension->Receiver->XAddr << std::endl;
receiverProxy.reset(new ReceiverBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Extension->Receiver->XAddr.c_str()));
}
std::unique_ptr<RecordingBindingProxy> recordingProxy;
if ( (tds__GetCapabilitiesResponse.Capabilities->Extension != NULL) && (tds__GetCapabilitiesResponse.Capabilities->Extension->Recording != NULL) )
{
std::cout << "\tRecording Url:" << tds__GetCapabilitiesResponse.Capabilities->Extension->Recording->XAddr << std::endl;
recordingProxy.reset(new RecordingBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Extension->Recording->XAddr.c_str()));
}
std::unique_ptr<SearchBindingProxy> searchProxy;
if ( (tds__GetCapabilitiesResponse.Capabilities->Extension != NULL) && (tds__GetCapabilitiesResponse.Capabilities->Extension->Search != NULL) )
{
std::cout << "\tSearch Url:" << tds__GetCapabilitiesResponse.Capabilities->Extension->Search->XAddr << std::endl;
searchProxy.reset (new SearchBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Extension->Search->XAddr.c_str()));
}
std::unique_ptr<EventBindingProxy> eventProxy;
if (tds__GetCapabilitiesResponse.Capabilities->Events != NULL)
{
std::cout << "\tEvent Url:" << tds__GetCapabilitiesResponse.Capabilities->Events->XAddr << std::endl;
eventProxy.reset(new EventBindingProxy(tds__GetCapabilitiesResponse.Capabilities->Events->XAddr.c_str()));
}
if (mediaProxy.get() != NULL)
{
// call Media::GetVideoSources
std::cout << "=>Media::GetVideoSources" << std::endl;
_trt__GetVideoSources trt__GetVideoSources;
_trt__GetVideoSourcesResponse trt__GetVideoSourcesResponse;
addSecurity(mediaProxy->soap, username, password);
if (mediaProxy->GetVideoSources(&trt__GetVideoSources, &trt__GetVideoSourcesResponse) == SOAP_OK)
{
for (auto source : trt__GetVideoSourcesResponse.VideoSources)
{
std::cout << "\t" << source->token;
if (source->Resolution)
{
std::cout << " " << source->Resolution->Width << "x" << source->Resolution->Height;
}
std::cout << std::endl;
_trt__GetVideoEncoderConfiguration trt__GetVideoEncoderConfiguration;
trt__GetVideoEncoderConfiguration.ConfigurationToken = source->token;
_trt__GetVideoEncoderConfigurationResponse trt__GetVideoEncoderConfigurationResponse;
addSecurity(mediaProxy->soap, username, password);
if (mediaProxy->GetVideoEncoderConfiguration(&trt__GetVideoEncoderConfiguration, &trt__GetVideoEncoderConfigurationResponse) == SOAP_OK)
{
std::cout << "\tEncoding:" << trt__GetVideoEncoderConfigurationResponse.Configuration->Encoding << std::endl;
if (trt__GetVideoEncoderConfigurationResponse.Configuration->H264)
{
std::cout << "\tH264Profile:" << trt__GetVideoEncoderConfigurationResponse.Configuration->H264->H264Profile << std::endl;
}
if (trt__GetVideoEncoderConfigurationResponse.Configuration->Resolution)
{
std::cout << "\tResolution:" << trt__GetVideoEncoderConfigurationResponse.Configuration->Resolution->Width << "x" << trt__GetVideoEncoderConfigurationResponse.Configuration->Resolution->Height << std::endl;
}
}
_trt__GetVideoEncoderConfigurationOptions trt__GetVideoEncoderConfigurationOptions;
trt__GetVideoEncoderConfigurationOptions.ConfigurationToken = soap_new_std__string(mediaProxy->soap);
trt__GetVideoEncoderConfigurationOptions.ConfigurationToken->assign(source->token);
_trt__GetVideoEncoderConfigurationOptionsResponse trt__GetVideoEncoderConfigurationOptionsResponse;
addSecurity(mediaProxy->soap, username, password);
if (mediaProxy->GetVideoEncoderConfigurationOptions(&trt__GetVideoEncoderConfigurationOptions, &trt__GetVideoEncoderConfigurationOptionsResponse) == SOAP_OK)
{
if (trt__GetVideoEncoderConfigurationOptionsResponse.Options->H264)
{
for (auto res : trt__GetVideoEncoderConfigurationOptionsResponse.Options->H264->ResolutionsAvailable)
{
std::cout << "\tResolution:" << res->Width << "x" << res->Height << std::endl;
}
}
}
if (imagingProxy.get() != NULL)
{
_timg__GetImagingSettings timg__GetImagingSettings;
timg__GetImagingSettings.VideoSourceToken = source->token;
_timg__GetImagingSettingsResponse timg__GetImagingSettingsResponse;
addSecurity(imagingProxy->soap, username, password);
if (imagingProxy->GetImagingSettings(&timg__GetImagingSettings, &timg__GetImagingSettingsResponse) == SOAP_OK)
{
std::cout << "\tBrightness :" << printPtr (timg__GetImagingSettingsResponse.ImagingSettings->Brightness) << std::endl;
std::cout << "\tContrast :" << printPtr (timg__GetImagingSettingsResponse.ImagingSettings->Contrast) << std::endl;
std::cout << "\tSaturation :" << printPtr (timg__GetImagingSettingsResponse.ImagingSettings->ColorSaturation) << std::endl;
std::cout << "\tSharpness :" << printPtr (timg__GetImagingSettingsResponse.ImagingSettings->Sharpness) << std::endl;
std::cout << "\tBacklight :" << printMode(timg__GetImagingSettingsResponse.ImagingSettings->BacklightCompensation) << std::endl;
std::cout << "\tWideDynamic :" << printMode(timg__GetImagingSettingsResponse.ImagingSettings->WideDynamicRange) << std::endl;
std::cout << "\tExposure :" << printMode(timg__GetImagingSettingsResponse.ImagingSettings->Exposure) << std::endl;
if (timg__GetImagingSettingsResponse.ImagingSettings->Exposure)
std::cout << "\t\tExposureTime :" << printPtr(timg__GetImagingSettingsResponse.ImagingSettings->Exposure->ExposureTime) << std::endl;
std::cout << "\tWhiteBalance:" << printMode(timg__GetImagingSettingsResponse.ImagingSettings->WhiteBalance) << std::endl;
}
_timg__GetOptions timg__GetOptions;
timg__GetOptions.VideoSourceToken = source->token;
_timg__GetOptionsResponse timg__GetOptionsResponse;
addSecurity(imagingProxy->soap, username, password);
if (imagingProxy->GetOptions(&timg__GetOptions, &timg__GetOptionsResponse) == SOAP_OK)
{
std::cout << "\tBrightness: " << printRangePtr(timg__GetOptionsResponse.ImagingOptions->Brightness) << std::endl;
std::cout << "\tContrast : " << printRangePtr(timg__GetOptionsResponse.ImagingOptions->Contrast) << std::endl;
std::cout << "\tSaturation: " << printRangePtr(timg__GetOptionsResponse.ImagingOptions->ColorSaturation) << std::endl;
std::cout << "\tSharpness : " << printRangePtr(timg__GetOptionsResponse.ImagingOptions->Sharpness) << std::endl;
}
}
}
}
std::cout << "=>Media::GetProfiles" << std::endl;
_trt__GetProfiles trt__GetProfiles;
_trt__GetProfilesResponse trt__GetProfilesResponse;
addSecurity(mediaProxy->soap, username, password);
if (mediaProxy->GetProfiles(&trt__GetProfiles, &trt__GetProfilesResponse) == SOAP_OK)
{
for (auto profile : trt__GetProfilesResponse.Profiles)
{
std::string token(profile->token);
std::cout << "\tMediaProfile:" << token << std::endl;
_trt__GetStreamUri trt__GetStreamUri;
_trt__GetStreamUriResponse trt__GetStreamUriResponse;
trt__GetStreamUri.ProfileToken = token;
trt__GetStreamUri.StreamSetup = soap_new_tt__StreamSetup(mediaProxy->soap);
trt__GetStreamUri.StreamSetup->Transport = soap_new_tt__Transport(mediaProxy->soap);
trt__GetStreamUri.StreamSetup->Transport->Protocol = tt__TransportProtocol__RTSP;
addSecurity(mediaProxy->soap, username, password);
if (mediaProxy->GetStreamUri(&trt__GetStreamUri, &trt__GetStreamUriResponse) == SOAP_OK)
{
std::cout << "\tMediaUri:" << trt__GetStreamUriResponse.MediaUri->Uri << std::endl;
}
}
}
}
if (recordingProxy.get() != NULL)
{
std::cout << "=>Recording::GetRecordings" << std::endl;
_trc__GetRecordings trc__GetRecordings;
_trc__GetRecordingsResponse trc__GetRecordingsResponse;
addSecurity(recordingProxy->soap, username, password);
if (recordingProxy->GetRecordings(&trc__GetRecordings, &trc__GetRecordingsResponse) == SOAP_OK)
{
for (auto recording : trc__GetRecordingsResponse.RecordingItem)
{
std::string token(recording->RecordingToken);
std::cout << "\tRecording:" << token << std::endl;
if (replayProxy.get() != NULL)
{
_trp__GetReplayUri trp__GetReplayUri;
_trp__GetReplayUriResponse trp__GetReplayUriResponse;
trp__GetReplayUri.RecordingToken = token;
addSecurity(replayProxy->soap, username, password);
if (replayProxy->GetReplayUri(&trp__GetReplayUri, &trp__GetReplayUriResponse) == SOAP_OK)
{
std::cout << "\tReplay Uri:" << trp__GetReplayUriResponse.Uri << std::endl;
}
}
}
}
std::cout << "=>Recording::GetRecordingJobs" << std::endl;
_trc__GetRecordingJobs trc__GetRecordingJobs;
_trc__GetRecordingJobsResponse trc__GetRecordingJobsResponse;
addSecurity(recordingProxy->soap, username, password);
if (recordingProxy->GetRecordingJobs(&trc__GetRecordingJobs, &trc__GetRecordingJobsResponse) == SOAP_OK)
{
for (auto job : trc__GetRecordingJobsResponse.JobItem)
{
std::string token(job->JobToken);
std::cout << "\tRecordingJob:" << token << std::endl;
if (job->JobConfiguration)
{
std::cout << "\tRecordingToken:" << job->JobConfiguration->RecordingToken << std::endl;
for (auto src : job->JobConfiguration->Source)
{
if (src->SourceToken)
{
std::cout << "\tSourceToken:" << src->SourceToken->Token << std::endl;
std::cout << "\tSourceType:" << src->SourceToken->Type << std::endl;
}
}
}
}
}
}
if (receiverProxy.get() != NULL)
{
std::cout << "=>Receiver::GetReceivers" << std::endl;
_trv__GetReceivers trv__GetReceivers;
_trv__GetReceiversResponse trv__GetReceiversResponse;
addSecurity(receiverProxy->soap, username, password);
if (receiverProxy->GetReceivers(&trv__GetReceivers, &trv__GetReceiversResponse) == SOAP_OK)
{
for (auto receiver : trv__GetReceiversResponse.Receivers)
{
std::string token(receiver->Token);
std::cout << "\tReceiver:" << token << std::endl;
if (receiver->Configuration)
{
std::cout << "\tReceiver mode:" << receiver->Configuration->Mode << " uri:" << receiver->Configuration->MediaUri << std::endl;
}
}
}
}
if (eventProxy.get() != NULL)
{
std::cout << "=>Event::CreatePullPoint" << std::endl;
_tev__CreatePullPointSubscription tev__CreatePullPointSubscription;
_tev__CreatePullPointSubscriptionResponse tev__CreatePullPointSubscriptionResponse;
addSecurity(eventProxy->soap, username, password);
if (eventProxy->CreatePullPointSubscription(&tev__CreatePullPointSubscription, &tev__CreatePullPointSubscriptionResponse) == SOAP_OK)
{
std::cout << "\tPullpoint Url:" << tev__CreatePullPointSubscriptionResponse.SubscriptionReference.Address << std::endl;
// pull
PullPointSubscriptionBindingProxy pullpoint(tev__CreatePullPointSubscriptionResponse.SubscriptionReference.Address);
soap_wsse_add_Security(pullpoint.soap);
_tev__PullMessages tev__PullMessages;
tev__PullMessages.Timeout = "PT10S";
tev__PullMessages.MessageLimit = 100;
_tev__PullMessagesResponse tev__PullMessagesResponse;
if (pullpoint.PullMessages(&tev__PullMessages, &tev__PullMessagesResponse) == SOAP_OK)
{
for (auto msg : tev__PullMessagesResponse.wsnt__NotificationMessage)
{
std::cout << "\tMessage:" << msg->Message.__any << std::endl;
}
}
// subscribe
NotificationConsumerBindingService consumer;
consumer.soap->accept_timeout=5;
consumer.bind(NULL,9090,10);
std::thread th(&NotificationConsumerBindingService::run, &consumer, 0);
NotificationProducerBindingProxy producer(tev__CreatePullPointSubscriptionResponse.SubscriptionReference.Address);
soap_wsse_add_Security(producer.soap);
_wsnt__Subscribe wsnt__Subscribe;
std::string url("http://127.0.0.1:9090");
wsnt__Subscribe.ConsumerReference.Address = strcpy((char*)soap_malloc(producer.soap, url.size()+1), url.c_str());
_wsnt__SubscribeResponse wsnt__SubscribeResponse;
if (producer.Subscribe(&wsnt__Subscribe, &wsnt__SubscribeResponse) == SOAP_OK)
{
}
th.join();
}
}
}
return 0;
}
