TweetFollow Us on Twitter

Sector Dumps
Volume Number:5
Issue Number:7
Column Tag:HyperChat™

XCMD Corner: Sector Dumps

By Donald Koscheka, Arthur Young & Company, MacTutor Contributing Editor

Note: Source code files accompanying article are located on MacTech CD-ROM or source code disks.

Reinventing the wheel often provides an opportunity to embellish on the original design. Recently, I needed a file dump utility. Several packages are available “over the counter”, but I needed a utility that dumps the entire file without having to manually move from sector to sector as is the case with most commercial solutions. Moreover, I use file dump tools frequently enough that I could afford to spend the effort writing one for Hypercard.

I dump the file in a fairly typical way. Each line in the dump contains the “sector address” of the first byte on the line followed by the hexadecimal dump of 16 bytes followed by the ASCII interpretation of the data. Not all ASCII characters are “printable” so we replace non-printing characters with the “.”, yielding a cleaner display.

This month’s XFCN, FilePeek.c (listing 1) accepts two parameters. The first parameter is the reference number of the opened file; the second parameter is the sector you want dumped. HFS sectors are 512 bytes so filepeek returns 32 lines of 16 bytes apiece.

Dumping the entire contents of a file becomes a matter of calling FilePeek repeatedly for all the logical sectors in the file.

The first line in the dump tells us how many bytes were read in. This number can be equal to or less than a full sector. If line 1 contains less than a sector full of data, then you know that logical end of file is after the last byte read in.

The Hypertalk afficianado will realize that this code can easily be written in Hypertalk. I chose to commit my scheme to an XFCN only after discovering that the Hypertalk version was too slow for my purposes.

The dumping scheme is amazingly simple. Position the file mark at the beginning of the sector that you want to dump. If the start of the sector extends beyond end of file, do nothing and return to hypercard with a result of zero (no bytes were read in), otherwise read the sector into the buffer we allocated (buf).

The sector is presented to Hypercard as a series of haxadecimal characters. Hypercard contains a call back “NumtoHex” which converts an arbitrary run of data to a hex string. We lose portability when using a callback so you’ll need to write your own hexdump algorithm or dig one up in the toolbox.

FilePeek dumps two bytes at a time (4 hex digits). This is analogous to dumping the contents of a short. We can use a pointer to short (rPtr). To dump the ascii data, we use a char pointer (cPtr) to the same data.

The current line in the dump is assembled by first displaying the “sector address” of that line. The sector address is 512 * blk (blk = sector number).

The sector address is delineated by the “:” character. Following the sector address, we display 16 bytes of data in hexadecimal format. The data is grouped into 8 words.

The hexadecimal data is followed by the ascii representation of the line. If the character falls in the range of printing characters, we display the character, otherwise print a “.”. Characters below the space (0x020) are not normally considered printing characters. Likewise, Inside Macintosh indicates that no characters above $D8 have a printable format. Using the period to represent non-printing characters results in a less-cluttered looking dump.

We need to cycle the character pointer, cPtr, twice for every cycle on rPtr (a character is half a word). We accumulate the ascii data into a separate string which we then concatenate onto the end of the hex data.

Once the current line is assembled, we stick a carriage return on the end, block move it to the output data handle and then go to the next 16 bytes in the input stream. When the outer loop completes, outdata will contain 32 lines of 16 bytes apiece, suitable for framing.

Figure 1.

How you open and close a file from Hypercard is a matter of taste. I prefer to keep my interface to the file manager as clean as possible. This requires passing a filename and working directory id to the file manager’s FSOpen call and subsequently referring to the file by the reference number returned by FSOpen. To close the file, pass the reference number to FSClose (last month I provided an XFCN that will return a file name and working directory id from the standard file package).

Listings 2 and 3 are two simple XFCNs that open and close a file respectively. FileOpen returns a reference number if the file opened ok (0 otherwise). Pass this reference number to FilePeek along with the number of the sector you wish to dump.

Figure 1. is a sample card that I use to dump the contents of the file. The dump is presented in a mono-spaced font to keep it “clean-looking”. The forward and back arrows allow the user to “browse” sectors by moving 1 sector forward or backward. The scripts for theses two buttons is fairly obvious so I’ve left them to the reader. The scripts for open, close are contained in listing 4.


