自学教程：C++ DumpInt函数代码示例

static void DumpConstants(const Proto* f, DumpState* D){ int i,n; DumpInt(n=f->sizek,D); for (i=0; i<n; i++) {  const TObject* o=&f->k[i];  DumpByte(ttype(o),D);  switch (ttype(o))  {   case LUA_TNUMBER:	DumpNumber(nvalue(o),D);	break;   case LUA_TSTRING:	DumpString(tsvalue(o),D);	break;   case LUA_TNIL:	break;   default:	lua_assert(0);			/* cannot happen */	break;  } } DumpInt(n=f->sizep,D); for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);}

GF_Err gf_ipmpx_dump_KeyData(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_KeyData*p = (GF_IPMPX_KeyData*)_p;	StartElement(trace, "IPMP_KeyData", indent, XMTDump);	indent++;	DumpBool(trace, "hasStartDTS", (p->flags & 1) ? 1 : 0, indent, XMTDump);	DumpBool(trace, "hasStartPacketID", (p->flags & 2) ? 1 : 0, indent, XMTDump);	DumpBool(trace, "hasEndDTS", (p->flags & 4) ? 1 : 0, indent, XMTDump);	DumpBool(trace, "hasEndPacketID", (p->flags & 8) ? 1 : 0, indent, XMTDump);	if (p->flags & 1) DumpLargeInt(trace, "startDTS", p->startDTS, indent, XMTDump);	if (p->flags & 2) DumpInt(trace, "startPacketID", p->startPacketID, indent, XMTDump);	if (p->flags & 4) DumpLargeInt(trace, "expireDTS", p->expireDTS, indent, XMTDump);	if (p->flags & 8) DumpInt(trace, "expirePacketID", p->expirePacketID, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	gf_ipmpx_dump_ByteArray(p->keyBody, "keyBody", trace, indent, XMTDump);	gf_ipmpx_dump_ByteArray(p->OpaqueData, "OpaqueData", trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_KeyData", indent, XMTDump);	return GF_OK;}

static void DumpConstants(const Proto* f, DumpState* D){    int i,n=f->sizek;    DumpInt(n,D);    for (i=0; i<n; i++)    {        const TValue* o=&f->k[i];        DumpChar(ttype(o),D);        switch (ttype(o))        {        case LUA_TNIL:            break;        case LUA_TBOOLEAN:            DumpChar(bvalue(o),D);            break;        case LUA_TNUMBER:            DumpNumber(nvalue(o),D);            break;        case LUA_TSTRING:            DumpString(rawtsvalue(o),D);            break;        default:            lua_assert(0);			/* cannot happen */            break;        }    }    n=f->sizep;    DumpInt(n,D);    for (i=0; i<n; i++) DumpFunction(f->p[i],f->source,D);}

static void DumpCSymbols(DumpState *D){	int i, cs_nr;	cp_csymbol_state *cs_state;	csymbol *cs, *cs_arr;	cs_state = ctype_get_csym_state();	cs_arr = cs_state->cs_arr;	cs_nr = cs_state->cs_nr;	if (!cs_arr || cs_nr == 0) {		DumpInt(0, D);		return;	}	/* dump number of csymbols */	DumpInt(cs_nr, D);	/* dump size of csymbol, for safty check in vm */	DumpInt(sizeof(csymbol), D);	for (i = 0; i < cs_nr; i++) {		cs = &cs_arr[i];		switch (cs->type) {		case FFI_FUNC:			DumpCSymbolFunc(cs, D);			break;		case FFI_STRUCT:			DumpCSymbolStruct(cs, D);			break;		default:			DumpBlock(cs, sizeof(csymbol), D);			break;		}	}}

static void DumpConstants(const ktap_proto *f, DumpState *D){	int i, n = f->sizek;	DumpInt(n, D);	for (i = 0; i < n; i++) {		const ktap_value* o=&f->k[i];		DumpChar(ttypenv(o), D);		switch (ttypenv(o)) {		case KTAP_TNIL:			break;		case KTAP_TBOOLEAN:			DumpChar(bvalue(o), D);			break;		case KTAP_TNUMBER:			DumpNumber(nvalue(o), D);			break;		case KTAP_TSTRING:			DumpString(rawtsvalue(o), D);			break;		default:			printf("ktap: DumpConstants with unknown vaule type %d/n", ttypenv(o));			ktap_assert(0);		}	}	n = f->sizep;	DumpInt(n, D);	for (i = 0; i < n; i++)		DumpFunction(f->p[i], D);}

GF_Err gf_ipmpx_dump_ParametricDescription(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	u32 i;	GF_IPMPX_ParametricDescription*p = (GF_IPMPX_ParametricDescription*)_p;	StartElement(trace, "IPMP_ParametricDescription", indent, XMTDump);	indent++;	DumpInt(trace, "majorVersion", p->majorVersion, indent, XMTDump);	DumpInt(trace, "minorVersion", p->minorVersion, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	gf_ipmpx_dump_ByteArray(p->descriptionComment, "descriptionComment", trace, indent, XMTDump);	StartList(trace, "descriptions", indent, XMTDump);	indent++;	for (i=0; i<gf_list_count(p->descriptions); i++) {		GF_IPMPX_ParametricDescriptionItem *it = (GF_IPMPX_ParametricDescriptionItem *)gf_list_get(p->descriptions, i);		StartElement(trace, "IPMP_ParametricDescriptionItem", indent, XMTDump);		indent++;		EndAttributes(trace, XMTDump, GF_TRUE);		gf_ipmpx_dump_ByteArray(it->main_class, "class", trace, indent, XMTDump);		gf_ipmpx_dump_ByteArray(it->subClass, "subClass", trace, indent, XMTDump);		gf_ipmpx_dump_ByteArray(it->typeData, "typeData", trace, indent, XMTDump);		gf_ipmpx_dump_ByteArray(it->type, "type", trace, indent, XMTDump);		gf_ipmpx_dump_ByteArray(it->addedData, "addedData", trace, indent, XMTDump);		indent--;		EndElement(trace, "IPMP_ParametricDescriptionItem", indent, XMTDump);	}	indent--;	EndList(trace, "descriptions", indent, XMTDump);	indent--;	EndElement(trace, "IPMP_ParametricDescription", indent, XMTDump);	return GF_OK;}

static void DumpConstants(const killa_Proto* f, DumpState* D){ int i,n=f->sizek; DumpInt(n,D); for (i=0; i<n; i++) {  const killa_TValue* o=&f->k[i];  DumpChar(killa_ttype(o),D);  switch (killa_ttype(o))  {   case KILLA_TNULL:	break;   case KILLA_TBOOLEAN:	DumpChar(killa_bvalue(o),D);	break;   case KILLA_TNUMBER:	DumpNumber(killa_nvalue(o),D);	break;   case KILLA_TSTRING:	DumpString(killa_rawtsvalue(o),D);	break;  } } n=f->sizep; DumpInt(n,D); for (i=0; i<n; i++) DumpFunction(f->p[i],D);}

static void DumpLocals(const Proto* f, DumpState* D){ int i,n=f->sizelocvars; DumpInt(n,D); for (i=0; i<n; i++) {  DumpString(f->locvars[i].varname,D);  DumpInt(f->locvars[i].startpc,D);  DumpInt(f->locvars[i].endpc,D); }}

static void DumpLocals(const Proto* tf, void* D){	int i,n=tf->nlocvars;	DumpInt(n,D);	for (i=0; i<n; i++)	{		DumpString(tf->locvars[i].varname,D);		DumpInt(tf->locvars[i].startpc,D);		DumpInt(tf->locvars[i].endpc,D);	}}

static void DumpConstants(const Proto* tf, void* D){	int i,n;	DumpInt(n=tf->nkstr,D);	for (i=0; i<n; i++)		DumpString(tf->kstr[i],D);	DumpInt(tf->nknum,D);	DumpVector(tf->knum,tf->nknum,sizeof(*tf->knum),D);	DumpInt(n=tf->nkproto,D);	for (i=0; i<n; i++)		DumpFunction(tf->kproto[i],D);}

static void DumpFunction(const Proto* tf, void* D){	DumpString(tf->source,D);	DumpInt(tf->lineDefined,D);	DumpInt(tf->numparams,D);	DumpByte(tf->is_vararg,D);	DumpInt(tf->maxstacksize,D);	DumpLocals(tf,D);	DumpLines(tf,D);	DumpConstants(tf,D);	DumpCode(tf,D);}

static void DumpFunction(const ktap_proto *f, DumpState *D){	DumpInt(f->linedefined, D);	DumpInt(f->lastlinedefined, D);	DumpChar(f->numparams, D);	DumpChar(f->is_vararg, D);	DumpChar(f->maxstacksize, D);	DumpCode(f, D);	DumpConstants(f, D);	DumpUpvalues(f, D);	DumpDebug(f, D);}

static  void    DumpInsRange( conflict_node *conf ) {/***************************************************/    if( conf->ins_range.first != NULL ) {        DumpLiteral( " Instruction " );        DumpInt( conf->ins_range.first->id );        if( conf->ins_range.first != conf->ins_range.last         && conf->ins_range.last != NULL ) {            DumpLiteral( " to Instruction " );            DumpInt( conf->ins_range.last->id );        }    }}

static void DumpFunction(const Proto* f, const TString* p, DumpState* D){    DumpString((f->source==p || D->strip) ? NULL : f->source,D);    DumpInt(f->linedefined,D);    DumpInt(f->lastlinedefined,D);    DumpChar(f->nups,D);    DumpChar(f->numparams,D);    DumpChar(f->is_vararg,D);    DumpChar(f->maxstacksize,D);    DumpCode(f,D);    DumpConstants(f,D);    DumpDebug(f,D);}

GF_Err gf_ipmpx_dump_GetToolContext(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_GetToolContext*p = (GF_IPMPX_GetToolContext*)_p;	StartElement(trace, "IPMP_GetToolContext", indent, XMTDump);	indent++;	DumpInt(trace, "scope", p->scope, indent, XMTDump);	DumpInt(trace, "IPMP_DescriptorIDEx", p->IPMP_DescriptorIDEx, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_GetToolContext", indent, XMTDump);	return GF_OK;}

GF_Err gf_ipmpx_dump_InitAuthentication(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_InitAuthentication*p = (GF_IPMPX_InitAuthentication*)_p;	StartElement(trace, "IPMP_InitAuthentication", indent, XMTDump);	indent++;	DumpInt(trace, "Context", p->Context, indent, XMTDump);	DumpInt(trace, "AuthType", p->AuthType, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_InitAuthentication", indent, XMTDump);	return GF_OK;}

static  void    DumpScList( score_list *curr )/********************************************/{    DumpLiteral( "    " );    switch( curr->info.class ) {    case SC_N_CONSTANT:        DumpChar( '&' );        DumpLong( curr->info.offset );        break;    case SC_N_TEMP:        DumpChar( 't' );        DumpInt( curr->info.symbol.t->v.id );        DumpLiteral( " offset " );        DumpLong( curr->info.offset );        break;    case SC_N_MEMORY:        DumpXString( FEName( curr->info.symbol.p ) );        DumpLiteral( " offset " );        DumpLong( curr->info.offset );        break;    case SC_N_INDEXED:        if( curr->info.base == NULL ) {            ;        } else if( curr->info.base->n.class == N_TEMP ) {            DumpChar( 't' );            DumpInt( curr->info.base->t.v.id );            DumpChar( '+' );        } else {            DumpXString( FEName( curr->info.base->v.symbol ) );            DumpChar( '+' );        }        DumpLong( curr->info.offset );        DumpChar( '[' );        DumpRegName( ScoreList[curr->info.index_reg]->reg );        DumpChar( ']' );        break;    case SC_N_INITIAL:        DumpLiteral( "INITIAL(" );        DumpLong( curr->info.offset );        DumpChar( ')' );        break;    case SC_N_VOLATILE:        DumpLiteral( "VOLATILE - Oh No!" );        break;    case SC_N_ADDRESS:        DumpLiteral( "ADDRESS(" );        DumpOperand(curr->info.symbol.p);        DumpChar( ')' );        break;    }

static void DumpFunction(const Proto* f, DumpState* D){ int i; DumpInt(f->linedefined,D); DumpInt(f->lastlinedefined,D); DumpChar(f->numparams,D); DumpChar(f->is_vararg,D); DumpChar(f->maxstacksize,D); DumpInt(f->sizecode,D); for (i=0; i<f->sizecode; i++) DumpUInt(f->code[i],D); DumpConstants(f,D); DumpUpvalues(f,D); DumpDebug(f,D);}

GF_Err gf_ipmpx_dump_ToolAPI_Config(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_ToolAPI_Config*p = (GF_IPMPX_ToolAPI_Config*)_p;	StartElement(trace, "IPMP_ToolAPI_Config", indent, XMTDump);	indent++;	DumpInt(trace, "Instantiation_API_ID", p->Instantiation_API_ID, indent, XMTDump);	DumpInt(trace, "Messaging_API_ID", p->Messaging_API_ID, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	gf_ipmpx_dump_ByteArray(p->opaqueData, "opaqueData", trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_ToolAPI_Config", indent, XMTDump);	return GF_OK;}

void gf_ipmpx_dump_BaseData(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){#if 0	if (XMTDump) {		StartElement(trace, "IPMP_BaseData", indent, XMTDump);		DumpInt(trace, "dataID", _p->dataID, indent, 1);		DumpInt(trace, "Version", _p->Version, indent, 1);		EndLeafAttribute(trace, indent, XMTDump);	} else {		DumpInt(trace, "dataID", _p->dataID, indent, 0);		DumpInt(trace, "Version", _p->Version, indent, 0);	}#endif}

GF_Err gf_ipmpx_dump_GetToolContextResponse(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_GetToolContextResponse*p = (GF_IPMPX_GetToolContextResponse*)_p;	StartElement(trace, "IPMP_GetToolContextResponse", indent, XMTDump);	indent++;	DumpInt(trace, "OD_ID", p->OD_ID, indent, XMTDump);	DumpInt(trace, "ESD_ID", p->ESD_ID, indent, XMTDump);	DumpInt(trace, "IPMP_ToolContextID", p->IPMP_ToolContextID, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_GetToolContextResponse", indent, XMTDump);	return GF_OK;}

GF_Err gf_ipmpx_dump_NotifyToolEvent(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_NotifyToolEvent*p = (GF_IPMPX_NotifyToolEvent*)_p;	StartElement(trace, "IPMP_NotifyToolEvent", indent, XMTDump);	indent++;	DumpInt(trace, "OD_ID", p->OD_ID, indent, XMTDump);	DumpInt(trace, "ESD_ID", p->ESD_ID, indent, XMTDump);	DumpInt(trace, "IPMP_ToolContextID", p->IPMP_ToolContextID, indent, XMTDump);	DumpInt(trace, "eventType", p->eventType, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_NotifyToolEvent", indent, XMTDump);	return GF_OK;}

static void DumpFunction(const Proto* f, const TString* p, DumpState* D){ DumpString((f->source==p) ? NULL : f->source,D); DumpInt(f->linedefined,D); DumpInt(f->lastlinedefined,D); DumpChar(f->nups,D); DumpChar(f->numparams,D); DumpChar(f->is_vararg,D); DumpChar(f->maxstacksize,D); if (D->strip) DumpInt(0,D); else DumpLines(f,D); if (D->strip) DumpInt(0,D); else DumpLocals(f,D); if (D->strip) DumpInt(0,D); else DumpUpvalues(f,D); DumpConstants(f,D); DumpCode(f,D);}

GF_Err gf_ipmpx_dump_SendWatermark(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_SendWatermark*p = (GF_IPMPX_SendWatermark*)_p;	StartElement(trace, (char*) ((_p->tag==GF_IPMPX_AUDIO_WM_SEND_TAG) ? "IPMP_SendAudioWatermark" : "IPMP_SendVideoWatermark"), indent, XMTDump);	indent++;	DumpInt(trace, "wmStatus", p->wm_status, indent, XMTDump);	DumpInt(trace, "compression_status", p->compression_status, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	if (p->wm_status==GF_IPMPX_WM_PAYLOAD) gf_ipmpx_dump_ByteArray(p->payload, "payload", trace, indent, XMTDump);	if (p->opaqueData) gf_ipmpx_dump_ByteArray(p->opaqueData, "opaqueData", trace, indent, XMTDump);	indent--;	EndElement(trace, (char*) ( (_p->tag==GF_IPMPX_AUDIO_WM_SEND_TAG) ? "IPMP_SendAudioWatermark" : "IPMP_SendVideoWatermark"), indent, XMTDump);	return GF_OK;}

GF_Err gf_ipmpx_dump_ISMACryp(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	GF_IPMPX_ISMACryp*p = (GF_IPMPX_ISMACryp*)_p;	StartElement(trace, "ISMACryp_Data", indent, XMTDump);	indent++;	DumpInt(trace, "crypto_suite", p->cryptoSuite, indent, XMTDump);	DumpInt(trace, "IV_length", p->IV_length, indent, XMTDump);	DumpBool(trace, "selective_encryption", p->use_selective_encryption, indent, XMTDump);	DumpInt(trace, "key_indicator_length", p->key_indicator_length, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	indent--;	EndElement(trace, "ISMACryp_Data", indent, XMTDump);	return GF_OK;}

static void DumpConstants (const Proto *f, DumpState *D) {  int i;  int n = f->sizek;  DumpInt(n, D);  for (i = 0; i < n; i++) {    const TValue *o = &f->k[i];    DumpByte(ttype(o), D);    switch (ttype(o)) {    case LUA_TNIL:      break;    case LUA_TBOOLEAN:      DumpByte(bvalue(o), D);      break;    case LUA_TNUMFLT:      DumpNumber(fltvalue(o), D);      break;    case LUA_TNUMINT:      DumpInteger(ivalue(o), D);      break;    case LUA_TSHRSTR:    case LUA_TLNGSTR:      DumpString(tsvalue(o), D);      break;    default:      lua_assert(0);    }  }}

static void DumpFunction (const Proto *f, TString *psource, DumpState *D) {  if (D->strip || f->source == psource)    DumpString(NULL, D);  /* no debug info or same source as its parent */  else    DumpString(f->source, D);  DumpInt(f->linedefined, D);  DumpInt(f->lastlinedefined, D);  DumpByte(f->numparams, D);  DumpByte(f->is_vararg, D);  DumpByte(f->maxstacksize, D);  DumpCode(f, D);  DumpConstants(f, D);  DumpUpvalues(f, D);  DumpProtos(f, D);  DumpDebug(f, D);}

void gf_ipmpx_dump_AUTH(GF_IPMPX_Authentication *ipa, FILE *trace, u32 indent, Bool XMTDump){	switch (ipa->tag) {	case GF_IPMPX_AUTH_KeyDescr_Tag:	{		GF_IPMPX_AUTH_KeyDescriptor *p = (GF_IPMPX_AUTH_KeyDescriptor *)ipa;		StartElement(trace, "IPMP_KeyDescriptor", indent, XMTDump);		DumpData(trace, "keyBody", p->keyBody, p->keyBodyLength, indent+1, XMTDump);		if (XMTDump) EndAttributes(trace, GF_TRUE, GF_FALSE);		else EndElement(trace, "", indent, GF_FALSE);	}	break;	case GF_IPMPX_AUTH_AlgorithmDescr_Tag:	{		GF_IPMPX_AUTH_AlgorithmDescriptor *p = (GF_IPMPX_AUTH_AlgorithmDescriptor *)ipa;		StartElement(trace, "IPMP_AlgorithmDescriptor", indent, XMTDump);		if (p->regAlgoID) {			DumpInt(trace, "regAlgoID", p->regAlgoID, indent+1, XMTDump);		} else {			gf_ipmpx_dump_ByteArray(p->specAlgoID, "specAlgoID", trace, indent+1, XMTDump);		}		EndAttributes(trace, XMTDump, GF_TRUE);		if (p->OpaqueData) gf_ipmpx_dump_ByteArray(p->OpaqueData, "OpaqueData", trace, indent+1, XMTDump);		EndElement(trace, "IPMP_AlgorithmDescriptor", indent, XMTDump);	}	break;	}}

static void DumpProtos (const Proto *f, DumpState *D) {  int i;  int n = f->sizep;  DumpInt(n, D);  for (i = 0; i < n; i++)    DumpFunction(f->p[i], f->source, D);}

GF_Err gf_ipmpx_dump_AddToolNotificationListener(GF_IPMPX_Data *_p, FILE *trace, u32 indent, Bool XMTDump){	u32 i;	GF_IPMPX_AddToolNotificationListener*p = (GF_IPMPX_AddToolNotificationListener*)_p;	StartElement(trace, "IPMP_AddToolNotificationListener", indent, XMTDump);	indent++;	DumpInt(trace, "scope", p->scope, indent, XMTDump);	StartAttribute(trace, "eventType", indent, XMTDump);	if (!XMTDump) fprintf(trace, "/"");	for (i=0; i<p->eventTypeCount; i++) {		if (XMTDump) {			fprintf(trace, "/'%d/'", p->eventType[i]);			if (i+1<p->eventTypeCount) fprintf(trace, " ");		} else {			fprintf(trace, "%d", p->eventType[i]);			if (i+1<p->eventTypeCount) fprintf(trace, ",");		}	}	if (!XMTDump) fprintf(trace, "/"");	EndAttribute(trace, indent, XMTDump);	EndAttributes(trace, XMTDump, GF_TRUE);	gf_ipmpx_dump_BaseData(_p, trace, indent, XMTDump);	indent--;	EndElement(trace, "IPMP_AddToolNotificationListener", indent, XMTDump);	return GF_OK;}