Пример #1
0
void DumpPackage(FILE *flp, USB_REG_INFO_PACKET *pack)
{

	fprintf(flp, "\n------ Header: ------ \n");

	fprintf(flp, "WORD PacketSize = %d: ", pack->PacketSize); fflush(flp); DumpWORD(flp, pack->PacketSize); fflush(flp); fprintf(flp, "\n");fflush(flp);
	fprintf(flp, "WORD ProtocolVersion = %d: ", pack->ProtocolVersion); fflush(flp); DumpWORD(flp, pack->ProtocolVersion); fflush(flp); fprintf(flp, "\n");fflush(flp);
	fprintf(flp, "WORD SubblockID = %d: ", pack->SubblockID); fflush(flp); DumpWORD(flp, pack->SubblockID); fflush(flp); fprintf(flp, "\n");fflush(flp);
	fprintf(flp, "WORD PacketNo = %d: ", pack->PacketNo);
	fprintf(flp, "WORD PartNo = %d: ", pack->PartNo); fflush(flp); DumpWORD(flp, pack->PartNo); fflush(flp); fprintf(flp, "\n");fflush(flp);

	fprintf(flp, " ---------- DATA ---------- \n"); fflush(flp);
	for (int i = 0; i < 990; i+=2)
	{
		fprintf(flp, "word %d = 0x%x   : ", i / 2, pack->RegInfo[i]); 
		fflush(flp); 
		DumpByte(flp, (char*)&pack->RegInfo[i]); 
		fflush(flp); 
		fprintf(flp, " ");
		DumpByte(flp, (char*)&pack->RegInfo[i + 1]); 
		fflush(flp); 
		fprintf(flp, "\n"); 
		fflush(flp);
	}

	fprintf(flp, " -------------------------- \n\n"); fflush(flp);
		
}
Пример #2
0
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);
    }
  }
}
Пример #3
0
static void DumpUpvalues (const Proto *f, DumpState *D) {
  int i, n = f->sizeupvalues;
  DumpInt(n, D);
  for (i = 0; i < n; i++) {
    DumpByte(f->upvalues[i].instack, D);
    DumpByte(f->upvalues[i].idx, D);
  }
}
Пример #4
0
static void DumpString (const TString *s, DumpState *D) {
  if (s == NULL)
    DumpByte(0, D);
  else {
    size_t size = s->len + 1;  /* include trailing '\0' */
    if (size < 0xFF)
      DumpByte(cast_int(size), D);
    else {
      DumpByte(0xFF, D);
      DumpVar(size, D);
    }
    DumpVector(getstr(s), size - 1, D);  /* no need to save '\0' */
  }
}
Пример #5
0
static void DumpFunction(const Proto* f, const TString* p, DumpState* D)
{
 DumpString((f->source==p) ? NULL : f->source,D);
 DumpInt(f->lineDefined,D);
 DumpByte(f->nups,D);
 DumpByte(f->numparams,D);
 DumpByte(f->is_vararg,D);
 DumpByte(f->maxstacksize,D);
 DumpLines(f,D);
 DumpLocals(f,D);
 DumpUpvalues(f,D);
 DumpConstants(f,D);
 DumpCode(f,D);
}
Пример #6
0
static void DumpHeader(DumpState* D)
{
 DumpLiteral(LUA_SIGNATURE,D);
 DumpByte(VERSION,D);
 DumpByte(luaU_endianness(),D);
 DumpByte(sizeof(int),D);
 DumpByte(sizeof(size_t),D);
 DumpByte(sizeof(Instruction),D);
 DumpByte(SIZE_OP,D);
 DumpByte(SIZE_A,D);
 DumpByte(SIZE_B,D);
 DumpByte(SIZE_C,D);
 DumpByte(sizeof(lua_Number),D);
 DumpNumber(TEST_NUMBER,D);
}
Пример #7
0
Файл: luac.c Проект: jcubic/ToME
static void DumpHeader(void* D)
{
	DumpByte(ID_CHUNK,D);
	DumpSig(SIGNATURE, D);
	DumpByte(VERSION,D);
	DumpByte(luaU_endianess(),D);
	DumpByte(sizeof(int),D);
	DumpByte(sizeof(size_t),D);
	DumpByte(sizeof(Instruction),D);
	DumpByte(SIZE_INSTRUCTION,D);
	DumpByte(SIZE_OP,D);
	DumpByte(SIZE_B,D);
	DumpByte(sizeof(Number),D);
	DumpNumber(TEST_NUMBER,D);
}
Пример #8
0
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);
}
Пример #9
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);
}
Пример #10
0
int          clsDump::DumpConst(clsConst * pConst, int onlyCalculateSize)
{
  int          iSize = 0;
  unsigned int iIndex;

  iSize += DumpLine("----- CONST BEG -----\n", onlyCalculateSize);
  iSize += DumpLine("\tUID %u\n", pConst->m_UID, onlyCalculateSize);
  iSize += DumpLine("\tData Type UID %u\n", pConst->m_pDataType->m_UID, onlyCalculateSize);
  iSize += DumpLine("\tConst Width: %u\n", pConst->m_pDataType->m_iWidth, onlyCalculateSize);
  for (iIndex = 0; iIndex < pConst->m_pDataType->m_iWidth; ++iIndex)
  {
    iSize += DumpByte("\tBits: %u\n", pConst->m_sBits[iIndex], onlyCalculateSize);
  }
  iSize += DumpByte("\tBits End: %u\n", '\0', onlyCalculateSize);
  iSize += DumpLine("----- CONST END -----\n", onlyCalculateSize);

  return iSize;
}
Пример #11
0
void TRsReadTester::DumpBytes(const TAny* aPtr,TInt aLen)
    {
    TUint8* src=(TUint8*)aPtr;
    TBuf<100> whole;
    TUint8* tar=(TUint8*)whole.Ptr();
    TInt len=0;
    while (aLen--)
        {
        TUint val=(*src++);
        TUint top=val/16;
        TUint bottom=val%16;
        *tar++=DumpByte(top);
        *tar++=DumpByte(bottom);
        *tar++=' ';
        len+=3;
        }
    whole.SetLength(len);
    test.Printf(whole);
    test.Printf(_L("\r\n"));
    }
