--                                EUREAP
--
--               A program to transport files using floppies
--                A program to back-up files using floppies
--                         Version 1.6 - 2006/11/14
--
--                           Author: R. M. Forno
--                            Contact either of:
--   ricardoforno@tutopia.com, ricardoforno128@hotmail.com
--
--                                DISCLAIMER
-- This is free software. I will not be held responsible for any damage it
-- may cause to you or, for that matter, to anybody else. Use it at your
-- own risk.
-- I have no obligation to maintain or support this program in any manner.
-- However, I will accept comments, questions, requests and error reports
-- through e-mail, and eventually answer them.
--
--                               INTRODUCTION
-- Have you ever needed to transport files from a PC to another one when
-- you had only floppies to that end (no CD-RW, no modem, etc.)?
-- Have you ever needed to back-up files under the same conditions?
-- Well, this program helps solving these problems.
-- There is a bunch of programs to split files to floppy capacity (or to any
-- given size), but they require much hand work, so being prone to error.
--
-- With the present program, you can ease these tasks and get a better use
-- of floppy capacity.
--
-- The following are the advantages of EUREAP:
--
-- 1) The process is completely automated. The user is prompted to enter
-- yes/no type answers only when inserting floppies.
--
-- 2) You can use floppies of any capacity, even with defective tracks, and
-- mixed capacities (double sided / single sided, for example). However,
-- 720 KB floppies use 1024-byte blocks. In this case, mixing floppies with
-- different capacities could be non-optimal.
--
-- 3) As the files are automatically compressed, you save floppy space, and
-- so you can diminish the number of floppies needed.
--
-- 4) An extremely fast knapsack algorithm is included, to optimize the
-- distribution of files among floppies, and so further decreasing the
-- number of floppies needed.
--
-- 5) Usually, you make two or more copies of back-up files, as the
-- floppies quality is nowadays very low. So, when a floppy fails, you have
-- another copy to rescue you. But then, Murphy law strikes, and the second
-- copy also fails.
-- Assume there is a 10% probability of failure. Using 2 copies, you will
-- get a mere 1% failure probability. But, if you want to be sure, you will
-- probably make a third copy, lowering failure probability to 0.1%. This
-- applies if you write a single, big file to each floppy.
-- This program writes a number of chunks (13 by default) to each floppy. So,
-- unless the floppy fails completely, the failure probability is reduced.
-- In fact, assume there is a 10% probability of a floppy developing a single
-- bad sector or track, and let us disregard the possibility of double,
-- triple, etc. failure, only to simplify the calculation.
-- This means, as assumed early, that a big file spanning all floppy tracks
-- will have a 10% failure probability.
-- But this program (by default) writes 13 files (chunks) to each floppy.
-- So, the probability of any specific chunk getting bad is 0.1 / 13 = 0.0077,
-- that is, 0.77%.
-- And the probability of having *the same* chunk bad in the 2nd copy is
-- 0.0077 * 0.0077 = 0.00006, that is, only 0.006%, or less than 1 case in
-- 100,000.
-- But a big file was split into 13 chunks, and then, the probability of
-- this file getting bad is about 13 * 0.00006 = 0.00078, that is, 0.077%.
-- So, compare: using floppy-sized chunks and 2 copies, you get a 1%
-- probability of getting a bad 1,457,664-byte file.
-- And using the present technique, you have a 0.077% failure probability
-- under the same conditions: a 13-fold decrease, as you could have guessed
-- at first.
-- This calculation has been simplified to some extent.
-- Please note that this decrease in failure probability is attained only
-- if you make 2 or more copies of the files.
--
-- 6) The program checks floppies to avoid overwriting them in case you
-- inadverentently left in the drive the last one written by the program, or
-- even if you try writing to a floppy that was previously used in the same
-- run.
--
-- 7) Source code is provided. This code is free for everybody. You can
-- modify it to your taste, or use any part of it as you like. You do not
-- need to do so, but I will be glad if you mention me when you use part or
-- all of the code. Especially interesting is the extremely fast knapsack
-- algorithm included, that may be used to fill to the brim floppies, CDs,
-- etc., or even trucks.
--
--                               REQUIREMENTS
-- HARDWARE: PC 386 and up. Hard disk. 3 1/2" (or 5 1/4") floppy drive.
-- RAM depending on data (8 MB will usually suffice). Hard disk space
-- depending on data (100 MB free space will suffice in most cases).
--
-- SOFTWARE: MSDOS and compatibles; or Windows 95, 98 FE, 98 SE, ME, 2000,
-- NT, XP; or Linux; or Free BSD. Euphoria Interpreter / Compiler. PKZIP /
-- PKUNZIP (if using long names, a version supporting them).
--
--                      FILES CONTAINED IN THE PACKAGE
-- The archive EUREAP.ZIP contains:
--
-- 1) This README.TXT file, or as part of the source code.
--
-- 2) Source code for the program, named EUREAP.EX.
--
-- 3) REAP.BAT, to ease use.
--
--                        INSTALLATION INSTRUCTIONS
-- 1) Unzip EUREAP.ZIP using PKUNZIP, WINZIP, WINRAR, or any other suitable
-- software (as you are reading this, you probably already did so).
--
-- 2) Download the Euphoria interpreter from www.RapidEuphoria.com. This is
-- a free download.
--
-- 3) Install Euphoria as instructed in the Euphoria distribution.
--
-- 4) If you do not have one, download a PKZIP version. If you are using
-- long file names, this version should support them. If it does not, you
-- will be restricted to the 8.3 DOS standard file names. If you use
-- stand-alone DOS, or boot W9X in DOS mode, you will have to modify the
-- source code to avoid problems originated by the attempt to get long names
-- when they are not supported.
-- In case you wish to use another archive compressor / decompressor, you
-- will have to modify the source code. The compressor / decompressor should
-- support being called from the command line.
--
-- 5) Create a folder named as you wish. We will call this folder
-- <user base folder>. You may use an existing, non-empty folder, but this
-- is not recommended, as the program will delete some files / folders
-- having specific names.
--
-- 6) Copy EUREAP.EX to this folder. Additionally, you might want to copy
-- REAP.BAT
--
-- 7) Copy PKUNZIP.EXE and PKZIP.EXE to the same folder. This is not needed
-- if you can access them from the DOS PATH.
--
--                            USAGE INSTRUCTIONS
-- 1) This program may be run directly from Windows, but it is preferable to
-- run it from a DOS window. While it is prepared to run under Linux /
-- Free BSD, I did not yet test this capability. Please contact me if you
-- have any difficulty in that respect.
--
-- 2) Move (or better copy) the files and folders you want to transport or
-- back-up to a folder named as you wish.
--
-- 3) Get hold of a sufficient number of formatted floppies. These floppies
-- should be, in principle, good quality, but the program supports floppies
-- with defective sectors and of different capacity, mixed as you wish.
-- In case of floppy failure, the program may be restarted at the previous
-- point.
--
-- 4) Run EUREAP.EX using the Euphoria interpreter. If correctly installed,
-- the EUPHORIA interpreter should be in the PATH. Under a DOS shell in
-- Windows, type:
-- EX EUREAP (plus an optional list of parameters).
-- You can also type: EXW EUREAP.EX to run the program under a Windows
-- environment.
-- To run it directly from Windows, associate .EX files with EX.EXE.
-- You can run REAP.BAT instead. Modify it according to the parameters you
-- need.
--
-- 5) Follow the on-screen instructions to create files on floppies.
--
-- 6) To restore the floppies contents, follow the detailed instructions
-- below.
--
--                          DETAILED INSTRUCTIONS
--
--                         FLOPPY CHARACTERISTICS
-- A double-sided, high density 3 1/2" floppy has normally capacity for
-- 1,457,664 bytes, distributed among a number of files and folders.
-- Other types of floppies may have different characteristics.
-- Floppies with defective tracks have a smaller capacity.
--
-- A floppy file can consist of any number of bytes, from 0 to 1,457,664.
-- However, as it is formed by 512-byte blocks, the real space occupied is
-- a multiple of 512. So, the directory listing may inform that file X has
-- 13,577 bytes, but the occupied space is actually 13,824 bytes (the next
-- multiple of 512); file X occupies 26 full blocks and part of a 27th block.
--
-- In addition, if files are in the root folder (A:\), the maximum number
-- of them is 224. This maximum can be reached only if file names adhere to
-- the 8.3 DOS standard, that is, 1-8 characters for the name, an optional
-- dot, and 0-3 characters for the extension.
--
-- In case some file name does not adhere to this standard, the maximum
-- number of files is less than 224, the exact limit being a function of the
-- lengths of the names.
--
-- This maximum number of files does not apply if the files are not in the
-- root folder.
--
-- The present program does not use floppy subfolders, so this maximum applies.
--
-- Floppies for this program should be formatted, but not necessarily
-- empty. All files and folders in them will be erased, unless you select
-- a (not recommended) option to keep these old files and folders.
--
-- Of course, you should not write-protect the floppies.
--
--
--                         COMMAND LINE PARAMETERS
-- Command line syntax:
-- EX EUREAP [<parameter 1>] [>parameter 2>] ... [<parameter n>]
-- [] means parameters are optional. All parameters are optional for this
-- program.
-- All letters may be upper or lower case without distinction.
-- Parameters are separated by one or more spaces or tabs.
-- No whitespace is allowed between the parameter keywor and the equal sign
-- that follows it in most cases, and between the equal sign and the parameter
-- value.
--
-- Most parameters for this program may be omitted.
--
-- BLOCK=<block size> where <block size> is a positive integer.
-- The standard block size for double-sided, high density 3 1/2" floppies
-- is 512. Usually you do not want to modify it, but if you use some other
-- floppy type, you will get better results using the block or cluster
-- size that corresponds to this type. For example, for 3 1/2" floppies
-- formatted to 720 KB, BLOCK=1024 will provide better results. In this case,
-- you should also modify the CHUNK parameter (see below).
-- Default is 512.
--
-- TIME=<time limit> where <time limit> is a positive number. It may be
-- fractional.
-- The knapsack algorithm to distribute files among floppies is usually
-- very fast. But in rare cases it may take a very long time. TIME is
-- provided to terminate the knapsack algorithm when the elapsed time is
-- too big. If the algorithm takes more than <time limit> seconds, it is
-- terminated. This does not affect the creation of floppies and, usually,
-- the distribution continues to be optimal. A message will be shown if the
-- knapsack algorithm reaches this time limit.
-- Default is 10 seconds.
--
-- CHUNK=<chunk size> where <chunk size> is a positive integer.
-- This will be the size of most of the file chunks and whole files written
-- by the program. Some files may have smaller sizes, or (rarely) slightly
-- larger sizes.
-- Default is 112128. This number crops up from the following floppy
-- characteristics:
-- 1,457,664 bytes @ 512 bytes/block = 2,847 blocks.
-- 2,847 has factors 3, 13 and 73.
-- 73 * 3 * 512 give 112,128, which is a submultiple of 1,457,664 allowing
-- for a perfect fit and giving a reasonable number of 13 files per floppy.
-- If you own an old 5 1/4" floppy drive, or some other variant, probably
-- you should specify a different chunk size, and maybe modify the source
-- code replacing the drive letter A: by B:, for example.
--
-- LCOMM=<length> where <length> is a positive integer representing a length
-- limit.
-- The program generates .BAT files to join the chunks that form a file.
-- These .BAT files consist of a command line. The command line has a
-- length limit, after which characters are lost. When a .BAT file contains
-- a longer line, this line is split and modified to keep the length within
-- bounds. This limit depends on the Operating System version, so it is
-- modifiable.
-- Default is 80, which is on the sure side.
--
-- SOURCE=<folder name> where <folder name> is the folder under which your
-- files and subfolders are located. It may include a drive letter, but it
-- cannot contain spaces. This parameter is usually required.
-- If the program is run under DOS, then only directory names obeying the
-- DOS 8.3 name rule are accepted.
-- Default is \xx (on the current drive).
--
-- ID=<identification string> where <identification string> is a sequence
-- of one or more characters to identify files for the present run.
-- It is useful to distinguish files among different sets of source data.
-- If you omit the NOLABEL parameter (see below), a label will be written
-- to the floppy. This label has a maximum size of 11 characters. It uses
-- at least 3 characters (copy number, space, and floppy number). As it
-- also includes the <identification string>, the size of this string should
-- be less or equal to 8 to avoid problems when writing the label.
-- Characters should be letters or numbers. No other characters may be used.
-- Default is a sequence of 4 letters, the first 2 taken from the date, 
-- and the last 2 randomly generated by the program.
--
-- MOVE
-- When the program starts, it either copies or moves files and subfolders
-- from the SOURCE folder to the <user base folder>\s folder.
-- By specifying the MOVE parameter, files and folders are moved instead of
-- copied, saving some processing time. However, it is recommended to leave
-- the default option, due to security reasons.
-- Default is "copy", obtained by omitting the MOVE parameter.
--
-- LOG
-- If specified, the commands issued by the program, and the results of
-- some of them, are logged respectively to the files <user base
-- folder>\l\l and <user base folder>\l\logcmd.txt.
-- This serves the purpose of debugging for the program developer. It may
-- also be useful for the user, to see when and how a problem happened, and
-- to report problems to the author.
-- Default is "nolog", obtained by omitting the LOG parameter.
--
-- NOREZIP
-- The program tries to diminish the size of .ZIP archives by unzipping them
-- and re-zipping to maximum compression. This might take too much time. If
-- you want to optimize time instead of space, specify NOREZIP.
-- However, unzipping and re-zipping archives provides a correctness check,
-- to avoid transporting or backuping corrupted archives.
-- If the program finds a corrupted archive, it issues a warning,
-- allowing the user to continue or cancel the program.
-- Default is "rezip", obtained by omitting the NOREZIP parameter.
--
-- SIGNATURE
-- A zip file usually has a .ZIP extension in the name, but this is not
-- necessary. Conversely, a file with a .ZIP extension could not be a true
-- ZIP file.
-- The contents of a true ZIP file start with what is known as a "signature".
-- This signature consists of 4 bytes: the letters PK followed by 03hex and
-- 04hex.
-- If you do not specify NOREZIP, the program will unzip ZIP files and then
-- re-zip them at maximum compression. To identify a zip file, the program
-- checks both the extension and the signature. If the signature is not the
-- one previously mentioned, the program will not attempt to unzip/re-zip the
-- file, even if its extension is .ZIP.
-- If you do not specify SIGNATURE, the program will not re-zip a zip file
-- that has the rigth signature unless it has a .ZIP extension.
-- If you specify SIGNATURE, the program will re-zip a file with the
-- right signature even if it has not a .ZIP extension (assuming you omitted
-- the NOREZIP parameter).
--
-- ZIPAGAIN
-- This option specifies that zip files, no matter whether generated by this
-- program or present in the source data, be zipped again.
-- This may achieve a greater compression, not usually significative, at the
-- cost of more processing time.
-- Default is "donotzipagain", obtained by omitting the ZIPAGAIN parameter.
--
-- NOZIPSMALL
-- By default, files and file chunks smaller than <chunk size> (see the CHUNK
-- parameter for details) will be joined and zipped into files whose size is
-- approximately <chunk size> (usually smaller). You can avoid this by
-- specifying NOZIPSMALL. In some cases, especially when floppies have bad
-- sectors, it might save some floppy space, but in other cases the reverse
-- may happen.
-- If you specify this parameter, when restoring the files you will not
-- have to unzip the files with a .Z extension mentioned later, because these
-- files will not exist.
-- Default is "zipsmall", obtained by omitting the NOZIPSMALL parameter. This
-- will zip together files and chunks smaller than the specified chunk size.
--
-- NOLABEL
-- A floppy label is written to each floppy. The label is composed by the
-- run identification, followed by a number, followed by a space, followed
-- by the floppy number.
-- If you do not want the floppy label being modified, specify NOLABEL.
-- Default is "label", obtained by omitting the NOLABEL parameter.
--
-- SKIP
-- When a floppy fails (possibly giving a Critical Error message), you can
-- retry the operation, but normally this will be of no avail. You then
-- abort the floppy operation, which means aborting the program. But you
-- had already used valuable processing time, and do not want losing it.
-- In such a case, you can add the SKIP parameter to the command line and
-- run again the program from the same folder. The program will start
-- writing the floppies from the the point it was aborted, so you will lose
-- nothing.
-- You can also use the SKIP parameter to make another copy of the files,
-- if for any reason you did not so during the initial run.
-- When SKIP is specified, the only other parameters that have any effect are
-- TIME=<time limit>, LOG and NOLABEL.
--
--
--                            WRITING FLOPPIES
-- Once the program is started, the user will be instructed to insert
-- floppies.
--
-- The program copies all the generated files to the floppies. To hold all
-- the files, you will need to use one or more floppies. The program sounds
-- a beep and shows the copy number and the floppy number each time it
-- instructs to insert a new floppy. If you want, you can write down these
-- numbers on the floppy label, but this is not necessary.
--
-- The program allows writing more than one copy of the set of floppies. You
-- will see a message asking whether you want to write copy number 1, 2,
-- etc.
--
-- You can abort the process at any time, either answering 'n' to the prompt
-- to make another copy or 'x' to the request to insert a new floppy, or by
-- any other means. Afterwards, you may restart the process at the point of
-- interruption by running the program with the SKIP parameter.
--
--
--                            RETRIEVING FILES
-- The generated floppies contain files of these types:
--
-- 1) Chunks. They are named <ID>n.m, where m and n are decimal numbers
-- consisting of one or more digits.
-- <ID> is the run identification provided by you or generated by the program.
-- n is the number of the archive of which this chunk is part.
-- m is the sequence number of the chunk.
--
-- 2) Zipped files named <ID>n.Z.
-- <ID> is the run identification provided by you or generated by the program.
-- n is a sequence number.
-- Due to the fact that many small chunks and other files could be generated,
-- to avoid poor use of space they are zipped together, forming these .Z
-- archives (unless you specify the NOZIPSMALL parameter).
--
-- 3) In rare cases, zipped files with the normal .ZIP extension. They are
-- zipped source files that have exactly CHUNK size. Many of these files
-- could be present if you specify the NOZIPSMALL parameter.
--
-- To retrieve files, do the following:
--
-- a) Create a folder in the hard disk and copy all the files in the floppies
-- to this folder. If some file fails, you probably will have another copy of
-- it in some other floppy; overwrite the corrupted copy with the new one.
-- In such a case, it might be a good idea to delete the failing file
-- from both the hard disk and the bad floppy before attempting to copy the
-- remaining files from the same floppy. You should not discard the failing
-- floppy before trying to copy all possible files from it, to insure you
-- have at least two copies of each file.
-- Be sure all files in the back-up were written to the hard disk, because
-- the 'copy' command, when joining files, does not check for missing ones.
--
-- b) Some files with a .Z extension will be in the folder. Unzip them to
-- the same folder using the archiver of your election. These files have
-- standard ZIP format. In case you had specified the NOZIPSMALL parameter,
-- these files with a .Z extension will not exist.
--
-- c) This will unzip some files, among them some .BAT files. Execute the
-- XTRA<ID>.BAT file by double clicking its icon or, under DOS, by merely
-- typing XTRA<ID> (either upper or lower case). <ID> is the identification
-- specified by the user as ID=<identification string> or generated by the
-- program.
-- Disregard a final error message saying that a batch file is missing.
-- This message is shown because the last .BAT file erases itself.
--
-- d) Now, you will have a bunch of .ZIP files, named as the original files
-- or folders with the addition of .ZIP. Files that had an original .ZIP
-- extension will now have a double extension: .ZIP.ZIP. This is necessary
-- because, for example, it is possible to have a file named A.ZIP and a
-- folder named A. In such a case, if we add a single .ZIP extension to
-- the name of the A file, it would become A.ZIP, and the folder would be
-- also named A.ZIP, which would cause conflicts.
-- You can restore their contents by unzipping them. Do not forget to
-- specify recovering full paths in case you had processed folders.
-- Please remember that, if you had original files with the .ZIP extension,
-- what you have now is the same file, maybe slightly smaller due to
-- re-zipping.
-- As explained before, file or folder names (only upper level) containing
-- spaces, commas or plus signs had suffered the substitution of every
-- one of these characters by an underscore (_) character.
--
---------------------------END OF README------------------------------------

