STOW V1.0
© December 13, 1994 by Leonard D Atkinson II
Concept: Doc of Doc's House BBS


************************************************************
** Licence Information                                    **
************************************************************

Everything in this archive is copyright 1994 by Leonard D 
Atkinson II.  I'm only copyrighting this for the sake of proving 
that I wrote it, otherwise anything may be done with it.  Suffice 
it to say I'm putting it under the GNU licence.  It may be 
included in a shareware-type archive like Aminet or the Fish 
disks without my permission and sold for profit.  If it is 
included, I'd appreciate getting word about it, but it's not 
necessary.

If you still feel like giving me something, send me some email.  
A word of thanks is actually more interesting than five bucks.  
My internet address is lda@netcom.com.



************************************************************
** What does it do?                                       **
************************************************************

Put simply, stow copies files to floppies, leaving a minimum of 
extra space left over.  You tell it a minimum amount of space to 
leave unused and it makes as many disks as possible from the 
files provided.

Now, you might ask why you'd want to do this...well, I guess most 
people don't care about stuff like this, but for anyone who 
collects lots and lots of stuff off the net (like me), it saves 
some disks.  It also save the time of figuring out where to put 
which file.  Most people copy each file by hand from hard drive 
to floppy.  So they either end up with disks with 50K free, or 
they spend long hours trying to squeeze as much space out of the 
disks as they can.

************************************************************
** How does it work?                                      **
************************************************************
First, stow makes a list of all the files in the directory you 
give it.  It will ignore all files with a size of zero, which 
include directories.  So, no, there's not recursive directory 
traversal.  I could make it do this, but <sign> I beg you not to 
tempt the creeping feature creature.

So, anyway, then stow just starts throwing files onto a scratch 
pad and hoping they fit.  If it doesn't work out, then one file 
is removed and another takes its place.  This proceeds until a 
disk is found.  Then files are all copied onto the real floppy 
and we start all over again.

I think this is the best balance of time versus space-saving.  If 
you've got another idea, modify my source (and send it to me).


************************************************************
** How do I work it?                                      **
************************************************************
OK, the syntax stow expects is (in bnf):

stow <input directory> <output directory> {<option>}

That means you've got to always give the input directory (where 
the files are) and the output directory (where they are going).  
After that you can lots of different options.  They are as 
follows:


LIST <filename>

Create a list of all the files stowed.  This takes the name of 
the file to be created or re-written.  The files are put down in 
the order copied, which is also by disk.  If you wish them to be 
sorted by name, use the SORT command that comes with AmigaDOS.



ASSUME [n]

Assume disk size.  Defaults to 898560 bytes, a blank FFS minus 
one block just for kicks.  The optional number denotes the limit, 
expressed as K, which means the given number will be multiplied 
by 1024. By default stow detects how much free space is left on 
each disk automatically and I suggest you let it do so.  But if 
you wish to run stow so that it makes a script instead, you have 
to use an assumed size.  The advantage of running things 
interactively and letting stow detect free blocks on the disk is 
that you can stick in a half-full disk and stow will be able to 
handle it.



WASTE <n>

Waste a maximum of nK per disk.  After a disk is assembled only 
this much space (or less) will be free.  Sometimes perfect disks 
(waste == 0) can't be made.  Try using the script command to 
preview how many disks are made with a certain waste value.  I've 
had good luck with setting waste to 1, but I usually have a 
heterogenous mix of file sizes.

             

SCRIPT <filename>

Don't actually copy files, just create a script file to be 
executed later.  This is useful for testing, of course, but also 
for previewing how well certain parameters will make disks.  Some 
features (like verifying copies) won't work under a script, of 
course.



FORMAT "<options>"

Format each disk before copying files to it.  Inside the required 
quotes put the options you wish to be passed to the format 
command.  Example: FORMAT "FFS NOICONS"  Even if you don't want 
any parameters passed to format, you have to give it an empty 
string...like FORMAT "".



NAME <name>

Name each disk with this prefix.  This option only applies if the 
format command is used.  Each disk will be named in the form: 
NAME_AAA, NAME_AAB, ..., NAME_ZZZ.  I'm leaning toward changing 
this to using regular digits, or maybe giving the choice.

  

VERIFY

Verify each file copied.  I do this by comparing the file size of 
the original with that of the copy.  Maybe I should do some 
byte-by-byte comparison.  In any event, this only applies when 
the script command is off (obviously).

  

QUIET

Don't print anything to the screen.

  

NOSORT

This option probably shouldn't be used, but just in case I left 
it in.  Normally files are sorted by size before disks are made.  
This usually speeds the making of disks.

                    

BLOCKSIZE <n>

Set the blocksize of the output device.  This defaults to 512 
which is standard for AmigaDOS devices, I think.  Don't change 
this unless you really know what you are doing.

  

NOCOPYALL

Don't copy files that aren't part of a perfect disk.  By default 
stow copies everything; the last files that don't make a perfect 
disk are copied to the final disk.


OK, so you probably need some real-world examples:

stow c: df0: LIST ram:files.txt

would copy your c: directory to multiple floppies in df0, assumes 
the disks are already formatted, and puts a list of the files in 
a text file on RAM:


stow sys:fonts df3: LIST ram:files.txt ASSUME 440

Assumes the output device (df3:) can only handle 440K.


stow sys:uploads df0: LIST ram:files.txt SCRIPT ram:my.script 
ASSUME

Instead of copying the files, just make a script that can be run 
later.


stow c: df0: LISTram:file.list SCRIPT ram:my.script ASSUME FORMAT 
"FFS NOICONS" NAME MY_ARCHIVE QUIET WASTE 6

Make a script for stowing c:, put a list of file in file.list, 
format the disks as you go along, name them MY_ARCHIVE_AAA, 
MY_ARCHIVE_AAB, etc, and don't print anything to the screen while 
doing so.  Additionally, leave no more than 6K of free space on 
each disk.


Well, if you still have questions, drop me a note either by email

lda@netcom.com

or by snail mail

Leon Atkinson
125 Gilger Avenue
Martinez, CA 94553
USA

If you've got any ideas for stuff to be programed, and you can't 
do it yourself, let me know.  I like writing stuff that I know 
people will use.