コード例 #1
0
ファイル: fbse.c プロジェクト: clone/wv
U32
wvGetBlip (Blip * blip, wvStream * fd, wvStream * delay)
{
    U32 i, count, count2;
    MSOFBH amsofbh;
    long pos = 0;
    count = wvGetFBSE (&blip->fbse, fd);
    wvTrace (("count is %d\n", count));
    if (blip->fbse.cbName == 0)
	blip->name = NULL;
    else
	blip->name = (U16 *) wvMalloc (sizeof (U16) * blip->fbse.cbName);
    for (i = 0; i < blip->fbse.cbName; i++)
	blip->name[i] = read_16ubit (fd);
    count += blip->fbse.cbName * 2;
    wvTrace (("count is %d\n", count));
    wvTrace (("offset %x\n", blip->fbse.foDelay));

    if (delay)
      {
	  pos = wvStream_tell (delay);
	  if(blip->fbse.foDelay!=-1)
		wvStream_goto (delay, blip->fbse.foDelay);
	  wvTrace (("offset %x\n", blip->fbse.foDelay));
	  fd = delay;
      }

    count2 = wvGetMSOFBH (&amsofbh, fd);
    wvTrace (("count is %d\n", count2));
    wvTrace (
	     ("HERE is %x %x (%d)\n", wvStream_tell (fd), amsofbh.fbt,
	      amsofbh.fbt - msofbtBlipFirst));
    wvTrace (("type is %x\n", amsofbh.fbt));
    switch (amsofbh.fbt - msofbtBlipFirst)
      {
      case msoblipWMF:
      case msoblipEMF:
      case msoblipPICT:
	  count2 += wvGetMetafile (&blip->blip.metafile, &amsofbh, fd);
	  break;
      case msoblipJPEG:
      case msoblipPNG:
      case msoblipDIB:
	  count2 += wvGetBitmap (&blip->blip.bitmap, &amsofbh, fd);
	  break;
      }
    wvTrace (("count is %d\n", count2));
    blip->type = amsofbh.fbt - msofbtBlipFirst;

    if (delay)
      {
	  wvStream_goto (delay, pos);
	  return (count);
      }

    return (count + count2);
}
コード例 #2
0
void
wvGetRS(RS *item, wvStream *fd) {
    item->fRouted      = (S16)read_16ubit(fd);
    item->fReturnOrig  = (S16)read_16ubit(fd);
    item->fTrackStatus = (S16)read_16ubit(fd);
    item->fDirty       = (S16)read_16ubit(fd);
    item->nProtect     = (S16)read_16ubit(fd);
    item->iStage       = (S16)read_16ubit(fd);
    item->delOption    = (S16)read_16ubit(fd);
    item->cRecip       = (S16)read_16ubit(fd);
}
コード例 #3
0
ファイル: ffn.c プロジェクト: clone/wv
void
wvGetFFN_STTBF (FFN_STTBF * item, U32 offset, U32 len, wvStream * fd)
{
    int i;
    wvTrace (("reading fonts...\n"));
    wvTrace (("seeking to %x, len %d\n", offset, len));
    if (len == 0)
    {
        item->nostrings = 0;
        item->ffn = NULL;
    }
    else
    {
        wvStream_goto (fd, offset);
        item->extendedflag = read_16ubit (fd);
        if (item->extendedflag == 0xFFFF)
            item->nostrings = read_16ubit (fd);
        else
            item->nostrings = item->extendedflag;
        item->extradatalen = read_16ubit (fd);
        item->ffn = (FFN *) wvMalloc (item->nostrings * sizeof (FFN));
        for (i = 0; i < item->nostrings; i++)
        {
#ifdef DEBUG
            char *dbg;
#endif
            wvGetFFN (&(item->ffn[i]), fd);
#ifdef DEBUG
            dbg = wvWideStrToMB (item->ffn[i].xszFfn);
            wvTrace (("font %d: %s\n", i, dbg));
            if (dbg)
                wvFree (dbg);
#endif
        }
    }

    wvTrace (("done reading fonts.\n"));
}
コード例 #4
0
ファイル: ffn.c プロジェクト: clone/wv
void
wvGetFFN_STTBF6 (FFN_STTBF * item, U32 offset, U32 len, wvStream * fd)
{
    U32 count = 0;
    int noffn = 0;
    wvTrace (("reading fonts 6...\n"));
    wvTrace (("seeking to %x, len %d\n", offset, len));
    if (len == 0)
    {
        item->nostrings = 0;
        item->ffn = NULL;
        return;
    }
    wvStream_goto (fd, offset);
    item->extendedflag = 0;
    item->nostrings = 5;	/* lets just set a val to start off with */
    item->extradatalen = 0;
    item->ffn = (FFN *) wvMalloc (item->nostrings * sizeof (FFN));
    if (len != read_16ubit (fd))
        wvError (("FFN STTBF lens differ\n"));
    count += 2;

    while (count < len)
    {
#ifdef DEBUG
        char *dbg;
#endif
        if (noffn == item->nostrings)
        {
            /* need to extend the array just in case */
            item->nostrings += 5;
            item->ffn =
                (FFN *) realloc (item->ffn, item->nostrings * sizeof (FFN));
        }
        wvGetFFN6 (&(item->ffn[noffn]), fd);
        count += (item->ffn[noffn].cbFfnM1 + 1);
#ifdef DEBUG
        dbg = wvWideStrToMB (item->ffn[noffn].xszFfn);
        wvTrace (("font %d: %s\n", noffn, dbg));
        if (dbg)
            wvFree (dbg);
#endif
        noffn++;
    }

    if (item->nostrings != noffn)
        item->nostrings = noffn;

    wvTrace (("done reading fonts 6.\n"));
}
コード例 #5
0
ファイル: support.c プロジェクト: AbiWord/wv
U16
dread_16ubit (wvStream * in, U8 ** list)
{
    U8 *temp;
    U16 ret;
    if (in != NULL)
	return (read_16ubit (in));
    else
      {
	  temp = *list;
	  (*list) += 2;
	  ret = sread_16ubit (temp);
	  return (ret);
      }
}
コード例 #6
0
ファイル: bte.c プロジェクト: AbiWord/wv
int
wvGetBTE_PLCF6 (BTE ** bte, U32 ** pos, U32 * nobte, U32 offset, U32 len,
		wvStream * fd)
{
    U32 i;
    if (len == 0)
      {
	  *bte = NULL;
	  *pos = NULL;
	  *nobte = 0;
      }
    else
      {
	  wvTrace (("offset is %x, len is %d\n", offset, len));
	  *nobte = (len - 4) / (cb6BTE + 4);
	  wvTrace (("no of bte is %d at %x\n", *nobte, offset));
	  *pos = (U32 *) wvMalloc ((*nobte + 1) * sizeof (U32));
	  if (*pos == NULL)
	    {
		wvError (
			 ("NO MEM 1, failed to alloc %d bytes\n",
			  (*nobte + 1) * sizeof (U32)));
		return (1);
	    }

	  *bte = (BTE *) wvMalloc (*nobte * sizeof (BTE));
	  if (*bte == NULL)
	    {
		wvError (
			 ("NO MEM 1, failed to alloc %d bytes\n",
			  *nobte * sizeof (BTE)));
		wvFree (pos);
		return (1);
	    }
	  wvStream_goto (fd, offset);
	  for (i = 0; i <= *nobte; i++)
	    {
		(*pos)[i] = read_32ubit (fd);
		wvTrace (("pos is %x\n", (*pos)[i]));
	    }
	  for (i = 0; i < *nobte; i++)
	    {
		wvInitBTE (&((*bte)[i]));
		(*bte)[i].pn = read_16ubit (fd);
	    }
      }
    return (0);
}
コード例 #7
0
ファイル: sep.c プロジェクト: AbiWord/wv
void
wvGetSEPX (wvVersion ver, SEPX * item, wvStream * fd)
{
    U16 i;
    item->cb = read_16ubit (fd);

    if (item->cb)
	item->grpprl = (U8 *) wvMalloc (item->cb);
    else
	item->grpprl = NULL;

    for (i = 0; i < item->cb; i++)
      {
	  item->grpprl[i] = read_8ubit (fd);
	  wvTrace (("sep is %x\n", item->grpprl[i]));
      }
}
コード例 #8
0
ファイル: blip.c プロジェクト: AbiWord/wv
U32
twvGetFBSE (FBSE * afbse, wvStream * infd)
{
    int i;
    afbse->btWin32 = read_8ubit (infd);
    afbse->btMacOS = read_8ubit (infd);
    for (i = 0; i < 16; i++)
	afbse->rgbUid[i] = read_8ubit (infd);
    afbse->tag = read_16ubit (infd);
    afbse->size = read_32ubit (infd);
    afbse->cRef = read_32ubit (infd);
    afbse->foDelay = read_32ubit (infd);
    afbse->usage = read_8ubit (infd);
    afbse->cbName = read_8ubit (infd);
    afbse->unused2 = read_8ubit (infd);
    afbse->unused3 = read_8ubit (infd);
    return (36);
}
コード例 #9
0
U32
wvGetFBSE(FBSE *afbse, wvStream *fd) {
    int i;

    afbse->btWin32 = read_8ubit(fd);
    afbse->btMacOS = read_8ubit(fd);
    for (i = 0; i < 16; i++)
        afbse->rgbUid[i] = read_8ubit(fd);
    afbse->tag     = read_16ubit(fd);
    afbse->size    = read_32ubit(fd);
    afbse->cRef    = read_32ubit(fd);
    afbse->foDelay = read_32ubit(fd);
    wvTrace(("location is %x, size is %d\n", afbse->foDelay, afbse->size));
    afbse->usage  = read_8ubit(fd);
    afbse->cbName = read_8ubit(fd);
    wvTrace(("name len is %d\n", afbse->cbName));
    afbse->unused2 = read_8ubit(fd);
    afbse->unused3 = read_8ubit(fd);
    return 36;
}
コード例 #10
0
void
wvGetBKL(BKL *item, wvStream *fd) {
    item->ibkf = (S16)read_16ubit(fd);
}
コード例 #11
0
ファイル: picf.c プロジェクト: gxf/heigong
/* return value: 1 == success 0 == failure */
int
wvGetPICF (wvVersion ver, PICF * apicf, wvStream * fd)
{
    U8 temp;
    U32 i;
    U8 *buf,*p;
    size_t size;

    long pos = wvStream_tell (fd);

    apicf->lcb = read_32ubit (fd);
    apicf->cbHeader = read_16ubit (fd);
    wvTrace (("size of pic is %x (%d)\n", apicf->cbHeader, apicf->cbHeader));
    apicf->mfp_mm = (S16) read_16ubit (fd);
    wvTrace (("mm type is %d\n", apicf->mfp_mm));
    apicf->mfp_xExt = (S16) read_16ubit (fd);
    apicf->mfp_yExt = (S16) read_16ubit (fd);
    apicf->mfp_hMF = (S16) read_16ubit (fd);
    if (apicf->mfp_mm == 99)
	wvGetBITMAP (&(apicf->obj.bitmap), fd);
    else
	wvGetrc (&(apicf->obj.arc), fd);
    apicf->dxaGoal = (S16) read_16ubit (fd);
    apicf->dyaGoal = (S16) read_16ubit (fd);
    apicf->mx = read_16ubit (fd);
    apicf->my = read_16ubit (fd);
    apicf->dxaCropLeft = (S16) read_16ubit (fd);
    apicf->dyaCropTop = (S16) read_16ubit (fd);
    apicf->dxaCropRight = (S16) read_16ubit (fd);
    apicf->dyaCropBottom = (S16) read_16ubit (fd);
    temp = read_8ubit (fd);

    apicf->brcl = temp & 0x0F;
    apicf->fFrameEmpty = (temp & 0x10) >> 4;
    apicf->fBitmap = (temp & 0x20) >> 5;
    wvTrace (("bitmap is %d\n", apicf->fBitmap));
    apicf->fDrawHatch = (temp & 0x40) >> 6;
    apicf->fError = (temp & 0x80) >> 7;

    apicf->bpp = read_8ubit (fd);
    wvGetBRC (ver, &(apicf->brcTop), fd);
    wvGetBRC (ver, &(apicf->brcLeft), fd);
    wvGetBRC (ver, &(apicf->brcBottom), fd);
    wvGetBRC (ver, &(apicf->brcRight), fd);
    apicf->dxaOrigin = (S16) read_16ubit (fd);
    apicf->dyaOrigin = (S16) read_16ubit (fd);
    if (ver == WORD8)
	apicf->cProps = (S16) read_16ubit (fd);
    else
	apicf->cProps = 0;
    pos = wvStream_tell (fd) - pos;
    for (i = pos; i < apicf->cbHeader; i++)
	read_8ubit (fd);
    wvTrace (("pos is finally %x\n", wvStream_tell (fd)));
    wvTrace (("len of data is %d\n", apicf->lcb - apicf->cbHeader));
    wvTrace (
	     ("ends at %x\n",
	      wvStream_tell (fd) + apicf->lcb - apicf->cbHeader));

    i = 0;

    if (apicf->mfp_mm < 90){
	  MSOFBH bse_pic_amsofbh;
	  size_t lHeaderSize;
	  size_t lWordStructsSize;
	  U8 *pHeader;
	  U8 *pWordStructs;

	  U32 len;
	  U32 j;
	  U8 bmp_header[40];
	  U32 header_len;
	  U32 colors_used;
	  U16 bpp;

	  pWordStructs = pHeader = 0;

	  wvTrace (("test\n"));
	  len = apicf->lcb - apicf->cbHeader;
	  
	  /*[email protected] store*/
	  pos = wvStream_tell (fd);

	  i = wvEatOldGraphicHeader (fd, len);
  	  if(i!=-1)/*Found BMP */
	  {
		wvTrace (("len is %d, header len guess is %d\n", len, i));
		if (i + 2 >= len)
		{
			wvTrace (("all read ok methinks\n"));
			apicf->rgb = NULL;
			return 1;
		}
	    len -= i;
		
		pos = wvStream_tell (fd);

		for(j=0;j< sizeof(bmp_header);j++)
			bmp_header[j] = read_8ubit (fd);

		bpp = bmp_header[14] + (bmp_header[15] << 8);

		if ( bpp < 9)
		{
		    colors_used = bmp_header[32] 
			+ (bmp_header[33] << 8)
			+ (bmp_header[34] << 16)
			+ (bmp_header[35] << 24);
		}
		else
		{
		colors_used = 0;
		}
	
		wvStream_goto(fd,pos);  
		
		header_len = 14 + 40 + 4 * colors_used;
		

		/*Get Blip Header Size*/
		lHeaderSize = PutWord8BitmapHeader(apicf, 0, len + i-14, header_len);
		pHeader = malloc(lHeaderSize);
		/*Write Blip Header*/
		PutWord8BitmapHeader(apicf, pHeader, len, header_len);
		
		/*Set Type of FBSE Header*/
		bse_pic_amsofbh.ver  = 0;
		bse_pic_amsofbh.inst = msobiDIB;
		bse_pic_amsofbh.fbt  = msofbtBlipFirst + msoblipDIB;/*msoblipJPEG msoblipPNG*/
		bse_pic_amsofbh.cbLength = lHeaderSize+len;
	  }else{/*must be WMF*/ 

		/*Get Blip Header Size*/
		lHeaderSize = PutWord8MetafileHeader(apicf, 0);
		pHeader = malloc(lHeaderSize);
		/*Write Blip Header*/
		PutWord8MetafileHeader(apicf, pHeader);

		/*Set Type of FBSE Header*/
		bse_pic_amsofbh.ver  = 0;
		bse_pic_amsofbh.inst = msobiWMF; 
		bse_pic_amsofbh.fbt  = msofbtBlipFirst + msoblipWMF; 
		bse_pic_amsofbh.cbLength = lHeaderSize+len;

		i = 0;
  	    wvStream_goto(fd,pos); 
	  }
	  
	  lWordStructsSize = PutWord8Structs(&bse_pic_amsofbh, 0,0);
	  pWordStructs = malloc(lWordStructsSize);	  
	  PutWord8Structs(&bse_pic_amsofbh, pWordStructs, lWordStructsSize);

 	  size = lHeaderSize + lWordStructsSize + apicf->lcb - apicf->cbHeader;
	  p = buf = malloc(size);

	  if(!p)
	  {
		free(pWordStructs);
		free(pHeader);
		return 0;
	  }

	  memcpy(p, pWordStructs, lWordStructsSize);
	  p+= lWordStructsSize;
	  memcpy(p, pHeader, lHeaderSize);
	  p+=lHeaderSize;

	  free(pWordStructs);
	  free(pHeader);
	}
	else{
 		size = apicf->lcb - apicf->cbHeader;
		p = buf = malloc(size);
	}
	
#if 0
	for (; i < apicf->lcb - apicf->cbHeader; i++)
	  *p++ = read_8ubit (fd);
#endif
    U32 length = apicf->lcb - apicf->cbHeader - i; 
    if (fd->kind == GSF_STREAM)
    {
        gsf_input_read (GSF_INPUT (fd->stream.gsf_stream), length, p);
        p += length;
    }
    else if (fd->kind == FILE_STREAM)
    {
        fread(p, sizeof(guint8), length, fd->stream.file_stream);
        p += length;
    }
    else
    {
	    memorystream_read(fd->stream.memory_stream, p, length);
        p += length;
    }
	
/*	f = fopen("test.dat","wb");
	fwrite(buf, 1,size, f);
	fclose(f);
*/	

    wvStream_memory_create(&apicf->rgb, (char*)buf, size); 
    return 1;
}
コード例 #12
0
ファイル: picf.c プロジェクト: gxf/heigong
U32
wvEatOldGraphicHeader (wvStream * fd, U32 len)
{
    U32 X, entry, count = 0, test;
    U16 pad;
    test = read_32ubit (fd);	/*0x00090001 */
    if (test != 0x00090001L){
	 wvError (("Old Graphic\n"));
	 return -1;
	}
    count += 4;
    test = read_16ubit (fd);	/*0x0300 */
    if (test != 0x0300){
		wvError (("Old Graphic\n"));
 	    return -1;
	}

    count += 2;

    read_32ubit (fd);		/*changes */
    count += 4;
    test = read_16ubit (fd);	/*0x0000 */
    if (test != 0x00000000L){
  		wvError (("Old Graphic\n"));
		return -1;
	}
    count += 2;
    X = read_32ubit (fd);	/*changes, lets call this X */
    wvError (("X is %x\n", X));
    count += 4;
    test = read_16ubit (fd);		/*0x0000 */
    if (test != 0x00000000L){
		wvError (("Old Graphic\n"));
		return -1;
	}
    count += 2;

    /*
       while ( entry != X)
     */
    do
      {
	  entry = read_32ubit (fd);
	  count += 4;
	  wvTrace (
		   ("Entry is %x, %x, count is %d\n", entry,
		    wvStream_tell (fd), count));
	  switch (entry)
	    {
	    case 3:
		read_16ubit (fd);
		count += 2;
		wvTrace (
			 ("suspect that we are finished, count %d, len %d\n",
			  count, len));
		break;
	    default:
		{
		    U32 lene2 = entry - 2;
		    U32 i;
		    wvTrace (
			     ("lene2 is %d, predict end of %x\n", len,
			      wvStream_tell (fd) + (entry - 2) * 2));
		    /* RIES ([email protected])
		       prolly a dirty patch because I check count
		       everytime it's incremnented against lene2.
		       This seems twork very well I tried it on around 15.000
		       word documents and it seems to work! */
		    for (i = 0; i < lene2; i++)
		      {
		          if ( (count + 1) >= len) return (count);
			  test = read_16ubit (fd);
			  if ((i == 0)
			      && ((test == 0x0f43) || (test == 0x0b41)))
			    {
				wvTrace (
					 ("Found a Bitmap, Will strip header and return with bitmap data\n"));
				count += 2;
    		        	if ( (count + 1) >= len) return (count);
				pad = test;
				test = read_32ubit (fd);	/*0x00cc0020 */
				if (test != 0x00cc0020)
				    wvTrace (("Old Graphic\n"));
				count += 4;
    		        	if ( (count + 1) >= len) return (count);

				if (pad == 0x0f43)
				  {
				      test = read_16ubit (fd);	/*0x0000 */
				      if (test != 0x0000)
					  wvTrace (("Old Graphic\n"));
				      count += 2;
			              if ( (count + 1) >= len) return (count);
				  }

				read_16ubit (fd);	/*width */
				count += 2;
    		        	if ( (count + 1) >= len) return (count);
				read_16ubit (fd);	/*height */
				count += 2;
    		        	if ( (count + 1) >= len) return (count);
				test = read_32ubit (fd);	/*0x00000000L */
				if (test != 0x00000000L)
				    wvTrace (("Old Graphic\n"));
				count += 4;
    		        	if ( (count + 1) >= len) return (count);
				read_16ubit (fd);	/*width */
				count += 2;
    		        	if ( (count + 1) >= len) return (count);
				read_16ubit (fd);	/*height */
				count += 2;
    		        	if ( (count + 1) >= len) return (count);
				test = read_32ubit (fd);	/*0x00000000L */
				if (test != 0x00000000L)
				    wvTrace (("Old Graphic\n"));
				count += 4;
				return (count);
			    }
			  count += 2;
	        	  if ( (count + 1) >= len) return (count);
		      }
		}
		break;
	    }
      }
    while (count + 1 < len);
    wvTrace (("Entry is %x %x, %d\n", entry, wvStream_tell (fd), count));
    return (count);
}
コード例 #13
0
ファイル: fib.c プロジェクト: AbiWord/wv
void
wvGetFIB6 (FIB * item, wvStream * fd)
{
    U16 temp16;
    U8 temp8;

    item->wIdent = read_16ubit (fd);
    item->nFib = read_16ubit (fd);

    item->nProduct = read_16ubit (fd);
    item->lid = read_16ubit (fd);
    wvTrace (("lid is %x\n", item->lid));
    item->pnNext = (S16) read_16ubit (fd);
    temp16 = read_16ubit (fd);

    item->fDot = (temp16 & 0x0001);
    item->fGlsy = (temp16 & 0x0002) >> 1;
    item->fComplex = (temp16 & 0x0004) >> 2;
    item->fHasPic = (temp16 & 0x0008) >> 3;
    item->cQuickSaves = (temp16 & 0x00F0) >> 4;
    item->fEncrypted = (temp16 & 0x0100) >> 8;
    item->fWhichTblStm = 0;	/* word 6 files only have one table stream */
    item->fReadOnlyRecommended = (temp16 & 0x0400) >> 10;
    item->fWriteReservation = (temp16 & 0x0800) >> 11;
    item->fExtChar = (temp16 & 0x1000) >> 12;
    wvTrace (("fExtChar is %d\n", item->fExtChar));
    item->fLoadOverride = 0;
    item->fFarEast = 0;
    item->fCrypto = 0;
    item->nFibBack = read_16ubit (fd);
    item->lKey = read_32ubit (fd);
    item->envr = read_8ubit (fd);
    temp8 = read_8ubit (fd);
    item->fMac = 0;
    item->fEmptySpecial = 0;
    item->fLoadOverridePage = 0;
    item->fFutureSavedUndo = 0;
    item->fWord97Saved = 0;
    item->fSpare0 = 0;
    item->chse = read_16ubit (fd);
    item->chsTables = read_16ubit (fd);
    item->fcMin = read_32ubit (fd);
    item->fcMac = read_32ubit (fd);

    item->csw = 14;
    item->wMagicCreated = 0xCA0;	/*this is the unique id of the creater, so its me :-) */

    item->cbMac = read_32ubit (fd);

    read_16ubit (fd);
    read_16ubit (fd);
    read_16ubit (fd);
    read_16ubit (fd);
    read_16ubit (fd);
    read_16ubit (fd);
    read_16ubit (fd);
    read_16ubit (fd);

    item->ccpText = read_32ubit (fd);
    item->ccpFtn = (S32) read_32ubit (fd);
    item->ccpHdr = (S32) read_32ubit (fd);
    item->ccpMcr = (S32) read_32ubit (fd);
    item->ccpAtn = (S32) read_32ubit (fd);
    item->ccpEdn = (S32) read_32ubit (fd);
    item->ccpTxbx = (S32) read_32ubit (fd);
    item->ccpHdrTxbx = (S32) read_32ubit (fd);

    read_32ubit (fd);

    item->fcStshfOrig = (S32) read_32ubit (fd);
    item->lcbStshfOrig = read_32ubit (fd);
    item->fcStshf = (S32) read_32ubit (fd);
    item->lcbStshf = read_32ubit (fd);
    item->fcPlcffndRef = (S32) read_32ubit (fd);
    item->lcbPlcffndRef = read_32ubit (fd);
    item->fcPlcffndTxt = (S32) read_32ubit (fd);
    item->lcbPlcffndTxt = read_32ubit (fd);
    item->fcPlcfandRef = (S32) read_32ubit (fd);
    item->lcbPlcfandRef = read_32ubit (fd);
    item->fcPlcfandTxt = (S32) read_32ubit (fd);
    item->lcbPlcfandTxt = read_32ubit (fd);
    item->fcPlcfsed = (S32) read_32ubit (fd);
    item->lcbPlcfsed = read_32ubit (fd);
    item->fcPlcpad = (S32) read_32ubit (fd);
    item->lcbPlcpad = read_32ubit (fd);
    item->fcPlcfphe = (S32) read_32ubit (fd);
    item->lcbPlcfphe = read_32ubit (fd);
    item->fcSttbfglsy = (S32) read_32ubit (fd);
    item->lcbSttbfglsy = read_32ubit (fd);
    item->fcPlcfglsy = (S32) read_32ubit (fd);
    item->lcbPlcfglsy = read_32ubit (fd);
    item->fcPlcfhdd = (S32) read_32ubit (fd);
    item->lcbPlcfhdd = read_32ubit (fd);
    item->fcPlcfbteChpx = (S32) read_32ubit (fd);
    item->lcbPlcfbteChpx = read_32ubit (fd);
    item->fcPlcfbtePapx = (S32) read_32ubit (fd);
    item->lcbPlcfbtePapx = read_32ubit (fd);
    item->fcPlcfsea = (S32) read_32ubit (fd);
    item->lcbPlcfsea = read_32ubit (fd);
    item->fcSttbfffn = (S32) read_32ubit (fd);
    item->lcbSttbfffn = read_32ubit (fd);
    item->fcPlcffldMom = (S32) read_32ubit (fd);
    item->lcbPlcffldMom = read_32ubit (fd);
    item->fcPlcffldHdr = (S32) read_32ubit (fd);
    item->lcbPlcffldHdr = read_32ubit (fd);
    item->fcPlcffldFtn = (S32) read_32ubit (fd);
    item->lcbPlcffldFtn = read_32ubit (fd);
    item->fcPlcffldAtn = (S32) read_32ubit (fd);
    item->lcbPlcffldAtn = read_32ubit (fd);
    item->fcPlcffldMcr = (S32) read_32ubit (fd);
    item->lcbPlcffldMcr = read_32ubit (fd);
    item->fcSttbfbkmk = (S32) read_32ubit (fd);
    item->lcbSttbfbkmk = read_32ubit (fd);
    item->fcPlcfbkf = (S32) read_32ubit (fd);
    item->lcbPlcfbkf = read_32ubit (fd);
    item->fcPlcfbkl = (S32) read_32ubit (fd);
    item->lcbPlcfbkl = read_32ubit (fd);
    item->fcCmds = (S32) read_32ubit (fd);
    item->lcbCmds = read_32ubit (fd);
    item->fcPlcmcr = (S32) read_32ubit (fd);
    item->lcbPlcmcr = read_32ubit (fd);
    item->fcSttbfmcr = (S32) read_32ubit (fd);
    item->lcbSttbfmcr = read_32ubit (fd);
    item->fcPrDrvr = (S32) read_32ubit (fd);
    item->lcbPrDrvr = read_32ubit (fd);
    item->fcPrEnvPort = (S32) read_32ubit (fd);
    item->lcbPrEnvPort = read_32ubit (fd);
    item->fcPrEnvLand = (S32) read_32ubit (fd);
    item->lcbPrEnvLand = read_32ubit (fd);
    item->fcWss = (S32) read_32ubit (fd);
    item->lcbWss = read_32ubit (fd);
    item->fcDop = (S32) read_32ubit (fd);
    item->lcbDop = read_32ubit (fd);
    item->fcSttbfAssoc = (S32) read_32ubit (fd);
    item->lcbSttbfAssoc = read_32ubit (fd);
    item->fcClx = (S32) read_32ubit (fd);
    item->lcbClx = read_32ubit (fd);
    item->fcPlcfpgdFtn = (S32) read_32ubit (fd);
    item->lcbPlcfpgdFtn = read_32ubit (fd);
    item->fcAutosaveSource = (S32) read_32ubit (fd);
    item->lcbAutosaveSource = read_32ubit (fd);
    item->fcGrpXstAtnOwners = (S32) read_32ubit (fd);
    item->lcbGrpXstAtnOwners = read_32ubit (fd);
    item->fcSttbfAtnbkmk = (S32) read_32ubit (fd);
    item->lcbSttbfAtnbkmk = read_32ubit (fd);

    read_16ubit (fd);

    item->pnChpFirst = (S32) read_16ubit (fd);
    item->pnPapFirst = (S32) read_16ubit (fd);
    item->cpnBteChp = (S32) read_16ubit (fd);
    item->cpnBtePap = (S32) read_16ubit (fd);
    item->fcPlcdoaMom = (S32) read_32ubit (fd);
    item->lcbPlcdoaMom = read_32ubit (fd);
    item->fcPlcdoaHdr = (S32) read_32ubit (fd);
    item->lcbPlcdoaHdr = read_32ubit (fd);

    read_32ubit (fd);
    read_32ubit (fd);
    read_32ubit (fd);
    read_32ubit (fd);

    item->fcPlcfAtnbkf = (S32) read_32ubit (fd);
    item->lcbPlcfAtnbkf = read_32ubit (fd);
    item->fcPlcfAtnbkl = (S32) read_32ubit (fd);
    item->lcbPlcfAtnbkl = read_32ubit (fd);
    item->fcPms = (S32) read_32ubit (fd);
    item->lcbPms = read_32ubit (fd);
    item->fcFormFldSttbs = (S32) read_32ubit (fd);
    item->lcbFormFldSttbs = read_32ubit (fd);
    item->fcPlcfendRef = (S32) read_32ubit (fd);
    item->lcbPlcfendRef = read_32ubit (fd);
    item->fcPlcfendTxt = (S32) read_32ubit (fd);
    item->lcbPlcfendTxt = read_32ubit (fd);
    item->fcPlcffldEdn = (S32) read_32ubit (fd);
    item->lcbPlcffldEdn = read_32ubit (fd);
    item->fcPlcfpgdEdn = (S32) read_32ubit (fd);
    item->lcbPlcfpgdEdn = read_32ubit (fd);

    read_32ubit (fd);
    read_32ubit (fd);

    item->fcSttbfRMark = (S32) read_32ubit (fd);
    item->lcbSttbfRMark = read_32ubit (fd);
    item->fcSttbCaption = (S32) read_32ubit (fd);
    item->lcbSttbCaption = read_32ubit (fd);
    item->fcSttbAutoCaption = (S32) read_32ubit (fd);
    item->lcbSttbAutoCaption = read_32ubit (fd);
    item->fcPlcfwkb = (S32) read_32ubit (fd);
    item->lcbPlcfwkb = read_32ubit (fd);

    read_32ubit (fd);
    read_32ubit (fd);


    item->fcPlcftxbxTxt = (S32) read_32ubit (fd);
    item->lcbPlcftxbxTxt = read_32ubit (fd);
    item->fcPlcffldTxbx = (S32) read_32ubit (fd);
    item->lcbPlcffldTxbx = read_32ubit (fd);
    item->fcPlcfhdrtxbxTxt = (S32) read_32ubit (fd);
    item->lcbPlcfhdrtxbxTxt = read_32ubit (fd);
    item->fcPlcffldHdrTxbx = (S32) read_32ubit (fd);
    item->lcbPlcffldHdrTxbx = read_32ubit (fd);
    item->fcStwUser = (S32) read_32ubit (fd);
    item->lcbStwUser = read_32ubit (fd);
    item->fcSttbttmbd = (S32) read_32ubit (fd);
    item->cbSttbttmbd = read_32ubit (fd);
    item->fcUnused = (S32) read_32ubit (fd);
    item->lcbUnused = read_32ubit (fd);
    item->fcPgdMother = (S32) read_32ubit (fd);
    item->lcbPgdMother = read_32ubit (fd);
    item->fcBkdMother = (S32) read_32ubit (fd);
    item->lcbBkdMother = read_32ubit (fd);
    item->fcPgdFtn = (S32) read_32ubit (fd);
    item->lcbPgdFtn = read_32ubit (fd);
    item->fcBkdFtn = (S32) read_32ubit (fd);
    item->lcbBkdFtn = read_32ubit (fd);
    item->fcPgdEdn = (S32) read_32ubit (fd);
    item->lcbPgdEdn = read_32ubit (fd);
    item->fcBkdEdn = (S32) read_32ubit (fd);
    item->lcbBkdEdn = read_32ubit (fd);
    item->fcSttbfIntlFld = (S32) read_32ubit (fd);
    item->lcbSttbfIntlFld = read_32ubit (fd);
    item->fcRouteSlip = (S32) read_32ubit (fd);
    item->lcbRouteSlip = read_32ubit (fd);
    item->fcSttbSavedBy = (S32) read_32ubit (fd);
    item->lcbSttbSavedBy = read_32ubit (fd);
    item->fcSttbFnm = (S32) read_32ubit (fd);
    item->lcbSttbFnm = read_32ubit (fd);
}
コード例 #14
0
ファイル: fib.c プロジェクト: AbiWord/wv
void
wvGetFIB2 (FIB * item, wvStream * fd)
{
    U16 temp16 = 0;

    item->wIdent = read_16ubit (fd);
    item->nFib = read_16ubit (fd);

    item->nProduct = read_16ubit (fd);
    item->lid = read_16ubit (fd);
    wvTrace (("lid is %x\n", item->lid));
    item->pnNext = (S16) read_16ubit (fd);
    temp16 = read_16ubit (fd);

    item->fDot = (temp16 & 0x0001);
    item->fGlsy = (temp16 & 0x0002) >> 1;
    item->fComplex = (temp16 & 0x0004) >> 2;
    item->fHasPic = (temp16 & 0x0008) >> 3;
    item->cQuickSaves = (temp16 & 0x00F0) >> 4;
    item->fEncrypted = (temp16 & 0x0100) >> 8;
    item->fWhichTblStm = 0;	/* Unused from here on */
    item->fReadOnlyRecommended = 0;
    item->fWriteReservation = 0;
    item->fExtChar = 0;
    item->fLoadOverride = 0;
    item->fFarEast = 0;
    item->fCrypto = 0;

    item->nFibBack = read_16ubit (fd);
    wvTrace (("nFibBack is %d\n", item->nFibBack));

    item->Spare = read_32ubit (fd);	/* A spare for W2 */
    item->rgwSpare0[0] = read_16ubit (fd);
    item->rgwSpare0[1] = read_16ubit (fd);
    item->rgwSpare0[2] = read_16ubit (fd);
    item->fcMin = read_32ubit (fd);	/* These appear correct MV 29.8.2000 */
    item->fcMac = read_32ubit (fd);
    wvTrace (("fc from %d to %d\n", item->fcMin, item->fcMac));

    item->cbMac = read_32ubit (fd);	/* Last byte file position plus one. */

    item->fcSpare0 = read_32ubit (fd);
    item->fcSpare1 = read_32ubit (fd);
    item->fcSpare2 = read_32ubit (fd);
    item->fcSpare3 = read_32ubit (fd);

    item->ccpText = read_32ubit (fd);
    wvTrace (("length %d == %d\n", item->fcMac - item->fcMin, item->ccpText));

    item->ccpFtn = (S32) read_32ubit (fd);
    item->ccpHdr = (S32) read_32ubit (fd);
    item->ccpMcr = (S32) read_32ubit (fd);
    item->ccpAtn = (S32) read_32ubit (fd);
    item->ccpSpare0 = (S32) read_32ubit (fd);
    item->ccpSpare1 = (S32) read_32ubit (fd);
    item->ccpSpare2 = (S32) read_32ubit (fd);
    item->ccpSpare3 = (S32) read_32ubit (fd);

    item->fcStshfOrig = read_32ubit (fd);
    item->lcbStshfOrig = (S32) read_16ubit (fd);
    item->fcStshf = read_32ubit (fd);
    item->lcbStshf = (S32) read_16ubit (fd);
    item->fcPlcffndRef = read_32ubit (fd);
    item->lcbPlcffndRef = (S32) read_16ubit (fd);
    item->fcPlcffndTxt = read_32ubit (fd);
    item->lcbPlcffndTxt = (S32) read_16ubit (fd);
    item->fcPlcfandRef = read_32ubit (fd);
    item->lcbPlcfandRef = (S32) read_16ubit (fd);
    item->fcPlcfandTxt = read_32ubit (fd);
    item->lcbPlcfandTxt = (S32) read_16ubit (fd);
    item->fcPlcfsed = read_32ubit (fd);
    item->lcbPlcfsed = (S32) read_16ubit (fd);
    item->fcPlcfpgd = read_32ubit (fd);
    item->cbPlcfpgd = read_16ubit (fd);
    item->fcPlcfphe = read_32ubit (fd);
    item->lcbPlcfphe = (S32) read_16ubit (fd);
    item->fcPlcfglsy = read_32ubit (fd);
    item->lcbPlcfglsy = (S32) read_16ubit (fd);
    item->fcPlcfhdd = read_32ubit (fd);
    item->lcbPlcfhdd = (S32) read_16ubit (fd);
    item->fcPlcfbteChpx = read_32ubit (fd);
    item->lcbPlcfbteChpx = (S32) read_16ubit (fd);
    item->fcPlcfbtePapx = read_32ubit (fd);
    item->lcbPlcfbtePapx = (S32) read_16ubit (fd);
    item->fcPlcfsea = read_32ubit (fd);
    item->lcbPlcfsea = (S32) read_16ubit (fd);
    item->fcSttbfffn = read_32ubit (fd);
    item->lcbSttbfffn = (S32) read_16ubit (fd);
    item->fcPlcffldMom = read_32ubit (fd);
    item->lcbPlcffldMom = (S32) read_16ubit (fd);
    item->fcPlcffldHdr = read_32ubit (fd);
    item->lcbPlcffldHdr = (S32) read_16ubit (fd);
    item->fcPlcffldFtn = read_32ubit (fd);
    item->lcbPlcffldFtn = (S32) read_16ubit (fd);
    item->fcPlcffldAtn = read_32ubit (fd);
    item->lcbPlcffldAtn = (S32) read_16ubit (fd);
    item->fcPlcffldMcr = read_32ubit (fd);
    item->lcbPlcffldMcr = (S32) read_16ubit (fd);
    item->fcSttbfbkmk = read_32ubit (fd);
    item->lcbSttbfbkmk = (S32) read_16ubit (fd);
    item->fcPlcfbkf = read_32ubit (fd);
    item->lcbPlcfbkf = (S32) read_16ubit (fd);
    item->fcPlcfbkl = read_32ubit (fd);
    item->lcbPlcfbkl = (S32) read_16ubit (fd);
    item->fcCmds = read_32ubit (fd);
    item->lcbCmds = (S32) read_16ubit (fd);
    item->fcPlcmcr = read_32ubit (fd);
    item->lcbPlcmcr = (S32) read_16ubit (fd);
    item->fcSttbfmcr = read_32ubit (fd);
    item->lcbSttbfmcr = (S32) read_16ubit (fd);
    item->fcPrDrvr = read_32ubit (fd);
    item->lcbPrDrvr = (S32) read_16ubit (fd);
    item->fcPrEnvPort = read_32ubit (fd);
    item->lcbPrEnvPort = (S32) read_16ubit (fd);
    item->fcPrEnvLand = read_32ubit (fd);
    item->lcbPrEnvLand = (S32) read_16ubit (fd);
    item->fcWss = read_32ubit (fd);
    item->lcbWss = (S32) read_16ubit (fd);
    item->fcDop = read_32ubit (fd);
    item->lcbDop = (S32) read_16ubit (fd);
    item->fcSttbfAssoc = read_32ubit (fd);
    item->lcbSttbfAssoc = (S32) read_16ubit (fd);
    item->fcClx = read_32ubit (fd);
    item->lcbClx = (S32) read_16ubit (fd);
    item->fcPlcfpgdFtn = read_32ubit (fd);
    item->lcbPlcfpgdFtn = (S32) read_16ubit (fd);
    item->fcAutosaveSource = read_32ubit (fd);
    item->lcbAutosaveSource = (S32) read_16ubit (fd);
    item->fcSpare5 = read_32ubit (fd);
    item->cbSpare5 = read_16ubit (fd);
    item->fcSpare6 = read_32ubit (fd);
    item->cbSpare6 = read_16ubit (fd);
    item->wSpare4 = read_16ubit (fd);
    item->pnChpFirst = read_16ubit (fd);
    item->pnPapFirst = read_16ubit (fd);
    item->cpnBteChp = read_16ubit (fd);
    item->cpnBtePap = read_16ubit (fd);

}
コード例 #15
0
ファイル: fib.c プロジェクト: AbiWord/wv
void
wvGetFIB (FIB * item, wvStream * fd)
{
    U16 temp16;
    U8 temp8;

    item->fEncrypted = 0;

    wvStream_goto (fd, 0);
#ifdef PURIFY
    wvInitFIB (item);
#endif
    item->wIdent = read_16ubit (fd);
    item->nFib = read_16ubit (fd);

    if ((wvQuerySupported (item, NULL) == WORD2))
      {
	  wvInitFIB (item);
	  wvStream_offset (fd, -4);
	  wvGetFIB2 (item, fd);
	  return;
      }

    if ((wvQuerySupported (item, NULL) == WORD5)
	|| (wvQuerySupported (item, NULL) == WORD6)
	|| (wvQuerySupported (item, NULL) == WORD7))
      {
	  wvInitFIB (item);
	  wvStream_offset (fd, -4);
	  wvGetFIB6 (item, fd);
	  return;
      }

    item->nProduct = read_16ubit (fd);
    item->lid = read_16ubit (fd);
    wvTrace (("lid is %x\n", item->lid));
    item->pnNext = (S16) read_16ubit (fd);
    temp16 = read_16ubit (fd);
    item->fDot = (temp16 & 0x0001);
    item->fGlsy = (temp16 & 0x0002) >> 1;
    item->fComplex = (temp16 & 0x0004) >> 2;
    item->fHasPic = (temp16 & 0x0008) >> 3;
    item->cQuickSaves = (temp16 & 0x00F0) >> 4;
    item->fEncrypted = (temp16 & 0x0100) >> 8;
    item->fWhichTblStm = (temp16 & 0x0200) >> 9;
    item->fReadOnlyRecommended = (temp16 & 0x0400) >> 10;
    item->fWriteReservation = (temp16 & 0x0800) >> 11;
    item->fExtChar = (temp16 & 0x1000) >> 12;
    wvTrace (("fExtChar is %d\n", item->fExtChar));
    item->fLoadOverride = (temp16 & 0x2000) >> 13;
    item->fFarEast = (temp16 & 0x4000) >> 14;
    item->fCrypto = (temp16 & 0x8000) >> 15;
    item->nFibBack = read_16ubit (fd);
    item->lKey = read_32ubit (fd);
    item->envr = read_8ubit (fd);
    temp8 = read_8ubit (fd);
    item->fMac = (temp8 & 0x01);
    item->fEmptySpecial = (temp8 & 0x02) >> 1;
    item->fLoadOverridePage = (temp8 & 0x04) >> 2;
    item->fFutureSavedUndo = (temp8 & 0x08) >> 3;
    item->fWord97Saved = (temp8 & 0x10) >> 4;
    item->fSpare0 = (temp8 & 0xFE) >> 5;
    item->chse = read_16ubit (fd);
    item->chsTables = read_16ubit (fd);
    item->fcMin = read_32ubit (fd);
    item->fcMac = read_32ubit (fd);
    item->csw = read_16ubit (fd);
    item->wMagicCreated = read_16ubit (fd);
    item->wMagicRevised = read_16ubit (fd);
    item->wMagicCreatedPrivate = read_16ubit (fd);
    item->wMagicRevisedPrivate = read_16ubit (fd);
    item->pnFbpChpFirst_W6 = (S16) read_16ubit (fd);
    item->pnChpFirst_W6 = (S16) read_16ubit (fd);
    item->cpnBteChp_W6 = (S16) read_16ubit (fd);
    item->pnFbpPapFirst_W6 = (S16) read_16ubit (fd);
    item->pnPapFirst_W6 = (S16) read_16ubit (fd);
    item->cpnBtePap_W6 = (S16) read_16ubit (fd);
    item->pnFbpLvcFirst_W6 = (S16) read_16ubit (fd);
    item->pnLvcFirst_W6 = (S16) read_16ubit (fd);
    item->cpnBteLvc_W6 = (S16) read_16ubit (fd);
    item->lidFE = (S16) read_16ubit (fd);
    item->clw = read_16ubit (fd);
    item->cbMac = (S32) read_32ubit (fd);
    item->lProductCreated = read_32ubit (fd);
    item->lProductRevised = read_32ubit (fd);
    item->ccpText = read_32ubit (fd);
    item->ccpFtn = (S32) read_32ubit (fd);
    item->ccpHdr = (S32) read_32ubit (fd);
    item->ccpMcr = (S32) read_32ubit (fd);
    item->ccpAtn = (S32) read_32ubit (fd);
    item->ccpEdn = (S32) read_32ubit (fd);
    item->ccpTxbx = (S32) read_32ubit (fd);
    item->ccpHdrTxbx = (S32) read_32ubit (fd);
    item->pnFbpChpFirst = (S32) read_32ubit (fd);
    item->pnChpFirst = (S32) read_32ubit (fd);
    item->cpnBteChp = (S32) read_32ubit (fd);
    item->pnFbpPapFirst = (S32) read_32ubit (fd);
    item->pnPapFirst = (S32) read_32ubit (fd);
    item->cpnBtePap = (S32) read_32ubit (fd);
    item->pnFbpLvcFirst = (S32) read_32ubit (fd);
    item->pnLvcFirst = (S32) read_32ubit (fd);
    item->cpnBteLvc = (S32) read_32ubit (fd);
    item->fcIslandFirst = (S32) read_32ubit (fd);
    item->fcIslandLim = (S32) read_32ubit (fd);
    item->cfclcb = read_16ubit (fd);
    item->fcStshfOrig = (S32) read_32ubit (fd);
    item->lcbStshfOrig = read_32ubit (fd);
    item->fcStshf = (S32) read_32ubit (fd);
    item->lcbStshf = read_32ubit (fd);

    item->fcPlcffndRef = (S32) read_32ubit (fd);
    item->lcbPlcffndRef = read_32ubit (fd);
    item->fcPlcffndTxt = (S32) read_32ubit (fd);
    item->lcbPlcffndTxt = read_32ubit (fd);
    item->fcPlcfandRef = (S32) read_32ubit (fd);
    item->lcbPlcfandRef = read_32ubit (fd);
    item->fcPlcfandTxt = (S32) read_32ubit (fd);
    item->lcbPlcfandTxt = read_32ubit (fd);
    item->fcPlcfsed = (S32) read_32ubit (fd);
    item->lcbPlcfsed = read_32ubit (fd);
    item->fcPlcpad = (S32) read_32ubit (fd);
    item->lcbPlcpad = read_32ubit (fd);
    item->fcPlcfphe = (S32) read_32ubit (fd);
    item->lcbPlcfphe = read_32ubit (fd);
    item->fcSttbfglsy = (S32) read_32ubit (fd);
    item->lcbSttbfglsy = read_32ubit (fd);
    item->fcPlcfglsy = (S32) read_32ubit (fd);
    item->lcbPlcfglsy = read_32ubit (fd);
    item->fcPlcfhdd = (S32) read_32ubit (fd);
    item->lcbPlcfhdd = read_32ubit (fd);
    item->fcPlcfbteChpx = (S32) read_32ubit (fd);
    item->lcbPlcfbteChpx = read_32ubit (fd);
    item->fcPlcfbtePapx = (S32) read_32ubit (fd);
    item->lcbPlcfbtePapx = read_32ubit (fd);
    item->fcPlcfsea = (S32) read_32ubit (fd);
    item->lcbPlcfsea = read_32ubit (fd);
    item->fcSttbfffn = (S32) read_32ubit (fd);
    item->lcbSttbfffn = read_32ubit (fd);
    item->fcPlcffldMom = (S32) read_32ubit (fd);
    item->lcbPlcffldMom = read_32ubit (fd);
    item->fcPlcffldHdr = (S32) read_32ubit (fd);
    item->lcbPlcffldHdr = read_32ubit (fd);
    item->fcPlcffldFtn = (S32) read_32ubit (fd);
    item->lcbPlcffldFtn = read_32ubit (fd);
    item->fcPlcffldAtn = (S32) read_32ubit (fd);
    item->lcbPlcffldAtn = read_32ubit (fd);
    item->fcPlcffldMcr = (S32) read_32ubit (fd);
    item->lcbPlcffldMcr = read_32ubit (fd);
    item->fcSttbfbkmk = (S32) read_32ubit (fd);
    item->lcbSttbfbkmk = read_32ubit (fd);
    item->fcPlcfbkf = (S32) read_32ubit (fd);
    item->lcbPlcfbkf = read_32ubit (fd);
    item->fcPlcfbkl = (S32) read_32ubit (fd);
    item->lcbPlcfbkl = read_32ubit (fd);
    item->fcCmds = (S32) read_32ubit (fd);
    item->lcbCmds = read_32ubit (fd);
    item->fcPlcmcr = (S32) read_32ubit (fd);
    item->lcbPlcmcr = read_32ubit (fd);
    item->fcSttbfmcr = (S32) read_32ubit (fd);
    item->lcbSttbfmcr = read_32ubit (fd);
    item->fcPrDrvr = (S32) read_32ubit (fd);
    item->lcbPrDrvr = read_32ubit (fd);
    item->fcPrEnvPort = (S32) read_32ubit (fd);
    item->lcbPrEnvPort = read_32ubit (fd);
    item->fcPrEnvLand = (S32) read_32ubit (fd);
    item->lcbPrEnvLand = read_32ubit (fd);
    item->fcWss = (S32) read_32ubit (fd);
    item->lcbWss = read_32ubit (fd);
    item->fcDop = (S32) read_32ubit (fd);
    item->lcbDop = read_32ubit (fd);
    item->fcSttbfAssoc = (S32) read_32ubit (fd);
    item->lcbSttbfAssoc = read_32ubit (fd);
    item->fcClx = (S32) read_32ubit (fd);
    item->lcbClx = read_32ubit (fd);
    item->fcPlcfpgdFtn = (S32) read_32ubit (fd);
    item->lcbPlcfpgdFtn = read_32ubit (fd);
    item->fcAutosaveSource = (S32) read_32ubit (fd);
    item->lcbAutosaveSource = read_32ubit (fd);
    item->fcGrpXstAtnOwners = (S32) read_32ubit (fd);
    item->lcbGrpXstAtnOwners = read_32ubit (fd);
    item->fcSttbfAtnbkmk = (S32) read_32ubit (fd);
    item->lcbSttbfAtnbkmk = read_32ubit (fd);
    item->fcPlcdoaMom = (S32) read_32ubit (fd);
    item->lcbPlcdoaMom = read_32ubit (fd);
    item->fcPlcdoaHdr = (S32) read_32ubit (fd);
    item->lcbPlcdoaHdr = read_32ubit (fd);
    item->fcPlcspaMom = (S32) read_32ubit (fd);
    item->lcbPlcspaMom = read_32ubit (fd);
    item->fcPlcspaHdr = (S32) read_32ubit (fd);
    item->lcbPlcspaHdr = read_32ubit (fd);
    item->fcPlcfAtnbkf = (S32) read_32ubit (fd);
    item->lcbPlcfAtnbkf = read_32ubit (fd);
    item->fcPlcfAtnbkl = (S32) read_32ubit (fd);
    item->lcbPlcfAtnbkl = read_32ubit (fd);
    item->fcPms = (S32) read_32ubit (fd);
    item->lcbPms = read_32ubit (fd);
    item->fcFormFldSttbs = (S32) read_32ubit (fd);
    item->lcbFormFldSttbs = read_32ubit (fd);
    item->fcPlcfendRef = (S32) read_32ubit (fd);
    item->lcbPlcfendRef = read_32ubit (fd);
    item->fcPlcfendTxt = (S32) read_32ubit (fd);
    item->lcbPlcfendTxt = read_32ubit (fd);
    item->fcPlcffldEdn = (S32) read_32ubit (fd);
    item->lcbPlcffldEdn = read_32ubit (fd);
    item->fcPlcfpgdEdn = (S32) read_32ubit (fd);
    item->lcbPlcfpgdEdn = read_32ubit (fd);
    item->fcDggInfo = (S32) read_32ubit (fd);
    item->lcbDggInfo = read_32ubit (fd);
    item->fcSttbfRMark = (S32) read_32ubit (fd);
    item->lcbSttbfRMark = read_32ubit (fd);
    item->fcSttbCaption = (S32) read_32ubit (fd);
    item->lcbSttbCaption = read_32ubit (fd);
    item->fcSttbAutoCaption = (S32) read_32ubit (fd);
    item->lcbSttbAutoCaption = read_32ubit (fd);
    item->fcPlcfwkb = (S32) read_32ubit (fd);
    item->lcbPlcfwkb = read_32ubit (fd);
    item->fcPlcfspl = (S32) read_32ubit (fd);
    item->lcbPlcfspl = read_32ubit (fd);
    item->fcPlcftxbxTxt = (S32) read_32ubit (fd);
    item->lcbPlcftxbxTxt = read_32ubit (fd);
    item->fcPlcffldTxbx = (S32) read_32ubit (fd);
    item->lcbPlcffldTxbx = read_32ubit (fd);
    item->fcPlcfhdrtxbxTxt = (S32) read_32ubit (fd);
    item->lcbPlcfhdrtxbxTxt = read_32ubit (fd);
    item->fcPlcffldHdrTxbx = (S32) read_32ubit (fd);
    item->lcbPlcffldHdrTxbx = read_32ubit (fd);
    item->fcStwUser = (S32) read_32ubit (fd);
    item->lcbStwUser = read_32ubit (fd);
    item->fcSttbttmbd = (S32) read_32ubit (fd);
    item->cbSttbttmbd = read_32ubit (fd);
    item->fcUnused = (S32) read_32ubit (fd);
    item->lcbUnused = read_32ubit (fd);
    item->fcPgdMother = (S32) read_32ubit (fd);
    item->lcbPgdMother = read_32ubit (fd);
    item->fcBkdMother = (S32) read_32ubit (fd);
    item->lcbBkdMother = read_32ubit (fd);
    item->fcPgdFtn = (S32) read_32ubit (fd);
    item->lcbPgdFtn = read_32ubit (fd);
    item->fcBkdFtn = (S32) read_32ubit (fd);
    item->lcbBkdFtn = read_32ubit (fd);
    item->fcPgdEdn = (S32) read_32ubit (fd);
    item->lcbPgdEdn = read_32ubit (fd);
    item->fcBkdEdn = (S32) read_32ubit (fd);
    item->lcbBkdEdn = read_32ubit (fd);
    item->fcSttbfIntlFld = (S32) read_32ubit (fd);
    item->lcbSttbfIntlFld = read_32ubit (fd);
    item->fcRouteSlip = (S32) read_32ubit (fd);
    item->lcbRouteSlip = read_32ubit (fd);
    item->fcSttbSavedBy = (S32) read_32ubit (fd);
    item->lcbSttbSavedBy = read_32ubit (fd);
    item->fcSttbFnm = (S32) read_32ubit (fd);
    item->lcbSttbFnm = read_32ubit (fd);
    item->fcPlcfLst = (S32) read_32ubit (fd);
    item->lcbPlcfLst = read_32ubit (fd);
    item->fcPlfLfo = (S32) read_32ubit (fd);
    item->lcbPlfLfo = read_32ubit (fd);
    item->fcPlcftxbxBkd = (S32) read_32ubit (fd);
    item->lcbPlcftxbxBkd = read_32ubit (fd);
    item->fcPlcftxbxHdrBkd = (S32) read_32ubit (fd);
    item->lcbPlcftxbxHdrBkd = read_32ubit (fd);
    item->fcDocUndo = (S32) read_32ubit (fd);
    item->lcbDocUndo = read_32ubit (fd);
    item->fcRgbuse = (S32) read_32ubit (fd);
    item->lcbRgbuse = read_32ubit (fd);
    item->fcUsp = (S32) read_32ubit (fd);
    item->lcbUsp = read_32ubit (fd);
    item->fcUskf = (S32) read_32ubit (fd);
    item->lcbUskf = read_32ubit (fd);
    item->fcPlcupcRgbuse = (S32) read_32ubit (fd);
    item->lcbPlcupcRgbuse = read_32ubit (fd);
    item->fcPlcupcUsp = (S32) read_32ubit (fd);
    item->lcbPlcupcUsp = read_32ubit (fd);
    item->fcSttbGlsyStyle = (S32) read_32ubit (fd);
    item->lcbSttbGlsyStyle = read_32ubit (fd);
    item->fcPlgosl = (S32) read_32ubit (fd);
    item->lcbPlgosl = read_32ubit (fd);
    item->fcPlcocx = (S32) read_32ubit (fd);
    item->lcbPlcocx = read_32ubit (fd);
    item->fcPlcfbteLvc = (S32) read_32ubit (fd);
    item->lcbPlcfbteLvc = read_32ubit (fd);
    wvGetFILETIME (&(item->ftModified), fd);
    item->fcPlcflvc = (S32) read_32ubit (fd);
    item->lcbPlcflvc = read_32ubit (fd);
    item->fcPlcasumy = (S32) read_32ubit (fd);
    item->lcbPlcasumy = read_32ubit (fd);
    item->fcPlcfgram = (S32) read_32ubit (fd);
    item->lcbPlcfgram = read_32ubit (fd);
    item->fcSttbListNames = (S32) read_32ubit (fd);
    item->lcbSttbListNames = read_32ubit (fd);
    item->fcSttbfUssr = (S32) read_32ubit (fd);
    item->lcbSttbfUssr = read_32ubit (fd);
}