include file.e
include wildcard.e
include misc.e
include sort.e
include get.e
include graphics.e
include dll.e

constant FCAP = 1457664 --3 1/2" floppy normal capacity
constant ZIPID = "PK" & {3, 4} --Zip files signature
atom T --Time for knapsack algorithm
atom Tlimit --Time limit
Tlimit = 10 --Default: 10 seconds
integer M, Flog, Norezip, Zipagain, Signature, Zipsmall, Nolabel, Lcommand, Skip
M = 0 --Default "copy" option (not "move") from source folder
Skip = 0 --Default value for skipping or not 1st part
Norezip = 0 --Default for re-zipping files: do it
Nolabel = 0 --Default for writing floppy label: do it
Signature = 0 --Default: do not rely on file signature when .ZIP is missing
Zipagain = 0 --Default for zipping again zip files: do not do it
Zipsmall = 1 --Default for re-zipping small files and chunks: do it
Flog = -1 --Default value: no log
Lcommand = 80 --Default maximum length of generated DOS command
sequence Log, Logcmd, Id, Serials, d
d = date()
integer n, q, r
n = d[1] * 366 + d[8]
q = floor(n / 26)
r = n - q * 26
q = remainder(q, 26)
Id = 'A' + q & 'A' + r & 'A' - 1 + rand(repeat('Z' - 'A' + 1, 2)) --Default Id
Log = "nul" --Default log file
Logcmd ="l\\c"
sequence Sdir --Source folder
Sdir = "\\xx" --Default: \xx
integer Bsize
atom Capacity, Alpha
Alpha = 0.4 --Exponential smoothing factor
Capacity = 0 --Initial floppy capacity
Bsize = 512 --Default floppy block size: 512
integer Csize --Chunk size
Csize = 112128 --Default chunk size
--Floppy 3 1/2" = 1457664 bytes = 2847 512-byte blocks
--2847 = 3 * 13 * 73. 2847 / 13 = 219 blocks. 219 * 512 = 112128 bytes / chunk

