OpenEuphoria

1. init.e - standard library candidate

• Posted by mattlewis (admin) Mar 09, 2013
• 1741 views

I came up with a small file that makes it easier to make code (especially GUI code) more modular. Think of a Win32Lib or wxEuphoria application, where you would create all of your widgets and assign them to constants. This gets really unwieldy for large apps. And when you start splitting code into multiple files, you have to be careful that they're included in the right order so that things get initialized properly.

So I came up with init.e, and I've found myself using it in lots of projects, and it seems like the sort of thing others might find useful:

namespace init 
 
include std/map.e 
 
map init_routines = map:new() 
 
export procedure register( sequence name, integer rid = routine_id("init") ) 
	map:put( init_routines, name, rid ) 
end procedure 
 
export procedure ensure( sequence name ) 
	integer rid = map:get( init_routines, name, -1 ) 
	if rid != -1 then 
		map:remove( init_routines, name  ) 
		call_proc( rid, {} ) 
	end if 
end procedure 
 
export procedure all() 
	sequence r = map:pairs( init_routines ) 
	for i = 1 to length(r) do 
		if map:has( init_routines, r[i][1] ) then 
			map:remove( init_routines, r[i][1] ) 
			call_proc( r[i][2], {} ) 
		end if 
	end for 
	map:clear( init_routines ) 
end procedure 
 

The idea is that you call init:register( "some name" ) (it defaults to a procedure named init(), but you can put whatever you want). And then inside of you init's, you can call init:ensure( "some dependency" )), which will cause that init routine to be called if it hasn't already.

And you just call init:all() at the bottom of your main program, or just before you call WinMain() or whatever.

Matt

3. Re: init.e - standard library candidate

• Posted by mattlewis (admin) Mar 09, 2013
• 1730 views

Sure. I'm currently refactoring my wxIDE (I also have done this with the Win32Lib IDE). Here are some exerpts:

-- wxide.exw 
 
include init.e 
include main.e 
include menu.e 
include settings.e 
 
namespace main 
 
include wxeu/wxeud.e 
 
... 
 
 
init:all()     -- calls all of the initialization routines 
wxMain( main ) -- show the main window and start interacting with the user 
 
-- main.e 
include wxeu/wxeud.e 
 
include init.e 
 
init:register( "main" ) 
 
export atom 
	main, 
	status, 
	win, 
        notebook 
 
procedure init() 
	init:ensure( "settings" ) 
	 
	main = create( wxFrame, {0, -1, "wxIDE", win_pos[1], win_pos[2], win_size[1], win_size[2], 
		wx_or_all( {wxDEFAULT_FRAME_STYLE, wxNO_FULL_REPAINT_ON_RESIZE}) }) 
	status = create( wxStatusBar, {main}) 
	win = create( wxPanel, {main, -1, -1, -1, -1, -1, wxCLIP_CHILDREN}) 
	notebook        = create( wxNotebook, {win, -1, -1, -1, -1, -1, wxCLIP_CHILDREN}) 
 
        ... 
end procedure 
 
-- menu.e 
include wxeu/wxeud.e as wx 
 
include init.e 
include main.e 
init:register( "menu" ) 
 
export atom 
	menu_bar, 
	file_menu, 
	file_open, 
	file_exit, 
        ... 
 
procedure init() 
	init:ensure( "main" ) 
	init:ensure( "settings" ) 
	menu_bar = create( wxMenuBar, {main}) 
	file_menu         = create( wxMenu, {menu_bar, "&File"}) 
	file_new          = create( wxMenuItem, {file_menu, wxID_NEW, "&New"}) 
	file_open         = create( wxMenuItem, {file_menu, wxID_OPEN,"&Open\tCtrl-O"}) 
	file_reopen       = create( wxMenuItem, {file_menu, wxID_REOPEN, "&Reopen File"}) 
	file_close        = create( wxMenuItem, {file_menu, close_id, "&Close\tCtrl-W"}) 
	file_save         = create( wxMenuItem, {file_menu, wxID_SAVE, "&Save"}) 
	file_save_as      = create( wxMenuItem, {file_menu, wxID_SAVEAS, "Save &As"}) 
	file_save_project = create( wxMenuItem, {file_menu, new_id(), "Save &Project"}) 
	append_separator( file_menu ) 
	file_exit = create( wxMenuItem, {file_menu, wxID_EXIT, "E&xit"}) 
 
end procedure 

The idea is to make it easy to take initialization out of the top level of execution, and especially to make it easy to keep dependencies straight. In this case, you can't create the menu until you've created the main window, etc.

Matt

5. Re: init.e - standard library candidate

• Posted by ghaberek (admin) Mar 11, 2013
• 1596 views

export procedure register( sequence name, integer rid = routine_id("init") ) 
	map:put( init_routines, name, rid ) 
end procedure 

You've inadvertently solved a quandary that has been plaguing me for years: How do I pass only the name of a routine to an event handler, instead of embedding routine_id() in the function call? I had no idea that initializer values were called inline, which is what seems to make this magic work.

Quite simply...

public procedure SetHandler( atom this, atom id, atom event, sequence handler, integer rid = routine_id(handler) ) 
 
    if length(handler) > 0 and rid = -1 then 
        crash( "Routine %d not found!\n", {handler} ) 
    end if 
 
    -- store handler... 
 
end procedure 
 
-- later... 
 
SetHandler( frame, wxID_ANY, wxEVT_COMMAND_MENU_SELECTED, "MyFrame:OnClick" ) 

Am I wrong, or should this work as I expect?

-Greg

7. Re: init.e - standard library candidate

• Posted by petelomax Mar 16, 2013
• 1506 views

-- foo.ex 
include foo.e 
procedure bar() 
 
end procedure 
foo( "bar" ) 
 
-- foo.e 
 
export procedure foo( sequence name, integer rid = routine_id( name ) ) 
	? rid 
end procedure 

$ eui foo.ex 
0 

I suspect this is simply broken. What should the following do?

somefile.e

constant A="1" 
 
global procedure putsomething(sequence s=A) 
    puts(1,s) 
end procedure 

someotherfile.exw

include somefile.e 
constant A="2" 
putsomething() 
if getc(0) then end if 

I'm quite happy that it prints 1, but that is not what was said, and routine_id is breaking scope by working...

Pete

9. Re: init.e - standard library candidate

• Posted by petelomax Mar 16, 2013
• 1448 views

Thanks for the excellent and detailed reply.
I have figured it out now; the default expression is effectively parsed in the called context (that part I really misread), but evaluated in the callee context, which as you point out makes no difference except for routine_id().

FWIW, I plan (not particularly soon) in Phix to change routine_id to:

global function routine_id(string name, boolean use_callee_context=false) 
... 
procedure x(integer rid=routine_id("something",true)) 

which would allow what I see as the required extra flexibility. The extra parameter would not be valid in top-level code.

Regards, Pete

11. Re: init.e - standard library candidate

• Posted by jimcbrown (admin) Mar 17, 2013
• 1375 views

I seem to recall that was actually a ticket for that.

I said this already - in the part of my post that you quoted. You worded it better, though.