-- file open button
on mouseUp
  global fileName, DirectoryID
  global fileRefNum, theSector
  put getFileNameToOpen() into it
  put item 1 of it into fileName
  put item 2 of it into DirectoryID
  put filename into card field “file name”
  if filename is not empty then
    Put FileOpen( fileName, DirectoryID ) into fileRefNum
  end if
end mouseUp

-- Go to Sector
on mouseUp
  global fileRefNum, theSector
  if filerefnum is empty then
    answer “You have to open a file first, silly!”
    ask “Read what sector?” with “0”
    if (it is not empty) then
      put it into theSector
      Peekat theSector
    end if
  end if
end mouseUp

-- file close
on mouseUp
  global fileRefNum
  put FileClose( fileRefNum ) into it
  -- ignore the result of a closed file
end mouseUp

Listing 4. Scripts for the buttons

An interesting variation on this theme would be to dump the files in reverse order so that it prints in ascending order on the LaserWriter. Several easy solutions exist for this problem, and I’ll leave it as this month’s exercise to the reader. As a hint, I can think of two ways to do this off hand, one easy but inefficient, the second a little more challenging: (1) create a card for every sector (make sure your file is small first!) or (2) Find out how many sectors the file contains before starting the dump ( a wonderful opportunity to try your hand at XFCN writing).

Note on a bug in last month’s article:

Last month’s XFCN, GetFileName, incorrectly returns the working directory id of the file selected from SFGetFile. Change the call to GetFileNameToOpen to Read:

/* 1 */