integer Last, Lendata, Bestlast
integer Goal, Val, Bestval, Limit
sequence Data, Index, Accum, Bestind

function flushinput(sequence s)
--Gets a character from the keyboard
    integer c
    puts(2, "Valid answers: " & s & "\n")
    while 1 do
	c = getc(0)
	if find(c, s) then
	    return c
	elsif c != '\n' then
	    puts(2, "\nYou should enter a character from " & s & "\n")
	end if
    end while
end function

procedure logmsg(sequence s)
--Log message to log file and show it on standard error file
    if Flog >= 3 then
	puts(Flog, s & "\n")
    end if
    puts(2, s & "\n")
end procedure

procedure sys(sequence s)
--Wrap system() procedure
    logmsg(s)
    system(s, 2)
end procedure

procedure syslog(sequence s)
--Add "append to Log" to sys()
    sys(s & ">>" & Log)
end procedure

function sysex(sequence s)
--Wrap system_exec() function
    logmsg(s)
    return system_exec(s, 2)
end function

procedure error(integer n, sequence msg)
--Shows error message and aborts execution
    logmsg(sprintf("Error %d: " & msg, n))
    abort(n)
end procedure

procedure warning(integer n, sequence msg)
--Shows warning message and gives option to abort execution
    integer c
    logmsg(sprintf("Warning %d: " & msg, n))
    logmsg("Do you want to abort execution (y/n)?")
    c = flushinput("yYnN")
    logmsg(c & "")
    if c != 'n' and c != 'N' then
	abort(n)
    end if
