[Euphoria] Structured Access, part 2

I knew I had it somewhere. Okay, these implement the following: BYTE, BYTES, WORD, DWORD, QWORD, ASCIIZ and PSTRING. You can pull the data one chunk at a time as per the last posting or else pull a whole set all at once.

The file versions don't work and I'm not sure why, and as I said before, I don't have the time to do anything about it.

By the way, this was written before Euphoria 2.5. In fact, possibly before 2.4 so the code may need some tweaking.

mread is like the getmem of the previous posting. memread takes a sequences of reads. I will eventually post an example (if I can find one).

(Since writing part 1, I've been in touch with CChris from Euphoria Standard Library who has taken over the development of getmem. It's great to be able to give something back to the Euphoria community after all these years (I've been using it since version 1.5).)

-- tools for structures, based on earlier work in misctool.e
--
-- memload procedure. Initialises memBlock to contents of passed
--      sequence.
-- memread function. Reads memBlock according to parameters and
--      returns as sequence
-- memfree procedure. Frees allocated memory.

-- fmemload procedure. Like memload but sets up for direct file
--      access.
-- fmemread function. Reads file according to parameters.
-- fmemfree procedure. Close file.

include machine.e
include file.e
include get.e

atom memBlock
integer memAllocated

integer fileNumber
integer fileAllocated
integer fileLength

memAllocated = 0
fileAllocated = 1

function mread( integer offset, sequence typ )
        sequence conv
        object result
        integer i
        if equal( typ, "BYTE" ) then
                result = peek( memBlock + offset )

        elsif equal( typ, "WORD" ) then
                conv = peek( { memBlock + offset, 2 } ) & { 0, 0 }
                result = bytes_to_int( conv )

        elsif equal( typ, "DWORD" ) then
                conv = peek( { memBlock + offset, 4 } )
                result = bytes_to_int( conv )

        elsif equal( typ, "QWORD" ) then
                result = peek( { memBlock + offset, 8 } )

        elsif equal( typ, "ASCIIZ" ) then
                i = 0
                result = {}
                while 1 = 1 do
                        conv = peek( memBlock + 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( { memBlock + offset, i } )

        elsif equal( typ, "PSTRING" ) then
                i = peek( { memBlock + offset, 1 } )
                result = peek( { memBlock + offset + 1, i } )
        end if
        return result
end function

function fpeek( object access )
        integer seke
        object result
        result = -1
        if atom( access ) then -- byte at offset
                if access <= fileLength then
                        seke = seek( fileNumber, access )
                        if seke = 0 then
                                result = getc( fileNumber )
                        end if
                end if
        else -- sequence of offset and length
                if ( access[ 1 ] + access[ 2 ] ) <= fileLength then
                        seke = seek( fileNumber, access[ 1 ] )
                        if seke = 0 then
                                result = get_bytes( fileNumber, access[ 2 ] )
                        end if
                end if
        end if
        return result
end function

function fmread( integer offset, sequence typ )
        sequence conv
        object result
        integer i
        if equal( typ, "BYTE" ) then
                result = fpeek(  offset )

        elsif equal( typ, "WORD" ) then
                conv = fpeek( {  offset, 2 } ) & { 0, 0 }
                result = bytes_to_int( conv )

        elsif equal( typ, "DWORD" ) then
                conv = fpeek( {  offset, 4 } )
                result = bytes_to_int( conv )

        elsif equal( typ, "QWORD" ) then
                result = fpeek( {  offset, 8 } )

        elsif equal( typ, "ASCIIZ" ) then
                i = 0
                result = {}
                while 1 = 1 do
                        conv = fpeek(  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 = fpeek( {  offset, i } )

        elsif equal( typ, "PSTRING" ) then
                i = fpeek( {  offset, 1 } )
                result = fpeek( {  offset + 1, i } )
        end if
        return result
end function

global procedure memload( sequence data )
        memBlock = allocate( length( data ) + 1 )
        poke( memBlock, data )
        memAllocated = 1
end procedure

global procedure memfree()
        if memAllocated = 1 then
                free( memBlock )
        end if
end procedure

global function memread( sequence offsetTypes )
        object result
        result = -1
        if memAllocated = 1 then
                result = repeat( {}, length( offsetTypes ) )
                for i = 1 to length( offsetTypes ) do
                        result[ i ] = mread( offsetTypes[ i ][ 1 ], offsetTypes[ i ][ 2 ] )
                end for
        end if
        return result
end function

global procedure fmemload( sequence file )
        integer res
        fileNumber = open( file, "rb" )
        if fileNumber != -1 then
                fileAllocated = 1
                res = seek( fileNumber, -1 )
                if res = 0 then
                        fileLength = where( fileNumber )
                else
                        fileLength = 0
                end if
        end if
end procedure

global procedure fmemfree()
        if fileAllocated = 1 then
                close( fileNumber )
        end if
end procedure

global function fmemread( sequence offsetTypes )
        object result
        result = -1
        if fileAllocated = 1 then
                result = repeat( {}, length( offsetTypes ) )
                for i = 1 to length( offsetTypes ) do
                        result[ i ] = fmread( offsetTypes[ i ][ 1 ], offsetTypes[ i ][ 2 ] )
                end for
        end if
        return result
end function