OpenEuphoria

2. Re: dir()

• Posted by jimcbrown (admin) Nov 16, 2009
• 1478 views

Hmm, I do not have an answer to the question you have posed.

However, I think the reason the memory to dir() is not being cleared immediately is because the Windows binaries (eui.exe, euiw.exe, etc) are by default compiled using MANAGED_MEM. (This is the default for two reasons: a) it allows the binaries to run under Windows 9x, b) the caching speeds up programs even when running on Windows XP)

Binaries using ESIMPLE_MALLOC (aka System Memory) should not exhibit this problem. (You can tell the difference by running euiw.exe with no parameters and checking to see if it outputs "Using Managed Memory" or "Using System Memory".)

I don't know where to get one from, as afaik there are no System-Memory eubins. Someone with Windows would probably have to compile from source.

4. Re: dir()

• Posted by jimcbrown (admin) Nov 17, 2009
• 1452 views

Well, the memory is kept in cache and reused, so if the sequence variable is cleared (with var = {}) and then reused on another dir(), we still only use 300MB instead of 600MB.

I'm not sure I like adding a Windows-specific keyword for this situation (it only happens on Windows afaik).

System memory does return the memory to the system immediately after use.

6. Re: dir()

• Posted by jimcbrown (admin) Nov 17, 2009
• 1442 views

But this won't help as dir_size() calls dir() (via default_dir() through walk_dir()).

8. Re: dir()

• Posted by ghaberek (admin) Nov 18, 2009
• 1397 views

I feel like I'm tooting my own horn here...

My win_dir routine will not consume lots of memory when "walking" a directory. It calls your routine each time it encounters a single file, it does not collect all the files up at once then call your routine for each one. Maximum memory usage is in the range of about 1-4 KB, give-or-take some given the length of the current path.

-Greg

10. Re: dir()

• Posted by DerekParnell (admin) Nov 18, 2009
• 1340 views

thisdir = win_dir(path,ndxptr) 

I'll start working on the Eu library to implement these ideas. Thanks for the suggestions.

12. Re: dir()

• Posted by gbonvehi Nov 19, 2009
• 1330 views

Hi, this is an function I made some time ago to remove a directory with all the content inside including subdirectories, you may be able to adjust it for your needs (this wraps Ansi apis)

include machine.e 
include dll.e 
 
without warning 
 
constant 
    wKernel32           = open_dll("kernel32.dll"), 
    wDeleteFile         = define_c_func(wKernel32, "DeleteFileA", {C_POINTER}, C_LONG), 
    wFindFirstFile      = define_c_func(wKernel32, "FindFirstFileA", {C_POINTER, C_POINTER}, C_POINTER), 
    wFindNextFile       = define_c_func(wKernel32, "FindNextFileA", {C_POINTER, C_POINTER}, C_LONG), 
    wFindClose          = define_c_func(wKernel32, "FindClose", {C_POINTER}, C_LONG), 
    wRemoveDirectory    = define_c_func(wKernel32, "RemoveDirectoryA", {C_POINTER}, C_LONG), 
 
    sizeOfDWORD = 4, 
    sizeOfFILETIME = sizeOfDWORD * 2, 
    wMAX_PATH   = 260, 
     
    sizeOfWIN32_FIND_DATA = sizeOfDWORD * 7 + sizeOfFILETIME * 3 + wMAX_PATH + 14, 
    WIN32_FIND_DATA_dwFileAttributes = 0, 
    WIN32_FIND_DATA_cFileName =  sizeOfFILETIME * 3 + sizeOfDWORD * 5, 
 
    wFILE_ATTRIBUTE_DIRECTORY   = 16, 
    wINVALID_HANDLE_VALUE       = -1 
 
atom rid_removeDirectoryCheckFile 
 
function peek_string(atom addr, atom maxbytes)  -- Read a 0 (null) delimited string from memory 
    sequence text 
    atom chr 
    maxbytes += addr 
    text = {} 
    if addr > 0 then 
        chr = peek(addr) 
        while chr != 0 and addr < maxbytes do 
            text &= chr 
            addr += 1 
            chr = peek(addr) 
        end while 
    end if 
    return text 