end procedure

procedure beep(integer freq)
--Make a sound
    atom err, t, kernel32
    integer Beep
    if platform() = WIN32 then
	kernel32 = open_dll("kernel32.dll")
	Beep = define_c_func(kernel32, "Beep", {C_POINTER, C_INT}, C_INT)
	--call system Beep routine
	err = c_func(Beep, {0,0})
	if err then
	    logmsg(sprintf("Error %d while trying to beep", err))
	end if
    elsif platform() = DOS32 then
	--make beep
	sound(freq)
	t = time()
	while time() < t + 0.5 do
	end while
	sound(0)
    else
	--do nothing (Linux/FreeBSD)
    end if
end procedure

function writeto(sequence name, sequence data, integer err, integer sw)
--Subroutine to write a single record file
--If sw = 0, use puts(). Else, use print()
--Returns length of data as written by puts or print
    integer fo, len
    len = length(data)
    fo = open(name, "w")
    if fo = -1 then
	error(err, "Opening " & name & " for writing")
    end if
    if sw then
	print(fo, data)
    else
	if platform() = DOS32 or platform() = WIN32 then
	    for i = len to 1 by -1 do --Count CR's added
		if data[i] = '\n' then
		    len += 1
		end if
	    end for
	end if
	puts(fo, data)
    end if
    close(fo)
    return len
end function

function readfrom(sequence name, integer err)
--Subroutine to get a single Euphoria object
    integer fi
    sequence in
    fi = open(name, "r")
    if fi = -1 then
	error(err, "Opening " & name & " for reading")
    end if
    in = get(fi)
    if in[1] = GET_SUCCESS then
	in = in[2]
    else
	error(err, "Reading " & name)
    end if
    close(fi)
    return in
end function

function adjust(object k)
--Adjusts file length to an integer number of blocks(upwards)
    return Bsize * -floor(-k / Bsize) --Use ceiling
end function

function adjustdown(object k)
--Adjusts capacity to an integer number of blocks(downwards)
    return Bsize * floor(k / Bsize)
end function