if( GetFileNameToOpen(typs,numTypes,FileName,&FileWDID ) ){
 temp = (long)FileWDID & 0xFFFF;
 NumToStr( paramPtr, temp, &WDIDString );
 PtoCstr( WDIDString );
Listing 1:  FilePeek.c

/* File: FilePeek.c*/
/* */
/* Given the sector index into*/
/* an existing file, read the */
/* sector in and “dump” it to */
/* the screen    */
/* */
/* Paramters:    */
/* param0 = file referencenum */
/* ( file is open) */
/* param1 = sector number */
/* (1 sector = 512 bytes) */
/* ----------------------------  */
/* To Build:*/
/* */
/* (1) Create a project using */
/* this file as well as the */
/* XCMD.Glue.c file. (Set */
/* project type to XCMD (or */
/* XFCN) from the Project menu.  */
/* */
/* (2) Bring the project up to*/
/* date.*/
/* */
/* (3) Build Code Resource. */
/* */
/* (4) Use ResEdit to copy the   */
/* resource to your stack.*/

#include  “HyperXCmd.h”

#define SECTOR   512 /***size of input buffer ***/
#define NUMROWS  8 /***across each line***/
#define NUMLINES 32/***lines of data ***/
#define NUMBYTES 16/***#bytes per row of data***/
#define SPACE    0x020  /***the space character***/

long  paramtoNum();
void  appendChar();
void  CopyStrToHandle();
char  *CopyAscii();

pascal void main( paramPtr )
 XCmdBlockPtr  paramPtr;
 short  err;
 short  fref;
 short  lc; /* line count */
 short  rc; /* row count  */
 long   cnt;
 long   blk;/* sector number  */
 Handle outData;
 short  *rPtr;   /* per row */
 char   *cPtr;   /* for ASCII */
 char   *aPtr;   /* points to asciival */
 char   *buf;
 char   asciiStr[32];
 char   curntLine[256]; 
 Str31  numString;
 outData = 0L;
 if( paramPtr->paramCount == 2 ){  
 /*** expect two parameters ***/
 /*** (1) Get our input parameters ***/
 fref = (short)paramtoNum( paramPtr, 0 );
 blk   = paramtoNum( paramPtr, 1 );

 /*** (2) Read a buffer of data    ***/
 blk = blk * SECTOR;
 err = SetFPos( fref, fsFromStart, blk );
 if ( !err ){
 cnt = SECTOR;
 /*** We need to keep this data locked ***/
 /*** Since we can;t trust callbacks not     ***/
 /*** to move stuff, we allocate the ***/
 /*** buffer as non-relocatable.   ***/
 buf = NewPtr( cnt );
 err = FSRead( fref, &cnt, buf );
 if ( err != noErr &&  err != eofErr ){
 paramPtr->returnValue = 0L;
 /*** result is returned to hypercard as     ***/
 /*** a null terminated string***/
 outData = NewHandle( 0L );

 /*** (3) Start filling the output buffer    ***/
 *curntLine = ‘\0’;
 /*** first the number of bytes read in***/
 NumToHex( paramPtr, cnt, 4 , &numString );

 appendChar( PtoCstr( (char *)&numString), ‘\r’ );
 CopyStrToHandle( &numString, outData );

 /*** point to the input data ***/
 rPtr = (short *)buf;
 for( lc = 0;  lc < NUMLINES; ++lc ){
 *curntLine = ‘\0’;

 /*** blk is the sector address  ***/
 NumToHex( paramPtr, blk, 6, &numString );
 PtoCstr( (char *)&numString );
 strcat( curntLine, &numString );
 appendChar( curntLine, ‘:’ );
 appendChar( curntLine, SPACE );
 aPtr = asciiStr;
 blk += NUMBYTES;
 for( rc = 0; rc < NUMROWS; ++rc ){
 /*** convert eight shorts per row ***/
 /*** if we overrun the buffer, draw ***/
 /*** whatever data follows it...  ***/
 NumToHex( paramPtr, (long)*rPtr, 4 , &numString);
 strcat( curntLine, PtoCstr( (char *)&numString));
 appendChar( curntLine, ‘ ‘ );
 cPtr = (char *)rPtr;
 aPtr = CopyAscii( aPtr, *cPtr++ );
 aPtr = CopyAscii( aPtr, *cPtr++ );
 *aPtr = ‘\0’; /*** terminate the ascii data ***/
 strcat( curntLine, asciiStr );
 appendChar( curntLine, ‘\r’ );
 /*** move  line into output buffer***/
 CopyStrToHandle( curntLine, outData );
 DisposPtr( buf );
 cnt = GetHandleSize( outData );
 *(*outData + cnt) = ‘\0’;
 paramPtr->returnValue = outData;

long  paramtoNum( paramPtr, i )
 XCmdBlockPtr  paramPtr;
 short  i;
* Given a handle to an input
* argument in the paramBlk
* return an integer representation
* of the data.
 Str31  theStr;
 HLock( paramPtr->params[ i ] );
 ZeroToPas( paramPtr, *(paramPtr->params[ i ]), &theStr );
 HUnlock( paramPtr->params[ i ] );
 return( StrToLong( paramPtr, &theStr ) );

void  appendChar( theStr, theChar )
 char *theStr;
 char theChar;
* append the character passed
* to the end of the string 
 long len = strlen( theStr );
 char *theEnd;

 theEnd = theStr + len;
 *theEnd++  = theChar;
 *theEnd  = ‘\0’;

char  *CopyAscii( outStr, theChar )
 char *outStr;
 char theChar;
* if the character passed  
* in the input stream is a 
* printing character, append
* it to the output string,
* otherwise, append the ‘.’
* return the update output 
* string.
 if ( theChar >= SPACE  &&  theChar <= 0x0D8  ) 
 *outStr++ = theChar;
 *outStr++ = ‘.’;
 return( outStr );

void CopyStrToHandle( theStr, hand )
 char *theStr;
 Handle hand;
* Copy the input data to the
* output handle.
 long cnt = strlen( theStr );
 long oldSize  = GetHandleSize( hand );

 SetHandleSize( hand, oldSize + cnt );
 BlockMove( theStr, *hand + oldSize, cnt );
Listing 2: FileOpen.c

/* File: FIleOpen.c*/
/* */
/* open the file whose name and */
/* working directory id are */
/* passed as parameters.  This*/
/* information can be obtained*/
/* using GetFileNameToLoad... */
/* */
/* Paramters:    */
/* param0 = file namenum  */
/* param1 = directory id  */
/* */
/* Out: */
/* File RefNum if opened, 0 */
/* otherwise*/
/* ----------------------------  */

#include  “HyperXCmd.h”

pascal void main( paramPtr )
 XCmdBlockPtr  paramPtr;
 char   *filename;
 Str31  str, fName;
 short  wdid, refnum;

 HLock( paramPtr->params[0] );
 ZeroToPas( paramPtr, *(paramPtr->params[0]), &fName );
 HUnlock( paramPtr->params[0] );
 /* convert the wdid to a usable form */
 HLock( paramPtr->params[1] );
 ZeroToPas( paramPtr, *(paramPtr->params[1]), &str );
 HUnlock( paramPtr->params[1] );
 wdid = (short)StrToNum( paramPtr, &str );
 if( FSOpen( &fName, wdid, &refnum) == noErr )
 NumToStr( paramPtr, (long)refnum, &str );
 NumToStr( paramPtr, 0L, &str );

 paramPtr->returnValue = PasToZero( paramPtr, &str );
Listing 3:  FileClose.c

/* File: FileClose.c */
/* */
/* XCMD to access the file mgr*/
/* call FSClose  */
/* Paramters:    */
/* param0 = file reference from  */
/* the fileopen xcmd */
/* ----------------------------  */

#include  “HyperXCmd.h”

pascal void main( paramPtr )
 XCmdBlockPtr  paramPtr;
 short  refnum;
 char   str[256];
 /* convert the refnum to a usable form */
 HLock( paramPtr->params[0] );
 ZeroToPas( paramPtr, *(paramPtr->params[0]), &str );
 HUnlock( paramPtr->params[0] );
 refnum = (short)StrToNum( paramPtr, &str );
 /* Normally we should check the result      */
 /* code but it won’t kill us to ignore*/
 /* the reslt of a close file call */
 if ( FSClose(refnum) )
 paramPtr->returnValue = 0L;


Community Search:
MacTech Search:

Software Updates via MacUpdate

Victorious Knight (Games)
Victorious Knight 1.3 Device: iOS Universal Category: Games Price: $1.99, Version: 1.3 (iTunes) Description: New challenges awaits you! Experience fresh RPG experience with a unique combat mechanic, packed with high quality 3D... | Read more »
Agent Gumball - Roguelike Spy Game (Gam...
Agent Gumball - Roguelike Spy Game 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: Someone’s been spying on Gumball. What the what?! Two can play at that game! GO UNDERCOVERSneak past enemy... | Read more »
Runaway Toad (Games)
Runaway Toad 1.0 Device: iOS Universal Category: Games Price: $2.99, Version: 1.0 (iTunes) Description: It ain’t easy bein’ green! Tap, hold, and swipe to help Toad hop to safety in this gorgeous new action game from the creators of... | Read more »
PsyCard (Games)
PsyCard 1.0 Device: iOS Universal Category: Games Price: $1.99, Version: 1.0 (iTunes) Description: From the makers och Card City Nights, Progress To 100 and Ittle Dew PSYCARD is a minesweeper-like game set in a cozy cyberpunk... | Read more »
Sago Mini Robot Party (Education)
Sago Mini Robot Party 1.0 Device: iOS Universal Category: Education Price: $2.99, Version: 1.0 (iTunes) Description: -- Children's Technology Review Editor's Choice -- | Read more »
How to get a high score in every level o...
Sky Charms is an adorable match three puzzler that provides a decent challenge thanks to its creative level design. It regularly presents something new, forcing you to think on your feet. [Read more] | Read more »
Apestorm: Full Bananas (Games)
Apestorm: Full Bananas 1.0 Device: iOS Universal Category: Games Price: $.99, Version: 1.0 (iTunes) Description: ***Launch sale – limited time only!*** Fugitive Apes have taken to the skies in search of revenge after humans have... | Read more »
How to create bigger words in Spellspire
Words have power. At least they do in Spellspire,a game about blasting out magical attacks by making words out of a jumble of letters. And it's a lot of fun. But if you want to be the best, you're going to have to think tactically when you start... | Read more »
Steel Media and DeePoon have partnered f...
Virtual reality is the next big thing, and 148Apps's publisher,Steel Media, wants to know what the hottest upcoming games are. [Read more] | Read more »
Airline Director 2 - Tycoon Game (Games...
Airline Director 2 - Tycoon Game 1.2.1 Device: iOS Universal Category: Games Price: $2.99, Version: 1.2.1 (iTunes) Description: Airline Director 2 is a management game set in the challenging field of commercial aviation. As the... | Read more »

Price Scanner via

Aleratec Releases Mac Software Upgrade for 1...
California based Aleratec Inc., designer, developer and manufacturer of Portable Device Management (PDM) charge/sync products for mobile devices and professional-grade duplicators for hard disk... Read more
Sale! Amazon offers 27-inch iMac, 13-inch 2.9...
Amazon has the 27″ 3.2GHz 5K iMac and the 13″ 3.9GHz Retina MacBook Pro on sale for $300 off MSRP, each including free shipping, for a limited time: - 27″ 3.2GHz/1TB HD 5K iMac (model MK462LL/A): $... Read more
Apple refurbished 13-inch Retina MacBook Pros...
Apple has Certified Refurbished 13″ Retina MacBook Pros available for up to $270 off the cost of new models. An Apple one-year warranty is included with each model, and shipping is free: - 13″ 2.7GHz... Read more
13-inch 2.7GHz/128GB Retina MacBook Pro on sa...
Take $200 off MSRP on the price of a new 13″ 2.7GHz/128GB Retina MacBook Pro (model MF839LL/A) at Amazon. Shipping is free: - 13″ 2.7GHz/128GB Retina MacBook Pro: $1099.99 $200 off MSRP Act now if... Read more
Apple refurbished clearance 15-inch Retina Ma...
Apple has Certified Refurbished 2014 15″ 2.2GHz Retina MacBook Pros available for $1609, $390 off original MSRP. Apple’s one-year warranty is included, and shipping is free. They have refurbished 15... Read more
27-inch 5K iMacs on sale for up to $150 off M...
B&H Photo has 27″ 5K iMacs on sale for up to $150 off MSRP including free shipping plus NY sales tax only: - 27″ 3.3GHz iMac 5K: $2199 $100 off MSRP - 27″ 3.2GHz/1TB Fusion iMac 5K: $1849.99 $150... Read more
What Does The Refreshed 12-Inch MacBook Tell...
A lot of commentators are complaining that Apple’s update of the 12-Inch MacBook last week is a bit of a damp squib. I don’t know what they were expecting, since it would be very unlike Apple to do a... Read more
Free Wittify Keyboard Now Available On The Ap...
A team of Harvard Business School students have announced that the Wittify Keyboard, a new app utility for iOS devices, is now available on the Apple App Store. The Wittify keyboard and application... Read more
Apple Reports First Year-Over-Year Quarterly...
Apple on TUesday announced financial results for its fiscal 2016 second quarter ending March 26, 2016. The Company posted quarterly revenue of $50.6 billion and quarterly net income of $10.5 billion... Read more
13-inch 2.7GHz Retina MacBook Pros on sale fo...
Take $130-$150 off MSRP on the price of a new 13″ 2.7GHz Retina MacBook Pro at Amazon. Shipping is free: - 13″ 2.7GHz/128GB Retina MacBook Pro: $1169 $130 off MSRP - 13″ 2.7GHz/256GB Retina MacBook... Read more

Jobs Board

Simply Mac *Apple* Specialist- Service Repa...
Simply Mac is the largest premier retailer of Apple products in the nation. In order to support our growing customer base, we are currently looking for a driven Read more
*Apple* Retail - Multiple Positions - Apple,...
Job Description: Sales Specialist - Retail Customer Service and Sales Transform Apple Store visitors into loyal Apple customers. When customers enter the store, Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
*Apple* Solutions Consultant - … (United Sta...
Job Summary As an Apple Solutions Consultant, you'll be the link between our future customers and our products. You'll showcase your entrepreneurial spirit as you Read more
Restaurant Manager (Neighborhood Captain) - A...
…in every aspect of daily operation. WHY YOU'LL LIKE IT: You'll be the Big Apple . You'll solve problems. You'll get to show your ability to handle the stress and Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.