end function 
 
function poke_string(atom addr, atom maxbytes, sequence string) -- Poke a null terminated string @ address 
    atom len 
    len = length(string) 
    if addr != 0 and len < maxbytes then 
        poke(addr, string) 
        poke(addr+len,0) 
        return 1 
    end if 
    return 0 
end function 
 
-- It will stop processing on error returning 0 
-- name must be a path 
global function removeDirectory(sequence name) 
 
    atom fHandle, pwin32finddata, retval, pname, pfile 
    retval = 0 
     
    pname = allocate(wMAX_PATH) 
    -- Allocate a WIN32_FIND_DATA structure that's used by FindFile 
    pwin32finddata = allocate(sizeOfWIN32_FIND_DATA) 
     
    if pwin32finddata != 0 and pname != 0 then 
        mem_set(pwin32finddata,0,sizeOfWIN32_FIND_DATA) 
        if length(name) then 
            if name[$] != '\\' then 
                name &= "\\" 
            end if 
            pfile = allocate_string(name & "*") 
            fHandle = c_func(wFindFirstFile,{pfile, pwin32finddata})    -- There's always at least one directory "." 
            free(pfile) 
            if fHandle != wINVALID_HANDLE_VALUE then 
                if call_func(rid_removeDirectoryCheckFile, {name, pwin32finddata, pname}) then 
                    while c_func(wFindNextFile,{fHandle, pwin32finddata}) do -- While there's content inside the directory 
                        retval = call_func(rid_removeDirectoryCheckFile, {name, pwin32finddata, pname}) 
                        if not retval then 
                            exit 
                        end if 
                    end while 
                    if not c_func(wFindClose, {fHandle}) then   -- Close Find handle 
                        puts(1,"Error when calling findClose in removeDirectory()\n") 
                    end if 
                end if 
                if poke_string(pname, wMAX_PATH, name) then 
                    retval = c_func(wRemoveDirectory,{pname}) 
                else 
                    puts(1,"poke_string failed in removeDirectory(). Data: " & name & "\n") 
                end if 
            end if 
        end if 
        free(pwin32finddata) 
        free(pname) 
    end if 
    return retval 
end function 
 
-- Used by removeDirectory. This is the routine that checks and performs deletion of files inside 
-- a directory. 
function removeDirectoryCheckFile(sequence oriname, atom pwin32finddata, atom pname) 
    sequence filename 
    atom retval 
    retval = 1 
    filename = peek_string(pwin32finddata+WIN32_FIND_DATA_cFileName, wMAX_PATH) 
    if not equal(filename,".") and not equal(filename,"..") then -- Skip special directories 
        -- If it's a directory, call removeDirectory recursively 
        if and_bits( 
                peek4u(pwin32finddata+WIN32_FIND_DATA_dwFileAttributes), 
                wFILE_ATTRIBUTE_DIRECTORY 
                ) != 0 then 
            retval = removeDirectory(oriname & filename) 
 
        -- Else, if it's an archive, then delete it 
        else 
            if poke_string(pname, wMAX_PATH, oriname & filename) then 
                retval = c_func(wDeleteFile,{pname}) 
            else 
                puts(1,"poke_string failed in removeDirectoryCheckFile(). Data: " & oriname & filename & "\n") 
            end if 
        end if 
    end if 
    return retval 
end function 
 
rid_removeDirectoryCheckFile = routine_id("removeDirectoryCheckFile") 
 
if wKernel32 = 0 then 
    puts(1,"Error in open_dll(\"kernel32.dll\")\n") 
    abort(1) 
end if 

Regards,

14. Re: dir()

• Posted by useless Nov 19, 2009
• 1370 views

So i increment from 1 to 234,346, ok. Or i tell dir() to increment till it finds it, or i tell dir a range of indexes, or i give dir some wildcard. I would be using the existing tools made available in the last 10 years, i do not see the problem?

useless

16. Re: dir()

• Posted by jimcbrown (admin) Nov 20, 2009
• 1187 views

I agree, such a function does not seem to exist.

Fortunately, kat only wanted a function that returned each file one at a time (and not any particular file or any particular order), which was an easier condition to fulfill.