procedure command()
--Parses the command line
    sequence cmd, s, r, x, v
    integer n
    object test
    cmd = command_line()
    for i = 3 to length(cmd)  do
	s = upper(cmd[i])
	n = find ('=', s)
	if n then
	    x = s[1..n - 1]
	    r = s[n + 1..length(s)]
	    if equal("BLOCK", x) then
		v = value(r)
		if v[1] = GET_SUCCESS then
		    if not atom(v[2]) or v[2] <= 0 then
			error(1, "Bad block size spec")
		    end if
		    Bsize = v[2]
		else
		    error(2, "Bad block size spec")
		end if
	    elsif equal("TIME", x) then
		v = value(r)
		if v[1] = GET_SUCCESS then
		    if not atom(v[2]) or v[2] <= 0 then
			error(3, "Bad time limit spec")
		    end if
		    Tlimit = v[2]
		else
		    error(4, "Bad time limit spec")
		end if
	    elsif equal("CHUNK", x) then
		v = value(r)
		if v[1] = GET_SUCCESS then
		    if not atom(v[2]) or v[2] <= 0 then
			error(5, "Bad chunk size spec")
		    end if
		    Csize = v[2]
		else
		    error(6, "Bad chunk size spec")
		end if
	    elsif equal("LCOMM", x) then
		v = value(r)
		if v[1] = GET_SUCCESS then
		    if not atom(v[2]) or v[2] <= 0 then
			error(7, "Bad command line size spec")
		    end if
		    Csize = v[2]
		else
		    error(8, "Bad command line size spec")
		end if
	    elsif equal("SOURCE", x) then
		Sdir = r
	    elsif equal("ID", x) then
		Id = r
	    else
		error(9, "Wrong parameter " & s)
	    end if
	elsif equal("MOVE", s) then
	    M = 1 --Set "move" option
	elsif equal("LOG", s) then
	    Log = "l\\g" --Log file (default is nul)
	elsif equal("NOREZIP", s) then
	    Norezip = 1 --Do not re-zip files
	elsif equal("SIGNATURE", s) then
	    Signature = 1
	elsif equal("ZIPAGAIN", s) then
	    Zipagain = 1 --Zip again zip files
	elsif equal("NOZIPSMALL", s) then --Do not rezip small files / chunks
	    Zipsmall = 0
	elsif equal("NOLABEL", s) then
	    Nolabel = 1 --Do not alter floppy label
	elsif equal("SKIP", s) then
	    Skip = 1 --Skip 1st part of the program
	else
	    error(10, "Wrong parameter " & s)
	end if
    end for
    if Csize != adjust(Csize) then
	error(11, "Chunk size not divisible by Block size")
    end if
    if Skip = 0 then
	test = dir(Sdir)
	if atom(test) then
	    warning(12, "Source dir " & Sdir & " may not exist")
	end if
    end if
end procedure

function Mcd2(integer d, integer r)
--Maximum common divisor of two numbers 
    integer x
    while r do
	x = remainder(d, r)
	d = r
	r = x
    end while
    return d
end function

function Mcd(sequence s)
--Maximum common divisor of numbers within a simple sequence
    integer len, r
    len = length(s)
    r = s[len]
    for i = len - 1 to 1 by -1 do
	if r = 1 then
	    return r
	end if
	r = Mcd2(r, s[i])
    end for
    return r
end function

function recurse()
--Recursive routine to manage the knapsack algorithm
    integer ind, r, dat, i1
    if Val > Goal then --Impossible to get better values
	if time() - T > Tlimit then --Test imposed time limit
	    logmsg("Reached time limit")
	    beep(220)
	    T = time()
	    while time() > T + 5 do --Pause to show message
	    end while
	    return 1 --Signal best possible value attained
	end if
	return 0
    elsif Val < Goal then --Try to go ahead
	ind = Index[Last] --Go to next data item
	if Val > Bestval then --Test for better value
	    Bestval = Val --Update best value and corresponding indexes
	    Bestlast = Last
	    Bestind = Index
	end if
	if Val > Limit then --Impossible to get better values
	    return 0
	end if
	while 1 do
	    i1 = ind --Previous
	    ind += 1
	    if ind > Lendata then --End of data vector
		return 0
	    end if
	    if Val + Accum[ind] <= Bestval then --Impossible to get better value
		return 0
	    end if
	    dat = Data[ind]
	    if dat != Data[i1] or Index[Last] = i1 then --Skip repetition
		Last += 1 --Try next index
		Index[Last] = ind
		Val += dat
		r = recurse()
		if r then --Best possible value found
		    return 1
		end if
		Val -= dat --Restore previous value
		Last -= 1
	    end if
	end while
    else
	Bestval = Val --Val = Goal
	Bestlast = Last
	Bestind = Index
	return 1 --Indicate best possible value found
    end if
end function

procedure optim()
--Routine to solve the knapsack problem
    integer r
    Bestval = 0
    Last = 1
    Bestlast = 1
    Index[1] = 1
    Val = Data[1]
    Limit = Goal - Data[Lendata]
    Bestind = Index
    r = recurse()
end procedure

function knapsack()
--Main routine for the knapsack problem
    integer mcd
    T = time()
    Lendata = length(Data)
    Index = repeat(0, Lendata)
    if Lendata = 0 then
	Bestlast = 0
	Bestval = 0
	Bestind = {}
    elsif Lendata = 1 then
	Bestlast = 1
	Bestind = {1}
	Bestval = Data[1]
    else
	Accum = Data
	for i = Lendata to 2 by -1 do
	    Accum[i - 1] += Accum[i]
	end for
	mcd = Mcd(Data)
	Goal -= remainder(Goal, mcd)
	optim()
    end if
    return Bestind[1..Bestlast]
end function

function dropblanks(sequence s)
-- Eliminate spaces from s (it may contain only trailing spaces)
-- It always contains at least one
    return s[1..find(' ', s) - 1]
end function

function longdir(sequence ndir, sequence tempdir)
--Overcome dir() (no long names) limitation under DOS
    integer fn, len, num
    atom filesize
    sequence longdesc, desc, result, dir, name, newname, size, aux, sname, ext
    object line
    sys("dir " & ndir & " > " & tempdir & "\\list")
    fn = open(tempdir & "\\list", "r")
    if fn = -1 then
	error(13, "Opening " & tempdir & "\\list")
    end if
    longdesc = {}
    while 1 do
	line = gets(fn)
	if atom(line) then
	    exit
	end if
	longdesc = append(longdesc, line[1..length(line) - 1])
    end while
    close(fn)
    longdesc = longdesc[6..length(longdesc) - 2] --Ignore 5 heading and 2 trailing lines
    len = length(longdesc)
    num = 0
    result = {}
    for i = 1 to len do
	desc = longdesc[i]
	dir = desc[16..20]
	name = desc[45..length(desc)]
	sname = desc[1..9]
	ext = desc[10..13]
	sname = dropblanks(sname)
	ext = dropblanks(ext)
	if length(ext) then
	    sname &= "." & ext
	end if
	if not (equal(name, ".") or equal(name, "..")) then
	    newname = "A" & sprintf("%d.ZIP", num)
	    num += 1
	    if equal(dir, "<DIR>") then
		filesize = -1 --It is a directory
	    else --It is a file
		size = desc[14] & desc[16..18] & desc[20..22] & desc[24..26]
		for j = 1 to length(size) do
		    if size[j] = ' ' then
			size[j] = '0'
		    end if
		end for
		aux = value(size)
		filesize = aux[2]
		if aux[1] != GET_SUCCESS or not integer(filesize) then
		    error(14, "File size too long or invalid")
		end if
	    end if
	    result = append(result, {newname, sname, name, filesize})
	end if
    end for
    return result
