[Euphoria] Structured Access

Late last century, in a developing part of the world, I tried writing a diskette cataloguer. It worked okay, once I'd figured out how to do all the gymnastics necessary for BIOS calls. In the process I wrote a function to access memory in a structured way. Brilliant as Euphoria sequences are, they are just that: sequences. There's little in the way of structure, unless you apply some of your own.

I've reproduced the function in its entirety below. Essentially, the code takes data from memory in a structure way, that is, in terms of BYTE, BYTES, WORD, DWORD or ASCIIZ.

An attempt was made to make the functions applicable to files. Those routines don't work, and I haven't taken the time to find out why. Good as Euphoria is, there's no Mac OS X version (so I can't use it at home) and there's no opportunity to use it at work -- Euphoria's not in the SOE. If you're interested in looking at the code, write.

global function getmem( atom addr, integer offset, sequence typ )
        sequence conv
        object result
        integer i
        if equal( typ, "BYTE" ) then
                result = peek( addr + offset )
        elsif equal( typ, "WORD" ) then
                conv = peek( { addr + offset, 2 } ) & { 0, 0 }
                result = bytes_to_int( conv )
        elsif equal( typ, "DWORD" ) then
                conv = peek( { addr + offset, 4 } )
                result = bytes_to_int( conv )
        elsif equal( typ, "ASCIIZ" ) then
                i = 0
                result = {}
                while 1 = 1 do
                        conv = peek( addr + offset + i )
                        if conv = #00 then
                                exit
                        end if
                        result &= conv
                        i = i + 1
                end while
        elsif equal( typ[ 1 .. 5], "BYTES" ) then
                i = typ[ 6 ]
                result = peek( { addr + offset, i } )
        end if
        return result

end function

As an example of how to use getmen, below is the code for GetDriveParameterTable

global constant GDPT_DRIVE = 1,
                GDPT_UNIT = 2,
                GDPT_BYTES_PER_SECTOR = 3,
                GDPT_SECTORS_PER_CLUSTER_MINUS_1 = 4,
                GDPT_SECTORS_PER_CLUSTER_MULITPLIER = 5 ,
                GDPT_BOOT_SECTORS = 6,
                GDPT_FAT_COPIES = 7,
                GDPT_ROOT_DIRECTORY_ENTRIES = 8,
                GDPT_FIRST_DATA_SECTOR = 9,
                GDPT_TOTAL_CLUSTERS_PLUS_1 = 10,
                GDPT_NUMBER_SECTORS_PER_FAT = 11,
                GDPT_FIRST_ROOT_SECTOR = 12,
                GDPT_PTR_DEVICE_DRIVER_HEADER = 13,
                GDPT_MEDIA_DESCRIPTOR_BYTE = 14,
                GDPT_DISK_ACCESSED_BYTE = 15,
                GDPT_PTR_NEXT_DRIVE_PARAMETER_TABLE = 16,
                GDPT_FIRST_FREE_CLUSTER = 17,
                GDPT_NUMBER_FREE_CLUSTERS = 18

global function GetDriveParameterTable( integer logicalDrive )
        sequence r
        atom DPT
        integer drive
        integer unit
        integer bytesPerSector
        integer sectorsPerClusterMinus1
        integer sectorsPerClusterMulitplier
        integer bootSectors
        integer FATcopies
        integer rootDirectoryEntries
        integer firstDataSector
        integer totalClustersPlus1
        integer numberSectorsPerFAT
        integer firstRootSector
        atom ptrDeviceDriverHeader
        integer mediaDescriptorByte
        integer diskAccessedByte
        atom ptrNextDriveParameterTable
        integer numberFreeClusters
        integer firstFreeCluster
        
        r = repeat( 0, 10 )
        r[ REG_AX ] = #3200 --#1F00
        r[ REG_DX ] = logicalDrive
        r = dos_interrupt( #21, r )
        if lobyte( r[ REG_AX ] ) != 255 then
                DPT = r[ REG_DS ] * 16 + r[ REG_BX ]
                
                drive = getmem( DPT, #00, "BYTE" ) 
                unit  = getmem( DPT, #01, "BYTE" ) 
                bytesPerSector = getmem( DPT, #02, "WORD" )
                sectorsPerClusterMinus1 = getmem( DPT, #04, "BYTE" )
                sectorsPerClusterMulitplier = getmem( DPT, #05, "BYTE" )
                bootSectors = getmem( DPT, #06, "WORD" )
                FATcopies = getmem( DPT, #08, "BYTE" )
                rootDirectoryEntries = getmem( DPT, #09, "WORD" )
                firstDataSector = getmem( DPT, #0B, "WORD" )
                totalClustersPlus1 = getmem( DPT, #0D, "WORD" )
                numberSectorsPerFAT = getmem( DPT, #0F, "WORD" )
                firstRootSector = getmem( DPT, #11, "WORD" )
                ptrDeviceDriverHeader = getmem( DPT, #13, "DWORD" )
                mediaDescriptorByte = getmem( DPT, #17, "BYTE" )
                diskAccessedByte = getmem( DPT, #18, "BYTE" )
                ptrNextDriveParameterTable = getmem( DPT, #19, "DWORD" )
                firstFreeCluster = getmem( DPT, #1D, "WORD" )
                numberFreeClusters = getmem( DPT, #1F, "WORD" )
                return { drive, 
                        unit, 
                        bytesPerSector, 
                        sectorsPerClusterMinus1, 
                        sectorsPerClusterMulitplier, 
                        bootSectors, 
                        FATcopies, 
                        rootDirectoryEntries, 
                        firstDataSector, 
                        totalClustersPlus1, 
                        numberSectorsPerFAT, 
                        firstRootSector, 
                        ptrDeviceDriverHeader, 
                        mediaDescriptorByte, 
                        diskAccessedByte, 
                        ptrNextDriveParameterTable, 
                        firstFreeCluster, 
                        numberFreeClusters } 
        else
                return -1
        end if
end function

As an example of the BYTES parameter:

global function GetDiskLabels( integer drive )
        sequence r
        atom addr
        object result


        addr = allocate_low( 25 )
        r = repeat( 0, 10 )

        r[ REG_AX ] = #6900
        r[ REG_BX ] = drive
        r[ REG_DS ] = floor( addr / 16 )
        r[ REG_DX ] = remainder( addr, 16 )

        r = dos_interrupt( #21, r )

        if not Carry( r ) then
                result = { getmem( addr, #00, "WORD" ),
                           getmem( addr, #02, "DWORD" ),
                           getmem( addr, #06, "BYTES" & 11 ),
                           getmem( addr, #11, "BYTES" & 8 )
                         }
        else
                result = -1

        end if

        free_low( addr )

        return result

end function

The ASCIIZ parameter is like the BYTES except it keeps working its way through memory until it encounters a binary zero and then returns everything up to that point.

From memory I remember writing a version of getmem() which received a sequence of BYTE, WORD, etc. specifications and returned the resulting sequence of results. When I find it I'll post it.

Enjoy.