Пример #12
0
/*
** dump Lua function as precompiled chunk
*/
int luaU_dump(lua_State *L, const Proto *f, lua_Writer w, void *data, int strip) {
    DumpState D;
    D.L = L;
    D.writer = w;
    D.data = data;
    D.strip = strip;
    D.status = 0;
    DumpHeader(&D);
    DumpByte(f->sizeupvalues, &D);
    DumpFunction(f, NULL, &D);
    return D.status;
}
Пример #13
0
Файл: luac.c Проект: jcubic/ToME
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);
}
Пример #14
0
static void DumpDebug (const Proto *f, DumpState *D) {
  int i, n;
  n = (D->strip) ? 0 : f->sizelineinfo;
  DumpInt(n, D);
  DumpVector(f->lineinfo, n, D);
  /* n = (D->strip) ? 0 : f->sizelocvars; */
  n = f->sizelocvars;
  DumpInt(n, D);
  for (i = 0; i < n; i++) {
    DumpString((D->strip) ? NULL : f->locvars[i].varname, D);
    DumpInt(f->locvars[i].startpc, D);
    DumpInt(f->locvars[i].endpc, D);
    DumpByte(f->locvars[i].ravi_type, D);
  }
  /* n = (D->strip) ? 0 : f->sizeupvalues; */
  n = f->sizeupvalues;
  DumpInt(n, D);
  for (i = 0; i < n; i++) {
    DumpString((D->strip) ? NULL : f->upvalues[i].name, D);
    DumpByte(f->upvalues[i].type, D);
  }
}
Пример #15
0
static void DumpHeader (DumpState *D) {
  DumpLiteral(LUA_SIGNATURE, D);
  DumpByte(LUAC_VERSION, D);
  DumpByte(LUAC_FORMAT, D);
  DumpLiteral(LUAC_DATA, D);
  DumpByte(sizeof(int), D);
  DumpByte(sizeof(size_t), D);
  DumpByte(sizeof(Instruction), D);
  DumpByte(sizeof(lua_Integer), D);
  DumpByte(sizeof(lua_Number), D);
  DumpInteger(LUAC_INT, D);
  DumpNumber(LUAC_NUM, D);
}
Пример #16
0
void DumpWORD(FILE *flp, short word)
{

	char byte;
	short wordswp;

	wordswp = swap2bytes(word);

	for (unsigned int i = 0; i < sizeof(WORD); i++)
	{
		memcpy(&byte, (char*)&wordswp + i, 1);	
		DumpByte(flp, &byte);
		fprintf(flp, " ");
	}
	

}
Пример #17
0
static void DumpFunction(const Proto* tf, FILE* 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);
 if (ferror(D))
 {
  perror("luac: write error");
  exit(1);
 }
}
Пример #18
0
static int
DumpVolumeHeader(int dumpfd, register Volume * vp)
{
    int code = 0;

    if (verbose)
	fprintf(stderr, "dumping volume header\n");

    if (!code)
	code = DumpTag(dumpfd, D_VOLUMEHEADER);
    if (!code)
	code = DumpInt32(dumpfd, 'i', V_id(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'v', V_stamp(vp).version);
    if (!code)
	code = DumpString(dumpfd, 'n', V_name(vp));
    if (!code)
	code = DumpBool(dumpfd, 's', V_inService(vp));
    if (!code)
	code = DumpBool(dumpfd, 'b', V_blessed(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'u', V_uniquifier(vp));
    if (!code)
	code = DumpByte(dumpfd, 't', (byte) V_type(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'p', V_parentId(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'c', V_cloneId(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'q', V_maxquota(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'm', V_minquota(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'd', V_diskused(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'f', V_filecount(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'a', V_accountNumber(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'o', V_owner(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'C', V_creationDate(vp));	/* Rw volume creation date */
    if (!code)
	code = DumpInt32(dumpfd, 'A', V_accessDate(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'U', V_updateDate(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'E', V_expirationDate(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'B', V_backupDate(vp));	/* Rw volume backup clone date */
    if (!code)
	code = DumpString(dumpfd, 'O', V_offlineMessage(vp));

    /*
     * We do NOT dump the detailed volume statistics residing in the old
     * motd field, since we cannot tell from the info in a dump whether
     * statistics data has been put there.  Instead, we dump a null string,
     * just as if that was what the motd contained.
     */
    if (!code)
	code = DumpString(dumpfd, 'M', "");
    if (!code)
	code =
	    DumpArrayInt32(dumpfd, 'W', (afs_uint32 *) V_weekUse(vp),
			   sizeof(V_weekUse(vp)) / sizeof(V_weekUse(vp)[0]));
    if (!code)
	code = DumpInt32(dumpfd, 'D', V_dayUseDate(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'Z', V_dayUse(vp));
    if (!code)
	code = DumpInt32(dumpfd, 'V', V_volUpCounter(vp));
    return code;
}
Пример #19
0
static int
DumpVnode(int dumpfd, struct VnodeDiskObject *v, int volid, int vnodeNumber,
	  int dumpEverything, struct Volume *vp)
{
    int code = 0;
    IHandle_t *ihP;
    FdHandle_t *fdP;

    if (verbose)
	fprintf(stderr, "dumping vnode %d\n", vnodeNumber);

    if (!v || v->type == vNull)
	return code;
    if (!code)
	code = DumpDouble(dumpfd, D_VNODE, vnodeNumber, v->uniquifier);
    if (!dumpEverything)
	return code;
    if (!code)
	code = DumpByte(dumpfd, 't', (byte) v->type);
    if (!code)
	code = DumpShort(dumpfd, 'l', v->linkCount);	/* May not need this */
    if (!code)
	code = DumpInt32(dumpfd, 'v', v->dataVersion);
    if (!code)
	code = DumpInt32(dumpfd, 'm', v->unixModifyTime);
    if (!code)
	code = DumpInt32(dumpfd, 'a', v->author);
    if (!code)
	code = DumpInt32(dumpfd, 'o', v->owner);
    if (!code && v->group)
	code = DumpInt32(dumpfd, 'g', v->group);	/* default group is 0 */
    if (!code)
	code = DumpShort(dumpfd, 'b', v->modeBits);
    if (!code)
	code = DumpInt32(dumpfd, 'p', v->parent);
    if (!code)
	code = DumpInt32(dumpfd, 's', v->serverModifyTime);
    if (v->type == vDirectory) {
	acl_HtonACL(VVnodeDiskACL(v));
	if (!code)
	    code =
		DumpByteString(dumpfd, 'A', (byte *) VVnodeDiskACL(v),
			       VAclDiskSize(v));
    }

    if (VNDISK_GET_INO(v)) {
	IH_INIT(ihP, V_device(vp), V_parentId(vp), VNDISK_GET_INO(v));
	fdP = IH_OPEN(ihP);
	if (fdP == NULL) {
	    fprintf(stderr,
		    "Unable to open inode %s for vnode %u (volume %i); not dumped, error %d\n",
		    PrintInode(NULL, VNDISK_GET_INO(v)), vnodeNumber, volid,
		    errno);
	}
	else
	{
		if (verbose)
		    fprintf(stderr, "about to dump inode %s for vnode %u\n",
			    PrintInode(NULL, VNDISK_GET_INO(v)), vnodeNumber);
		code = DumpFile(dumpfd, vnodeNumber, fdP, v);
		FDH_CLOSE(fdP);
	}
	IH_RELEASE(ihP);
    }

    if (verbose)
	fprintf(stderr, "done dumping vnode %d\n", vnodeNumber);
    return code;
}