end function

procedure credits()
--Show name, author, version, date...
    puts(2, "\n                                  EUREAP\n")
    puts(2, "\n")
    puts(2, "               A program to transport files using floppies\n")
    puts(2, "                A program to back-up files using floppies\n")
    puts(2, "                         Version 1.4 - 2005/09/21\n")
    puts(2, "\n")
    puts(2, "                           Author: R. M. Forno\n")
    puts(2, "                            Contact either of:\n")
    puts(2, "   rmforno@tutopia.com, rforno@uyuyuy.com, ricardoforno128@hotmail.com\n\n")
end procedure

procedure enablelog()
--Enable logging
    if equal("nul", Log) then
	Flog = -1
    else
	Flog = open(Logcmd, "w")
	if Flog < 3 then
	    error(15, "Opening log file: " & Logcmd)
	end if
    end if
end procedure

function ziptype(sequence name)
--Subroutine to see if a file has a zip signature
    integer fi, c
    sequence in
    fi = open(name, "rb")
    if fi = -1 then
	error(16, "Opening " & name & " for reading")
    end if
    in = ""
    for i = 1 to 4 do
	c = getc(fi)
	if c < 0 then
	    exit
	end if
	in &= c
    end for
    c = equal(in, ZIPID)
    close(fi)
    return c
end function

function procdir()
--Zip or re-zip files and folders
    sequence lname, aux, desc, entry, newname, sname
    integer st, len, zipid, filesize
    if not atom(dir("p")) then
	logmsg("It seems this folder is loaded with a previous run of this program")
	logmsg("If you continue, data from the previous run will be lost")
	logmsg("Are you sure you want to start the back-up from scratch?")
	logmsg("If not, answer 'n' and restart the program using the SKIP parameter")
	st = flushinput("YyNn")
	if st = 'n' or st = 'N' then
	    abort(0)
	end if
    end if
    sys("deltree /y l") --Insure subfolders are empty
    sys("md l")
    enablelog()
    syslog("deltree /y a")
    syslog("deltree /y s")
    syslog("deltree /y z")
    syslog("deltree /y b")
    syslog("deltree /y q")
    syslog("md a")
    syslog("md s")
    syslog("md b")
    syslog("md z")
    syslog("md q")
    if M then --Move or Copy option
	syslog("move \"" & Sdir & "\"\\* s")
    else
	syslog("xcopy /e \"" & Sdir & "\"\\* s")
    end if
    desc = longdir("s", "a")
    len = length(desc)
    for i = 1 to len do
	entry = desc[i]
	newname = entry[1]
	sname = entry[2]
	lname = entry[3]
	filesize = entry[4]
	zipid = match("PIZ.", upper(reverse(sname))) --Identify signature
	if filesize = -1 then --Is it a folder?
	    syslog("md b\\dirs")
	    syslog("move \"s\\" & lname & "\" b\\dirs")
	    syslog("pkzip -exx -rp -whs z\\"
		& newname & " b\\dirs\\*") --Zip to 'z' folder
	    syslog("deltree /y b\\dirs")
	elsif ziptype("s\\" & sname) and (1 = zipid or Signature) then
	    if Norezip then
		syslog("copy \"s\\" & lname & "\" z\\" & newname)
	    else
		syslog("deltree /y b\\*")
		syslog("pkunzip -d -Jhsra \"s\\" & sname & "\" b") --Unzip to 'b' folder
		syslog("pkzip -exx -rp -whs z\\"
		    & newname & " b\\*") --Re-zip
		aux = longdir("z\\" & newname, "a")
		if aux[1][4] >= filesize then --If not better
		    syslog("deltree /y z\\" & newname)
		    syslog("copy \"s\\" & lname & "\" z\\" & newname)
		end if
	    end if
	else --Any other file type
	    syslog("pkzip -exx -whs z\\"
		& newname & " \"s\\" & sname & "\"") --Zip file
	end if
	if Zipagain then
	    aux = longdir("z\\" & newname, "a")
	    filesize = aux[1][4]
	    syslog("deltree /y b\\*")
	    syslog("move z\\" & newname & " \"b\\" & lname & ".ZIP\"")
	    syslog("pkzip -exx z\\" & newname & " b\\*") 
	    aux = longdir("z\\" & newname, "a")
	    if aux[1][4] >= filesize then
		syslog("move /Y \"b\\" & lname & ".ZIP\" z\\" & newname)
	    else
		desc[i][3] &= ".ZIP"
	    end if
	end if
	aux = longdir("z\\" & newname, "a")
	desc[i][4] = aux[1][4] --Compressed file length
    end for
    return desc
end function

function split(sequence desc)
--Splits files bigger than Csize into chunks
    sequence id, id1, join, sizes, outjoin, aux, files, indexes
    sequence extract, item, endren, lname, name, newname
    integer fi, fo, fnum, anum, c, count, ldesc, lenname, numjoin, num, k
    integer size, len, goal
    object line
    ldesc = length(desc)
    if ldesc = 0 then
	puts(1, "There are no files to process\n")
	abort(-1)
    end if
    syslog("deltree /y p") --Insure subfolder is empty
    syslog("md p")
    sizes = {}
    anum = 0 --Archive number
    extract = "deltree /y #out\nmd #out\n"
    endren = {}
    for i = 1 to ldesc do
	item = desc[i]
	newname = item[1]
	lname = item[3] & ".ZIP"
	size = item[4]
	if size <= Csize then --If small, only copy and rename afterwards
	    syslog("move z\\" & newname & " p\\")
	    endren &= "ren " & newname & " \"" & lname & "\"\n"
	    sizes = append(sizes, {size, newname, 1}) --1 means not yet processed
	else --Split
	    join = "copy/b "
	    outjoin = {}
	    fnum = 0
	    fi = open("z\\" & newname, "rb")
	    if fi = -1 then
		error(17, "Opening z\\" & newname)
	    end if
	    lenname = length(newname)
	    numjoin = 0
	    c = getc(fi) --Get first character
	    while c >= 0 do --While not EOF
		id = sprintf(Id & "%d.%d", {anum, fnum})
		fo = open("p\\" & id, "wb") --Open chunk file
		if fo = -1 then
		    error(18, "Opening p\\" & id)
		end if
		id1 = id & "+"
		len = length(id1) + lenname + 5 --5 is length of #out\
		if length(join) + len >= Lcommand then --Exceeds allowed length?
		    numjoin += 1
		    join[length(join)] = ' '
		    aux = sprintf("#out\\#%d", numjoin)
		    join &= aux & "\n"
		    outjoin &= join
		    join = "copy/b " & aux & "+"
		end if
		join &= id1 --Build data for bat file to join chunks
		count = 0
		while c >= 0 and count < Csize do --Write file chunk
		    puts(fo, c)
		    c = getc(fi)
		    count += 1
		end while
		close(fo)
		sizes = append(sizes, {count, id, 1})
		fnum += 1
	    end while
	    join[length(join)] = ' '
	    outjoin &= join & "#out\\" & newname & "\n"
	    if numjoin then --If auxiliary files used
		outjoin &= "del #out\\#*\n" --Prepare delete auxiliary files
	    end if
	    outjoin &= "ren #out\\" & newname & " \"" & lname & "\"\n"
	    len = writeto("p\\j.bat", outjoin, 201, 0)
	    aux = Id & "j" & sprintf("%d", anum) & ".bat"
	    sizes = append(sizes, {len, aux, 1})
	    extract &= "call " & aux & "\n"
	    syslog("ren p\\j.bat " & aux)
	    close(fi)
	    anum += 1
	end if
    end for
    extract &= "move *.ZIP #out\nmove " & Id & "ret.bat #out\n"
    extract &= "move " & Id & "end.bat #out\ncd #out\n" & Id & "ret\n" --Prepare end
    len = writeto("p\\xtra.bat", extract, 202, 0)
    sizes = append(sizes, {len, "xtra" & Id & ".bat", 1})
    syslog("ren p\\xtra.bat xtra" & Id & ".bat")
--
    extract = "del ..\\" & Id & "*\nmove *.ZIP ..\nmove " & Id & "end.bat ..\n"
    extract &= "del ..\\xtra" & Id & ".bat\ncd ..\n" & Id & "end\n"
    len = writeto("p\\ret.bat", extract, 203, 0)
    syslog("ren p\\ret.bat " & Id & "ret.bat")
    sizes = append(sizes, {len, Id & "ret.bat", 1})
--
    endren &= "del #out\\" & Id & "ret.bat\nrd #out\ndel " & Id & "end.bat\n"
    len = writeto("p\\end.bat", endren, 204, 0)
    syslog("ren p\\end.bat " & Id & "end.bat")
    sizes = append(sizes, {len, Id & "end.bat", 1})
    sizes = sort(sizes) --Will be used in reverse order
    -- Zip again small files
    if Zipsmall then --If re-zipping small files and small chunks specified
	Goal = Csize - Bsize --Add some slack
	files = {}
	Data = {}
	syslog("deltree /y q\\*")
	for i = length(sizes) to 1 by -1 do --Scan for small files
	    if sizes[i][1] < Goal then
		files = append(files, sizes[i][2])
		Data &= sizes[i][1]
		syslog("move p\\" & sizes[i][2] & " q")
		sizes = sizes[1..i - 1] & sizes[i + 1..length(sizes)]
	    end if
	end for
	num = 0
	while length(Data) do
	    goal = Goal --Save Goal
	    indexes = knapsack() --Try to fill a chunk
	    Goal = goal --Restore Goal
	    syslog("deltree /y b\\*")
	    for i = length(indexes) to 1 by -1 do --Get rid of files to be zipped
		k = indexes[i]
		syslog("move q\\" & files[k] & " b")
		Data = Data[1..k - 1] & Data[k + 1..length(Data)]
		files = files[1..k - 1] & files[k + 1..length(files)]
	    end for
	    name = sprintf(Id & "%d.z", num)
	    num += 1
	    syslog("pkzip -exx -whs p\\" & name & " b\\*") --Zip file
	    line = longdir("p\\" & name, "a")
	    sizes = append(sizes, {line[1][4], name, 1})
	end while
    end if
    return reverse(sort(sizes))
end function

function freespace()
--Gets serial # and free space from folder listing
    object line
    sequence prev, serial, free
    integer i, k, l, fn
    free = repeat('0', 7)
    sys("dir A: > a\\lista")
    fn = open("a\\lista", "r")
    if fn = -1 then
	error(19, "Opening a\\lista")
    end if
    i = 0
    while 1 do --Exit will terminate loop
	i += 1
	line = gets(fn)
	if atom(line) then
	    exit
	end if
	l = length(line)
	prev = line --Always contains last line
	if i = 3 then
	    serial = prev[l - 9..l - 1]
	end if
    end while
    if i <= 1 then
	error(20, "No floppy in drive A:")
    end if
    for j = l to 1 by -1 do --Search for free space data in last line
	k = prev[j]
	if k >= '0' and k <= '9' then
	    free[5..7] = prev[j - 2..j]
	    free[2..4] = prev[j - 6..j - 4]
	    free[1] = prev[j - 8]
	    exit
	end if
    end for
    close(fn)
    prev = value(free)
    if prev[1] != GET_SUCCESS then
	error(21, "Problem reading floppy in drive A:")
    end if
    return {prev[2], serial, i > 7} --If i > 7, at least has 1 file/folder
end function

function remove(sequence indexes)
--Removes elements from 'data' as flagged by 'indexes'
    sequence s, r
    integer lend, leni
    lend = length(Data)
    leni = length(indexes)
    s = repeat(1, lend)
    r = {}
    for i = 1 to leni do
	s[indexes[i]] = 0
    end for
    for i = 1 to lend do
	if s[i] then
	    r &= Data[i]
	end if
    end for
    return r
end function

function reducedsize()
--Computes space left when a minimum file is added
    sequence name, sp_ser
    integer fn
    while 1 do
	name = 'A' - 1 + rand(repeat('Z' - 'A' + 1, 12))
	name[9] = '.'
	fn = open("A:\\" & name, "rb")
	if fn >= 3 then
	    close(fn)
	else
	    exit
	end if
    end while
    sys("echo x > A:\\" & name)
    sp_ser = freespace()
    syslog("deltree /y A:\\" & name)
    return sp_ser[1]
end function

function requiredfloppies()
--Determines number of floppies needed
    integer k, goal
    sequence indexes
    k = 0
    while length(Data) do
	goal = Goal --Save Goal
	indexes = knapsack()
	Goal = goal --Restore Goal
	Data = remove(indexes)
	k += 1
    end while
    return k
end function

procedure fill(sequence sizes, integer copy, integer seq)
--Fill floppies to the brim
    sequence files, indexes, inddata, label, serial, sp_ser, dt
    integer k, lens, c, st, unwritten, ind, cpy, sq, w, bsize, sw, rf, acum, q
    integer dummy, goal
    if copy = 1 and seq = 1 then
	Capacity = FCAP
    end if
    lens = length(sizes)
    while 1 do
	Goal = adjustdown(Capacity)
	files = {}
	dt = {}
	inddata = {}
	k = 0
	unwritten = 0 --See whether there are any files not yet written
	for i = 1 to lens do --Scan for unwritten files
	    if sizes[i][3] then
		files = append(files, sizes[i][2])
		dt &= sizes[i][1]
		inddata &= i
		unwritten += 1
	    end if
	end for
	Data = adjust(dt)
	rf = requiredfloppies() --This routine clears Data variable
	if rf = 0 then
	    exit --No files left
	end if
	Data = dt --Reset Data
	beep(440)
	logmsg(sprintf("Copy #%d: Ready to write floppy #%d", {copy, seq}))
	logmsg(sprintf("About %d floppies remain to be written from a total of %d",{rf, rf + seq - 1}))
	logmsg(sprintf("Total files: %d. Not yet written: %d", {lens, unwritten}))
	logmsg("Please insert a floppy without write-protection into drive A:")
	logmsg("WARNING: All files in it will be deleted")
	logmsg("You may also skip deleting files, but this option is not recommended")
	logmsg("Type y and hit enter key when ready")
	logmsg("Type n and hit enter key if you want to keep old files")
	if seq > 1 then
	    logmsg("Type c to skip this floppy and start with a new full copy")
	end if
	logmsg("Otherwise, type x and hit enter key to exit program")
	logmsg("If you exit the program, you may restart it at the exit point")
	logmsg("by running it later with the SKIP parameter")
	if seq > 1 then
	    c = flushinput("xXyYnNcC")
	else
	    c = flushinput("xXyYnN")                
	end if
	logmsg(c & "")
	if c = 'x' or c = 'X' then
	    abort(0)
	elsif c = 'c' or c = 'C' then
	    return --Start a full new copy
	elsif c = 'y' or c = 'Y' then
	    w = 1 --Flag delete to be done
	else
	    w = 0 --Flag avoiding delete
	end if
	while 1 do
	    sp_ser = freespace()
	    Goal = sp_ser[1]
	    serial = sp_ser[2]
	    sw = sp_ser[3] --1 means there is at least 1 file/folder
	    ind = find(serial, Serials[1])
	    logmsg("Floppy serial: " & serial)
	    if ind then
		cpy = Serials[2][ind]
		sq = Serials[3][ind]
		logmsg(sprintf("This floppy was already written to in this run as Copy #%d Seq %d", {cpy, sq}))
		logmsg("To avoid losing data, please replace it with a new floppy")
		logmsg("Then type:")
		logmsg("y to check and use the new floppy")
		logmsg("x to abort the program")
		logmsg("i to ignore this warning and continue processing")
		logmsg("If you exit the program, you may restart it at the exit point")
		logmsg("by running it later with the SKIP parameter")
		c = flushinput("xXyYiI")
		logmsg(c & "")
		if c = 'x' or c = 'X' then
		    abort(0)
		elsif c = 'i' or c = 'I' then
		    exit
		end if
	    else
		exit
	    end if
	end while
	Serials[1] = append(Serials[1], serial)
	Serials[2] = append(Serials[2], copy)
	Serials[3] = append(Serials[3], seq)
	if w and sw then --Delete allowed and useful
	    syslog("deltree /y A:\\*")
	    --Get again folder information because it has changed
	    sp_ser = freespace()
	    Goal = sp_ser[1]
	end if
	logmsg(sprintf("Free space in this floppy: %d bytes", Goal))
	if Goal then --Is there any space in the floppy?
	    --Lets query floppy block size
	    bsize = Goal - reducedsize()
	    if bsize > 0 then --Just in case file could not be written
		Bsize = bsize
	    end if
	    Capacity = Capacity * (1 - Alpha) + Goal * Alpha --Smooth Capacity
	    Data = adjust(Data)
	    goal = Goal --Save Goal
	    indexes = knapsack()
	    Goal = goal --Restore Goal
	    acum = 0
	    q = 0
	    for i = 1 to length(indexes) do
		c = indexes[i]
		st = sysex("xcopy p\\" & files[c] & " A:")
		if st = 0 then --If not, save file for next floppy
		    acum += Data[c] --Bytes used
		    q += 1 --Files written
		    sizes[inddata[c]][3] = 0 --Flag written
		end if
	    end for
	    if Nolabel = 0 then
		label = sprintf(Id & "%d %d", {copy, seq})
		syslog("label A:" & label) --Write floppy label
	    end if
	    seq += 1
	    logmsg(sprintf("Files written to this floppy: %d", q))
	    logmsg(sprintf("Space left in this floppy: %d bytes", Goal - acum))
	    dummy = writeto("a\\sizes", sizes, 205, 1)
	    dummy = writeto("a\\numbers", {copy, seq, Capacity, Id, Serials, Bsize}, 206, 1)
	end if
    end while
end procedure

procedure main()
    sequence s, in
    integer copy, seq, c
    credits()
    command()
    if Skip = 0 then
	s = procdir()
	s = split(s)
	copy = 1
	seq = 1
	Serials = {{},{},{}}
	c = writeto("a\\sizes", s, 207, 1)
	c = writeto("a\\numbers", {copy, seq, 0, Id, Serials, Bsize}, 208, 1)
    else
	enablelog()
    end if
    while 1 do
	credits()
	s = readfrom("a\\sizes", 101)
	in = readfrom("a\\numbers", 102)
	copy = in[1]
	seq = in[2]
	Capacity = in[3]
	Id = in[4]
	Serials = in[5]
	Bsize = in[6]
	logmsg("If you exit the program, you may restart it at the exit point")
	logmsg("by running it later with the SKIP parameter")
	if seq = 1 then
	    beep(660)
	    logmsg(sprintf("Do you want to make copy number %d?", copy))
	    c = flushinput("yYnN")
	else
	    beep(2200)
	    logmsg(sprintf("Do you want to make copy number %d starting at floppy #%d (answer 'y'),", {copy, seq}))
	    logmsg("or start a new copy (answer 'c'),")
	    logmsg("or exit program (answer 'n')?")
	    c = flushinput("yYnNcC")
	end if
	logmsg(c & "")
	if c = 'n' or c = 'N' then
	    exit
	end if
	if c = 'y' or c = 'Y' then
	    fill(s, copy, seq)
	end if
	seq = 1
	copy += 1
	c = writeto("a\\numbers", {copy, seq, Capacity, Id, Serials, Bsize}, 209, 1)
	for i = 1 to length(s) do --Reset for use in next copy
	    s[i][3] = 1
	end for
	c = writeto("a\\sizes", s, 210, 1)
    end while
    if Flog >= 3 then
	close(Flog)
    end if
end procedure

main()