1.1 --- a/demo/simple_debug.e	Mon Dec 19 23:19:58 2011 -0300
     1.2 +++ b/demo/simple_debug.e	Wed Dec 21 16:45:49 2011 -0300
     1.3 @@ -100,6 +100,7 @@
     1.4  			printf( 1, " %s", { get_name( params[j] ) } )
     1.5  		end for
     1.6  		puts( 1, " )")
     1.7 +		
     1.8  	end if
     1.9  	puts( 1, "\n" )
    1.10  end procedure

     2.1 --- a/demo/win32/window.exw	Mon Dec 19 23:19:58 2011 -0300
     2.2 +++ b/demo/win32/window.exw	Wed Dec 21 16:45:49 2011 -0300
     2.3 @@ -8,254 +8,444 @@
     2.4  include std/os.e
     2.5  include std/machine.e
     2.6  include std/dll.e
     2.7 +include std/math.e
     2.8 +include std/error.e
     2.9 +include std/console.e
    2.10  
    2.11 -constant cbSize = 0,
    2.12 -	 style  = 4,
    2.13 -	 lpfnWndProc = 8,
    2.14 -	 cbClsExtra = 12,
    2.15 -	 cbWndExtra = 16,
    2.16 -	 hInstance  = 20,
    2.17 -	 hIcon      = 24,
    2.18 -	 hCursor    = 28,
    2.19 -	 hbrBackground = 32,
    2.20 -	 lpszMenuName  = 36,
    2.21 -	 lpszClassName = 40,
    2.22 -	 hIconSm = 44,
    2.23 -	 SIZE_OF_WNDCLASS = 48
    2.24 +include std/memstruct/windows.e
    2.25  
    2.26 -constant SIZE_OF_MESSAGE = 40
    2.27 +--****
    2.28 +-- === Windows Data Type constants for function/procedure calls
    2.29 +
    2.30 +public constant
    2.31 +	C_BYTE = C_UCHAR,
    2.32 +	C_BOOL = C_INT,
    2.33 +	C_ATOM = C_USHORT,
    2.34 +	C_WORD = C_USHORT,
    2.35 +	C_DWORD=  C_ULONG,
    2.36 +	C_WPARAM = C_POINTER,
    2.37 +	C_LPARAM = C_POINTER,
    2.38 +	C_HANDLE = C_POINTER,
    2.39 +	C_HWND = C_POINTER,
    2.40 +	C_LPSTR = C_POINTER,
    2.41 +	C_COLORREF =  C_DWORD,    --0x00bbggrr
    2.42 +	C_LANGID =  C_WORD,
    2.43 +	$
    2.44 +
    2.45 +public constant C_LONG_PTR = C_POINTER
    2.46 +
    2.47 +public constant C_LRESULT = C_LONG_PTR
    2.48 +
    2.49 +
    2.50 +
    2.51  
    2.52  constant CS_HREDRAW = 2,
    2.53 -	 CS_VREDRAW = 1
    2.54 +	CS_VREDRAW = 1
    2.55  
    2.56  constant SW_SHOWNORMAL = 1
    2.57  
    2.58  constant WM_CREATE = #01,
    2.59 -	 WM_PAINT  = #0F,
    2.60 -	 WM_DESTROY= #02
    2.61 +	WM_PAINT  = #0F,
    2.62 +	WM_DESTROY= #02
    2.63  
    2.64  constant SND_FILENAME = #00020000,
    2.65 -	 SND_ASYNC    = #00000001
    2.66 -	 
    2.67 +	SND_ASYNC    = #00000001
    2.68 +	
    2.69  constant DT_SINGLELINE = #0020,
    2.70 -	 DT_CENTER     = #0001,
    2.71 -	 DT_VCENTER    = #0004
    2.72 -	 
    2.73 -function or_all(sequence s)
    2.74 --- or together all elements of a sequence
    2.75 -    atom result
    2.76 -    
    2.77 -    result = 0
    2.78 -    for i = 1 to length(s) do
    2.79 -	result = or_bits(result, s[i])
    2.80 -    end for
    2.81 -    return result
    2.82 -end function
    2.83 +	DT_CENTER     = #0001,
    2.84 +	DT_VCENTER    = #0004
    2.85 +	
    2.86 +
    2.87  
    2.88  constant WS_OVERLAPPED  = #00000000,
    2.89 -	 WS_CAPTION     = #00C00000,
    2.90 -	 WS_SYSMENU     = #00080000,
    2.91 -	 WS_THICKFRAME  = #00040000,
    2.92 -	 WS_MINIMIZEBOX = #00020000,
    2.93 -	 WS_MAXIMIZEBOX = #00010000 
    2.94 +	WS_CAPTION     = #00C00000,
    2.95 +	WS_SYSMENU     = #00080000,
    2.96 +	WS_THICKFRAME  = #00040000,
    2.97 +	WS_MINIMIZEBOX = #00020000,
    2.98 +	WS_MAXIMIZEBOX = #00010000
    2.99  
   2.100 -constant IDC_ARROW = 32512,
   2.101 -	 WHITE_BRUSH = 0,
   2.102 -	 CW_USEDEFAULT = #80000000,
   2.103 -	 WS_OVERLAPPEDWINDOW = or_all({WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU,
   2.104 -				       WS_THICKFRAME, WS_MINIMIZEBOX, 
   2.105 -				       WS_MAXIMIZEBOX})
   2.106 +constant
   2.107 +	IDC_ARROW = 32512,
   2.108 +	IDI_APPLICATION = 3,
   2.109 +	CW_USEDEFAULT = #80000000,
   2.110 +	WS_OVERLAPPEDWINDOW = or_all({WS_OVERLAPPED, WS_CAPTION, WS_SYSMENU,
   2.111 +					WS_THICKFRAME, WS_MINIMIZEBOX,
   2.112 +				       WS_MAXIMIZEBOX}),
   2.113 +	WHITE_BRUSH = 0,
   2.114 +	LTGRAY_BRUSH = 1,
   2.115 +	GRAY_BRUSH = 2,
   2.116 +	DKGRAY_BRUSH = 3,
   2.117 +	BLACK_BRUSH = 4,
   2.118 +	NULL_BRUSH = 5,
   2.119 +-- 	HOLLOW_BRUSH = ?,
   2.120 +	WHITE_PEN = 6,
   2.121 +	BLACK_PEN = 7,
   2.122 +	NULL_PEN = 8,
   2.123 +	OEM_FIXED_FONT = 10,
   2.124 +	ANSI_FIXED_FONT = 11,
   2.125 +	ANSI_VAR_FONT = 12,
   2.126 +	SYSTEM_FONT = 13,
   2.127 +	DEVICE_DEFAULT_FONT = 14,
   2.128 +	DEFAULT_PALETTE = 15,
   2.129 +	SYSTEM_FIXED_FONT = 16,
   2.130  
   2.131 -	 
   2.132 +	STOCK_LAST = 16,
   2.133 +
   2.134 +	COLOR_SCROLLBAR = 0,
   2.135 +	COLOR_BACKGROUND = 1,
   2.136 +	COLOR_ACTIVECAPTION = 2,
   2.137 +	COLOR_INACTIVECAPTION = 3,
   2.138 +	COLOR_MENU = 4,
   2.139 +	COLOR_WINDOW = 5,
   2.140 +	COLOR_WINDOWFRAME = 6,
   2.141 +	COLOR_MENUTEXT = 7,
   2.142 +	COLOR_WINDOWTEXT = 8,
   2.143 +	COLOR_CAPTIONTEXT = 9,
   2.144 +	COLOR_ACTIVEBORDER = 10,
   2.145 +	COLOR_INACTIVEBORDER = 11,
   2.146 +	COLOR_APPWORKSPACE = 12,
   2.147 +	COLOR_HIGHLIGHT = 13,
   2.148 +	COLOR_HIGHLIGHTTEXT = 14,
   2.149 +	COLOR_BTNFACE = 15,
   2.150 +	COLOR_BTNSHADOW = 16,
   2.151 +	COLOR_GRAYTEXT = 17,
   2.152 +	COLOR_BTNTEXT = 18,
   2.153 +	COLOR_INACTIVECAPTIONTEXT = 19,
   2.154 +	COLOR_BTNHIGHLIGHT = 20,
   2.155 +
   2.156 +	LOGPIXELSX = 88,
   2.157 +	LOGPIXELSY = 90,
   2.158 +	OUT_DEFAULT_PRECIS = 0,
   2.159 +	OUT_STRING_PRECIS = 1,
   2.160 +	OUT_CHARACTER_PRECIS = 2,
   2.161 +	OUT_STROKE_PRECIS = 3,
   2.162 +	OUT_TT_PRECIS = 4,
   2.163 +	OUT_DEVICE_PRECIS = 5,
   2.164 +	OUT_RASTER_PRECIS = 6,
   2.165 +	OUT_TT_ONLY_PRECIS = 7,
   2.166 +	OUT_OUTLINE_PRECIS = 8,
   2.167 +	OUT_SCREEN_OUTLINE_PRECIS = 9,
   2.168 +	OUT_PS_ONLY_PRECIS = 10,
   2.169 +
   2.170 +	CLIP_DEFAULT_PRECIS = 0,
   2.171 +	CLIP_CHARACTER_PRECIS = 1,
   2.172 +	CLIP_STROKE_PRECIS = 2,
   2.173 +	CLIP_MASK = #F,
   2.174 +-- 	CLIP_LH_ANGLES = (1<<4),
   2.175 +
   2.176 +-- 	CLIP_TT_ALWAYS = (2<<4),
   2.177 +
   2.178 +-- 	CLIP_EMBEDDED = (8<<4),
   2.179 +
   2.180 +	DEFAULT_QUALITY = 0,
   2.181 +	DRAFT_QUALITY = 1,
   2.182 +	PROOF_QUALITY = 2,
   2.183 +
   2.184 +	DEFAULT_PITCH = 0,
   2.185 +	FIXED_PITCH = 1,
   2.186 +	VARIABLE_PITCH = 2,
   2.187 +
   2.188 +	ANSI_CHARSET = 0,
   2.189 +	DEFAULT_CHARSET = 1,
   2.190 +	SYMBOL_CHARSET = 2,
   2.191 +	SHIFTJIS_CHARSET = 128,
   2.192 +	HANGEUL_CHARSET = 129,
   2.193 +	HANGUL_CHARSET = 129,
   2.194 +	GB2312_CHARSET = 134,
   2.195 +	CHINESEBIG5_CHARSET = 136,
   2.196 +	OEM_CHARSET = 255,
   2.197 +
   2.198 +	FF_DONTCARE = shift_bits(0, -4),
   2.199 +
   2.200 +-- 	FF_ROMAN = (1<<4)  ,
   2.201 +
   2.202 +-- 	FF_SWISS = (2<<4)  ,
   2.203 +
   2.204 +-- 	FF_MODERN = (3<<4)  ,
   2.205 +
   2.206 +-- 	FF_SCRIPT = (4<<4)  ,
   2.207 +
   2.208 +-- 	FF_DECORATIVE = (5<<4)  ,
   2.209 +
   2.210 +	FW_DONTCARE = 0,
   2.211 +	FW_THIN = 100,
   2.212 +	FW_EXTRALIGHT = 200,
   2.213 +	FW_LIGHT = 300,
   2.214 +	FW_NORMAL = 400,
   2.215 +	FW_MEDIUM = 500,
   2.216 +	FW_SEMIBOLD = 600,
   2.217 +	FW_BOLD = 700,
   2.218 +	FW_EXTRABOLD = 800,
   2.219 +	FW_HEAVY = 900,
   2.220 +
   2.221 +-- 	FW_ULTRALIGHT = FW_EXTRALIGHT,
   2.222 +
   2.223 +-- 	FW_REGULAR = FW_NORMAL,
   2.224 +
   2.225 +-- 	FW_DEMIBOLD = FW_SEMIBOLD,
   2.226 +
   2.227 +-- 	FW_ULTRABOLD = FW_EXTRABOLD,
   2.228 +
   2.229 +-- 	FW_BLACK = FW_HEAVY,
   2.230 +	$
   2.231 +
   2.232  integer LoadIcon, LoadCursor, GetStockObject, RegisterClassEx,
   2.233  	CreateWindow, ShowWindow, UpdateWindow, GetMessage,
   2.234  	TranslateMessage, DispatchMessage, PlaySound, BeginPaint,
   2.235 -	GetClientRect, DrawText, EndPaint, PostQuitMessage, DefWindowProc
   2.236 +	GetClientRect, DrawText, EndPaint, PostQuitMessage, DefWindowProc,
   2.237 +    GetSysColor, SelectObject, SetTextColor, SetBkColor,
   2.238 +	xGetLastError, xSetLastError, xFormatMessage,
   2.239 +    GetDeviceCaps, CreateFont, MulDiv
   2.240  
   2.241  procedure not_found(sequence name)
   2.242 -    puts(1, "Couldn't find " & name & '\n')
   2.243 -    abort(1)
   2.244 +	crash( "Couldn't find " & name )
   2.245  end procedure
   2.246  
   2.247 +-- dynamically link a C routine as a Euphoria function
   2.248  function link_c_func(atom dll, sequence name, sequence args, atom result)
   2.249 --- dynamically link a C routine as a Euphoria function
   2.250 -    integer handle
   2.251 +	integer handle
   2.252  
   2.253 -    handle = define_c_func(dll, name, args, result)
   2.254 -    if handle = -1 then
   2.255 -	not_found(name)
   2.256 -    else
   2.257 -	return handle
   2.258 -    end if
   2.259 +	handle = define_c_func(dll, name, args, result)
   2.260 +	if handle = -1 then
   2.261 +		not_found(name)
   2.262 +	else
   2.263 +		return handle
   2.264 +	end if
   2.265  end function
   2.266  
   2.267 +-- dynamically link a C routine as a Euphoria function
   2.268  function link_c_proc(atom dll, sequence name, sequence args)
   2.269 --- dynamically link a C routine as a Euphoria function
   2.270 -    integer handle
   2.271 +	integer handle
   2.272  
   2.273 -    handle = define_c_proc(dll, name, args)
   2.274 -    if handle = -1 then
   2.275 -	not_found(name)
   2.276 -    else
   2.277 -	return handle
   2.278 -    end if
   2.279 +	handle = define_c_proc(dll, name, args)
   2.280 +	if handle = -1 then
   2.281 +		not_found(name)
   2.282 +	else
   2.283 +		return handle
   2.284 +	end if
   2.285  end function
   2.286  
   2.287 +-- get handles to all dll routines that we need
   2.288  procedure link_dll_routines()
   2.289 --- get handles to all dll routines that we need
   2.290 -    atom user32, gdi32, winmm
   2.291 -    
   2.292 -    user32 = open_dll("user32.dll")
   2.293 -    if user32 = NULL then
   2.294 -	not_found("user32.dll")
   2.295 -    end if
   2.296 -    gdi32 = open_dll("gdi32.dll")
   2.297 -    if gdi32 = NULL then
   2.298 -	not_found("gdi32.dll")
   2.299 -    end if
   2.300 -    winmm = open_dll("winmm.dll")
   2.301 -    if winmm = NULL then
   2.302 +	atom user32, gdi32, winmm, kernel32
   2.303 +	
   2.304 +	user32 = open_dll("user32.dll")
   2.305 +	if user32 = NULL then
   2.306 +		not_found("user32.dll")
   2.307 +	end if
   2.308 +	gdi32 = open_dll("gdi32.dll")
   2.309 +	if gdi32 = NULL then
   2.310 +		not_found("gdi32.dll")
   2.311 +	end if
   2.312 +	winmm = open_dll("winmm.dll")
   2.313 +	if winmm = NULL then
   2.314  	not_found("winmm.dll")
   2.315 -    end if
   2.316 -    
   2.317 -    LoadIcon = link_c_func(user32, "LoadIconA", {C_POINTER, C_INT}, C_INT)
   2.318 -    LoadCursor = link_c_func(user32, "LoadCursorA", {C_POINTER, C_INT}, C_INT)
   2.319 -    GetStockObject = link_c_func(gdi32, "GetStockObject", {C_INT}, C_INT)
   2.320 -    RegisterClassEx = link_c_func(user32, "RegisterClassExA", {C_POINTER}, C_INT)
   2.321 -    CreateWindow = link_c_func(user32, "CreateWindowExA", 
   2.322 -     {C_INT, C_INT,C_INT,C_INT,C_INT,C_INT,C_INT,C_INT,C_INT,C_INT,C_INT,C_INT},
   2.323 -      C_INT)
   2.324 -    ShowWindow = link_c_proc(user32, "ShowWindow", {C_INT, C_INT})
   2.325 -    UpdateWindow = link_c_proc(user32, "UpdateWindow", {C_INT})
   2.326 -    GetMessage = link_c_func(user32, "GetMessageA", 
   2.327 -			     {C_INT, C_INT, C_INT, C_INT}, C_INT)
   2.328 -    TranslateMessage = link_c_proc(user32, "TranslateMessage", {C_INT})
   2.329 -    DispatchMessage = link_c_proc(user32, "DispatchMessageA", {C_INT})
   2.330 -    PlaySound = link_c_proc(winmm, "PlaySound", {C_INT, C_INT, C_INT})
   2.331 -    BeginPaint = link_c_func(user32, "BeginPaint", {C_INT, C_POINTER}, C_INT)
   2.332 -    GetClientRect = link_c_proc(user32, "GetClientRect", {C_INT, C_POINTER})
   2.333 -    DrawText = link_c_proc(user32, "DrawTextA", 
   2.334 -			   {C_INT, C_INT, C_INT, C_INT, C_INT})
   2.335 -    EndPaint = link_c_proc(user32, "EndPaint", {C_INT, C_INT})
   2.336 -    PostQuitMessage = link_c_proc(user32, "PostQuitMessage", {C_INT})
   2.337 -    DefWindowProc = link_c_func(user32, "DefWindowProcA", 
   2.338 -				{C_INT, C_INT, C_INT, C_INT}, C_INT)
   2.339 +	end if
   2.340 +	
   2.341 +	kernel32 = open_dll( "kernel32.dll")
   2.342 +	if kernel32 = NULL then
   2.343 +		not_found("kernel32.dll")
   2.344 +	end if
   2.345 +
   2.346 +	--new code would use LoadImage
   2.347 +	LoadIcon = link_c_func(user32, "LoadIconA", {C_HANDLE, C_LPSTR}, C_HANDLE)
   2.348 +	LoadCursor = link_c_func(user32, "LoadCursorA", {C_HANDLE, C_LPSTR}, C_HANDLE)
   2.349 +
   2.350 +	GetStockObject = link_c_func(gdi32, "GetStockObject", {C_INT}, C_HANDLE)
   2.351 +	RegisterClassEx = link_c_func(user32, "RegisterClassExA", {C_POINTER}, C_ATOM)
   2.352 +	CreateWindow = link_c_func(user32, "CreateWindowExA",
   2.353 +		{C_DWORD, C_LPSTR, C_LPSTR,C_DWORD,C_INT,C_INT,C_INT,C_INT,
   2.354 +		C_HWND,C_HANDLE,C_HANDLE, C_POINTER},
   2.355 +	C_HWND)
   2.356 +	ShowWindow = link_c_proc(user32, "ShowWindow", {C_HWND, C_INT}) --BOOL
   2.357 +	UpdateWindow = link_c_proc(user32, "UpdateWindow", {C_HWND}) --BOOL
   2.358 +	GetMessage = link_c_func(user32, "GetMessageA",
   2.359 +				{C_LPSTR, C_HWND, C_UINT, C_UINT}, C_BOOL)
   2.360 +	TranslateMessage = link_c_proc(user32, "TranslateMessage", {C_LPSTR}) --BOOL
   2.361 +	DispatchMessage = link_c_proc(user32, "DispatchMessageA", {C_LPSTR}) --LRESULT
   2.362 +	PlaySound = link_c_proc(winmm, "PlaySound", {C_LPSTR, C_HANDLE, C_DWORD}) --BOOL
   2.363 +	BeginPaint = link_c_func(user32, "BeginPaint", {C_HWND, C_POINTER}, C_HANDLE)
   2.364 +	GetClientRect = link_c_proc(user32, "GetClientRect", {C_HWND, C_POINTER}) --BOOL
   2.365 +	DrawText = link_c_proc(user32, "DrawTextA",
   2.366 +			{C_HANDLE, C_LPSTR, C_INT, C_POINTER, C_UINT})  --INT
   2.367 +	EndPaint = link_c_proc(user32, "EndPaint", {C_HWND, C_POINTER}) --BOOL
   2.368 +	PostQuitMessage = link_c_proc(user32, "PostQuitMessage", {C_INT})
   2.369 +	DefWindowProc = link_c_func(user32, "DefWindowProcA",
   2.370 +				{C_HWND, C_UINT, C_WPARAM, C_LPARAM}, C_LRESULT)
   2.371 +
   2.372 +    GetSysColor = link_c_func(user32, "GetSysColor", {C_INT}, C_DWORD)
   2.373 +
   2.374 +    SelectObject = link_c_func(gdi32, "SelectObject", {C_HANDLE, C_HANDLE}, C_HANDLE)
   2.375 +    SetTextColor = link_c_func(gdi32, "SetTextColor", {C_HANDLE, C_COLORREF}, C_COLORREF)
   2.376 +    SetBkColor = link_c_func(gdi32, "SetBkColor", {C_HANDLE, C_COLORREF}, C_COLORREF)
   2.377 +
   2.378 +    GetDeviceCaps = link_c_func(gdi32, "GetDeviceCaps", {C_HANDLE, C_INT}, C_INT)
   2.379 +    CreateFont = link_c_func(gdi32, "CreateFontA", {
   2.380 +		C_INT, C_INT, C_INT, C_INT, C_INT, C_DWORD, C_DWORD, C_DWORD,
   2.381 +		C_DWORD, C_DWORD, C_DWORD, C_DWORD, C_DWORD, C_LPSTR
   2.382 +	},
   2.383 +	C_HANDLE)
   2.384 +	
   2.385 +	MulDiv = link_c_func( kernel32, "MulDiv", { C_INT, C_INT, C_INT }, C_INT )
   2.386 +
   2.387  end procedure
   2.388  
   2.389  link_dll_routines()
   2.390  
   2.391 -atom wav_file, Euphoria, ps, rect
   2.392 -wav_file = allocate_string("\\Windows\\Media\\tada.wav")
   2.393 -Euphoria = allocate_string("A Plain Vanilla Window using Euphoria!")
   2.394 -ps = allocate(64)
   2.395 -rect = allocate(16) 
   2.396 - 
   2.397 -global function WndProc(atom hwnd, atom iMsg, atom wParam, atom lParam)
   2.398 +atom
   2.399 + --get_env(media?)
   2.400 + wav_file = allocate_string(getenv("Windir")&`\Media\tada.wav`),
   2.401 + Euphoria = allocate_string("A Plain Vanilla Window using Euphoria!"),
   2.402 + my_title = allocate_string("Euphoria for WINDOWS"),
   2.403 + $
   2.404 +
   2.405 + --from Mike Duffy Units
   2.406 +-- create_font(hdc,"Courier New",12,FW_BOLD,0,0,0)
   2.407 +
   2.408 +public function create_font(atom hdc, sequence fontname="Veranda",
   2.409 +	integer points=12,
   2.410 +	integer weight=0, integer fitalic=0,
   2.411 +	integer funderline=0, integer fstrikeout=0, atom pandf=0
   2.412 +	)
   2.413 +	atom hfont, lpszFace, ppi, lfheight
   2.414 +
   2.415 +	ppi = c_func(GetDeviceCaps,{hdc,LOGPIXELSY})
   2.416 +	lfheight = -c_func( MulDiv, { points, ppi, 72})
   2.417 +	lpszFace = allocate_string(fontname, 1)
   2.418 +	hfont = c_func(CreateFont,
   2.419 +		{lfheight,	-- logical height of font
   2.420 +		 0,			-- logical average character width
   2.421 +		 0,			-- angle of escapement
   2.422 +		 0,			-- base-line orientation angle
   2.423 +		 weight,		-- font weight
   2.424 +		 fitalic,			-- italic attribute flag
   2.425 +		 funderline,		-- underline attribute flag
   2.426 +		 fstrikeout,		-- strikeout attribute flag
   2.427 +		 DEFAULT_CHARSET,	-- character set identifier
   2.428 +		 OUT_DEFAULT_PRECIS,	-- output precision
   2.429 +		 CLIP_DEFAULT_PRECIS,	-- clipping precision
   2.430 +		 DEFAULT_QUALITY,	-- output quality
   2.431 +		 or_all({DEFAULT_PITCH,FF_DONTCARE,pandf}),-- 0 pitch and family
   2.432 +		 lpszFace 			-- pointer to typeface name string
   2.433 +		}
   2.434 +	)
   2.435 +	return hfont
   2.436 +end function
   2.437 +
   2.438  -- callback routine to handle Window class
   2.439 -    atom hdc
   2.440 -    integer temp
   2.441 -    
   2.442 -    if iMsg = WM_CREATE then
   2.443 -	c_proc(PlaySound, {wav_file,
   2.444 -			   NULL,
   2.445 -			   or_bits(SND_FILENAME, SND_ASYNC)})
   2.446 -	return 0
   2.447 -    
   2.448 -    elsif iMsg = WM_PAINT then
   2.449 -	hdc = c_func(BeginPaint, {hwnd, ps})
   2.450 -	c_proc(GetClientRect, {hwnd, rect})
   2.451 -	c_proc(DrawText, {hdc, Euphoria, -1, rect, 
   2.452 -			  or_all({DT_SINGLELINE, DT_CENTER, DT_VCENTER})})
   2.453 -	c_proc(EndPaint, {hwnd, ps})
   2.454 +public function WndProc(atom hwnd, atom iMsg, atom wParam, atom lParam)
   2.455 +	
   2.456 +	if iMsg = WM_CREATE then
   2.457 +		c_proc(PlaySound, {wav_file,
   2.458 +				NULL,
   2.459 +				or_bits(SND_FILENAME, SND_ASYNC)})
   2.460 +		return 0
   2.461 +	
   2.462 +	elsif iMsg = WM_PAINT then
   2.463 +		atom
   2.464 +			hdc,
   2.465 +			oldFont,
   2.466 +			hCtrlFont,
   2.467 +			ps = allocate( sizeof(PAINTSTRUCT), 1),
   2.468 +			rect = allocate( sizeof(RECT), 1)
   2.469 +
   2.470 +		hdc = c_func(BeginPaint, {hwnd, ps})
   2.471 +		c_proc(GetClientRect, {hwnd, rect})
   2.472 +		hCtrlFont = create_font(hdc,"Verdana",12,FW_BOLD,0,0,0,0)
   2.473 +	
   2.474 +		--oldFont = c_func(SelectObject, {hdc, c_func(GetStockObject, {ANSI_VAR_FONT}) })
   2.475 +		oldFont = c_func(SelectObject, {hdc, hCtrlFont })
   2.476 +		c_func(SetTextColor, {hdc, c_func(GetSysColor, {COLOR_BTNTEXT}) })
   2.477 +		c_func(SetBkColor, {hdc, c_func(GetSysColor, {COLOR_BTNFACE}) })
   2.478 +
   2.479 +		c_proc(DrawText, {hdc, Euphoria, -1, rect,
   2.480 +				or_all({DT_SINGLELINE, DT_CENTER, DT_VCENTER})})
   2.481 +		c_proc(EndPaint, {hwnd, ps})
   2.482  	return 0
   2.483  	
   2.484 -    elsif iMsg = WM_DESTROY then
   2.485 -	c_proc(PostQuitMessage, {0})
   2.486 -	return 0
   2.487 +	elsif iMsg = WM_DESTROY then
   2.488 +		c_proc(PostQuitMessage, {0})
   2.489 +		return 0
   2.490 +	end if
   2.491  	
   2.492 -    end if
   2.493 -    
   2.494 -    temp = c_func(DefWindowProc, {hwnd, iMsg, wParam, lParam})
   2.495 -    return temp
   2.496 +    return c_func(DefWindowProc, {hwnd, iMsg, wParam, lParam})
   2.497  end function
   2.498  
   2.499 -atom my_title
   2.500 -my_title = allocate_string("Euphoria for WIN32")
   2.501  
   2.502  procedure WinMain()
   2.503 --- main routine 
   2.504 -    atom szAppName
   2.505 -    atom hwnd
   2.506 -    atom msg
   2.507 -    atom wndclass
   2.508 -    atom WndProcAddress
   2.509 -    atom class
   2.510 -    integer id
   2.511 -    atom icon_handle
   2.512 +-- main routine
   2.513 +	atom szAppName
   2.514 +	atom hwnd
   2.515 +	atom msg
   2.516 +	atom wndclass
   2.517 +	atom WndProcAddress
   2.518 +	atom class
   2.519 +	integer id
   2.520 +	atom icon_handle
   2.521  
   2.522 -    wndclass = allocate(SIZE_OF_WNDCLASS)
   2.523 -    msg = allocate(SIZE_OF_MESSAGE)
   2.524 -    szAppName = allocate_string("HelloWin")
   2.525 +	wndclass = allocate( sizeof(WNDCLASSEX), 1)
   2.526 +	msg = allocate( sizeof(MSG), 1)
   2.527 +	szAppName = allocate_string("winhello", 1)
   2.528  
   2.529 -    id = routine_id("WndProc")
   2.530 -    if id = -1 then
   2.531 -	puts(1, "routine_id failed!\n")
   2.532 -	abort(1)
   2.533 -    end if
   2.534 -    WndProcAddress = call_back(id) -- get 32-bit address for callback
   2.535 -    
   2.536 -    poke4(wndclass + cbSize, SIZE_OF_WNDCLASS)
   2.537 -    poke4(wndclass + style, or_bits(CS_HREDRAW, CS_VREDRAW))
   2.538 -    poke4(wndclass + lpfnWndProc, WndProcAddress)
   2.539 -    poke4(wndclass + cbClsExtra, 0)
   2.540 -    poke4(wndclass + cbWndExtra, 0)
   2.541 -    poke4(wndclass + hInstance, 0) --hInstance
   2.542 +	id = routine_id("WndProc")
   2.543 +	if id = -1 then
   2.544 +		crash( "routine_id failed!")
   2.545 +	end if
   2.546 +	WndProcAddress = call_back(id) -- get address for callback
   2.547 +	
   2.548 +	wndclass.WNDCLASSEX.cbSize      = sizeof(WNDCLASSEX)
   2.549 +	wndclass.WNDCLASSEX.style       = or_bits(CS_HREDRAW, CS_VREDRAW)
   2.550 +	wndclass.WNDCLASSEX.lpfnWndProc = WndProcAddress
   2.551 +	wndclass.WNDCLASSEX.cbClsExtra  = 0
   2.552 +	wndclass.WNDCLASSEX.cbWndExtra  = 0
   2.553 +	wndclass.WNDCLASSEX.hInstance   = 0
   2.554  
   2.555 -    -- set icon in top-left of window
   2.556 -    icon_handle = c_func(LoadIcon, {instance(), allocate_string("eui")})
   2.557 -    poke4(wndclass + hIcon, icon_handle)
   2.558 -    poke4(wndclass + hIconSm, icon_handle)
   2.559 -    
   2.560 -    -- Wolfgang Fritz observes that you can set an icon
   2.561 -    -- dynamically using:
   2.562 -    -- junk = sendMessage(YourWindow, 128, 1, icon_handle) 
   2.563 -    -- where 128 is WM_SETICON   
   2.564 -    
   2.565 -    poke4(wndclass + hCursor, c_func(LoadCursor, {NULL, IDC_ARROW}))
   2.566 -    poke4(wndclass + hbrBackground, c_func(GetStockObject, {WHITE_BRUSH}))
   2.567 -    poke4(wndclass + lpszMenuName, NULL)
   2.568 -    poke4(wndclass + lpszClassName, szAppName)
   2.569 +	-- set icon in top-left of window
   2.570 +	icon_handle = c_func(LoadIcon, {instance(), allocate_string( "eui", 1)})
   2.571 +	if icon_handle = 0 then
   2.572 +		c_proc( xSetLastError, {0} )
   2.573 +		icon_handle = c_func(LoadIcon, {NULL, IDI_APPLICATION})
   2.574 +	end if
   2.575 +	wndclass.WNDCLASSEX.hIcon   = icon_handle
   2.576 +	wndclass.WNDCLASSEX.hIconSm = icon_handle
   2.577 +	
   2.578 +	-- Wolfgang Fritz observes that you can set an icon
   2.579 +	-- dynamically using:
   2.580 +	-- sendMessage(YourWindow, WM_SETICON, 1, icon_handle)
   2.581 +	-- where WM_SETICON is 128
   2.582 +	
   2.583 +	wndclass.WNDCLASSEX.hCursor       = c_func(LoadCursor, {NULL, IDC_ARROW})
   2.584 +	wndclass.WNDCLASSEX.hbrBackground = c_func(GetStockObject, {WHITE_BRUSH})
   2.585 +	wndclass.WNDCLASSEX.lpszMenuName  = NULL
   2.586 +	wndclass.WNDCLASSEX.lpszClassName = szAppName
   2.587  
   2.588 -    class = c_func(RegisterClassEx, {wndclass})
   2.589 -    if class = 0 then
   2.590 -	puts(1, "Couldn't register class\n")
   2.591 -	abort(1)
   2.592 -    end if
   2.593 -    hwnd = c_func(CreateWindow, {
   2.594 -		    0,                       -- extended style
   2.595 -		    szAppName,               -- window class name
   2.596 -		    my_title,                -- window caption
   2.597 -		    WS_OVERLAPPEDWINDOW,     -- window style
   2.598 -		    CW_USEDEFAULT,           -- initial x position
   2.599 -		    CW_USEDEFAULT,           -- initial y position
   2.600 -		    CW_USEDEFAULT,           -- initial x size
   2.601 -		    CW_USEDEFAULT,           -- initial y size
   2.602 -		    NULL,                    -- parent window handle
   2.603 -		    NULL,                    -- window menu handle
   2.604 -		    0 ,                 --hInstance // program instance handle
   2.605 -		    NULL})              -- creation parameters
   2.606 -    if hwnd = 0 then
   2.607 -	puts(1, "Couldn't CreateWindow\n")
   2.608 -	abort(1)
   2.609 -    end if
   2.610 -    c_proc(ShowWindow, {hwnd, SW_SHOWNORMAL})
   2.611 -    c_proc(UpdateWindow, {hwnd})
   2.612 +	class = c_func(RegisterClassEx, {wndclass})
   2.613 +	if class = 0 then
   2.614 +		crash("could not register class")
   2.615 +	end if
   2.616 +	hwnd = c_func(CreateWindow, {
   2.617 +			0,                       -- extended style
   2.618 +			szAppName,               -- window class name
   2.619 +			my_title,                -- window caption
   2.620 +			WS_OVERLAPPEDWINDOW,     -- window style
   2.621 +			CW_USEDEFAULT,           -- initial x position
   2.622 +			CW_USEDEFAULT,           -- initial y position
   2.623 +			CW_USEDEFAULT,           -- initial x size
   2.624 +			CW_USEDEFAULT,           -- initial y size
   2.625 +			NULL,                    -- parent window handle
   2.626 +			NULL,                    -- window menu handle
   2.627 +			0 ,                 --hInstance // program instance handle
   2.628 +			NULL})              -- creation parameters
   2.629 +	if hwnd = 0 then
   2.630 +		crash("Couldn't CreateWindow")
   2.631 +	end if
   2.632 +	c_proc(ShowWindow, {hwnd, SW_SHOWNORMAL})
   2.633 +	c_proc(UpdateWindow, {hwnd})
   2.634  
   2.635 -    while c_func(GetMessage, {msg, NULL, 0, 0}) do
   2.636 -	c_proc(TranslateMessage, {msg})
   2.637 -	c_proc(DispatchMessage, {msg})
   2.638 -    end while
   2.639 +	while c_func(GetMessage, {msg, NULL, 0, 0}) do
   2.640 +		c_proc(TranslateMessage, {msg})
   2.641 +		c_proc(DispatchMessage, {msg})
   2.642 +	end while
   2.643  end procedure
   2.644  
   2.645  WinMain()
   2.646 -

     3.1 --- a/docs/refman_2.txt	Mon Dec 19 23:19:58 2011 -0300
     3.2 +++ b/docs/refman_2.txt	Wed Dec 21 16:45:49 2011 -0300
     3.3 @@ -4126,3 +4126,436 @@
     3.4  ##with inline## takes an optional integer parameter that defines the largest
     3.5  routine (by size of IL code) that will be considered for inlining.  The default
     3.6  is 30.
     3.7 +
     3.8 +%%output=lang_memstruct
     3.9 +== Memory Structures ==
    3.10 +@[memorystructures|]
    3.11 +:<<LEVELTOC level=2 depth=4>>
    3.12 +
    3.13 +=== Introduction
    3.14 +
    3.15 +Writing Euphoria code to interact with the operating system or external libraries often
    3.16 +requires communicating via data structures stored in memory.  In addition to using
    3.17 +peeks and pokes to read and write to memory locations, Euphoria programmers can also
    3.18 +define structures that can be used to more easily read and write values from and into
    3.19 +memory.
    3.20 +
    3.21 +The conventions used are similar to those found in the C programming language, since
    3.22 +that's the way the most commonly encountered structures are defined and meant to be
    3.23 +used.  This is meant to provide a familiar syntax to those who already know C, and
    3.24 +also to make it easy to define and use memory structures.
    3.25 +
    3.26 +=== Basic Syntax
    3.27 +
    3.28 +There are two keywords for defining memory structures: memstruct and memunion.
    3.29 +They are similar, except a memstruct is a way to define a data structure that
    3.30 +may contain many different, distinct elements, while a memunion (just like a union in C)
    3.31 +is a way to refer to the same locations in memory in different ways (e.g., either as an
    3.32 +integer or as a floating point number).
    3.33 +
    3.34 +Within a memstruct or memunion, different members are defined using names for data types
    3.35 +along with some data type modifiers. 
    3.36 +
    3.37 +It is also possible to declare fixed-length arrays of a member by adding the element count
    3.38 +inside square brackets after the member name.
    3.39 +
    3.40 +==== Assigning memstruct values
    3.41 +
    3.42 +Assigning a value to a memstruct is an alternative to using one of the ##[[:poke]]## built in
    3.43 +procedures.  The big advantage to using a ##[[:memstruct]]## over ##[[:poke]]## is that
    3.44 +euphoria handles data conversion and the calculation of offsets.
    3.45 +
    3.46 +The syntax for assigning a value to memory is the pointer to the memory,
    3.47 +followed by a dot, then the name of the memstruct, optionally followed by a dot and
    3.48 +then a member of the memstruct. If that member is an array and you wish to reference
    3.49 +a specific array element, then a 1-based index inside square brackets is also required.
    3.50 +
    3.51 +<eucode>
    3.52 +memstruct POINT
    3.53 +	int x
    3.54 +	int y
    3.55 +end memstruct
    3.56 +
    3.57 +memstruct BUFFER
    3.58 +    char name[12]  -- 'name' uses 12 bytes of space.
    3.59 +    int  next_element
    3.60 +    int  element[200] -- element uses 200 * 4 = 800 bytes of space.
    3.61 +end memstruct
    3.62 +   
    3.63 +atom point = allocate( sizeof( POINT ) )
    3.64 +point.POINT.x = 1
    3.65 +point.POINT.y = 2
    3.66 +
    3.67 +atom buf = allocate( sizeof( BUFFER ) )
    3.68 +
    3.69 +buf.BUFFER.name = "testname" -- assigns first 8 byte to string and zeros the remainder.
    3.70 +buf.BUFFER.element[1] = 543
    3.71 +buf.BUFFER.element[2] = 210
    3.72 +buf.BUFFER.element[3] = 987
    3.73 +buf.BUFFER.next_element = 4
    3.74 +
    3.75 +</eucode>
    3.76 +
    3.77 +When a member is itself a memstruct, the dot notation may be continued to access the 
    3.78 +nested members.  Continuing the ##POINT## example from above:
    3.79 +
    3.80 +<eucode>
    3.81 +memstruct RECT
    3.82 +	POINT upper_left
    3.83 +	POINT lower_right
    3.84 +end memstruct
    3.85 +
    3.86 +atom rect = allocate( sizeof( RECT ) )
    3.87 +rect.RECT.upper_left.x  = 0
    3.88 +rect.RECT.lower_right.x = 5
    3.89 +</eucode>
    3.90 +
    3.91 +Additionally, you can assign to multiple members of a memstruct at a time.  When the last
    3.92 +referenced member of the left hand side is itself a memstruct, the right hand side will
    3.93 +be assigned to the respective members of the memstruct:
    3.94 +
    3.95 +<eucode>
    3.96 +point.POINT = { 3, 6 }
    3.97 +rect.RECT.upper_left = { 0, 0 }
    3.98 +</eucode>
    3.99 +
   3.100 +If an atom is passed on the right hand side, it is treated as a single element sequence.
   3.101 +If the sequence has more elements than the memstruct has members, the extra elements are 
   3.102 +ignored.  If the sequence has fewer elements than the memstruct has members, then the
   3.103 +additional members are set to zero.  This provides for a simple way to zero out all
   3.104 +elements:
   3.105 +
   3.106 +<eucode>
   3.107 +point.POINT = {3}  -- x = 3, y = 0
   3.108 +point.POINT = {}   -- x = 0, y = 0
   3.109 +</eucode>
   3.110 +
   3.111 +Note that a ##[[:memunion]]## is treated as ##unsigned char## data.
   3.112 +
   3.113 +==== Reading memstruct values
   3.114 +
   3.115 +Reading from a memstruct is an alternative to using one of the ##peek## built in
   3.116 +procedures.    The big advantage to using a ##[[:memstruct]]## over ##[[:peek]]## is that
   3.117 +euphoria handles data conversion and the calculation of offsets.
   3.118 +
   3.119 +The syntax is the same as for [[:Assigning memstruct values]], except that it is applied
   3.120 +to the right hand side of an expression.
   3.121 +
   3.122 +==== Reading and assigning with pointers
   3.123 +
   3.124 +A memstruct member that is itself a pointer has an additional way to be used.  The normal
   3.125 +assignment and reading operations deal with the value of the pointer itself.  To access
   3.126 +the value to which the pointer points, use an additional dot, then an asterisk:
   3.127 +
   3.128 +<eucode>
   3.129 +memstruct PTR_TO_INT
   3.130 +    pointer int a
   3.131 +end memstruct
   3.132 +
   3.133 +atom ptr = allocate( sizeof( PTR_TO_INT ) )
   3.134 +ptr.PTR_TO_INT.a = allocate( sizeof( int ) )
   3.135 +
   3.136 +ptr.PTR_TO_INT.a.* = 5
   3.137 +ptr.PTR_TO_INT.a.* += 5
   3.138 +
   3.139 +? ptr.PTR_TO_INT.a.* -- prints 10
   3.140 +</eucode>
   3.141 +
   3.142 +@[memstruct|]
   3.143 +==== memstruct
   3.144 +
   3.145 +##memstruct## is used to declare a memory based structure to be used by a Euphoria program.
   3.146 +The format is similar to other declarations:
   3.147 +<eucode>
   3.148 +memstruct foo
   3.149 +    int a
   3.150 +    unsigned int b
   3.151 +    pointer int c
   3.152 +end foo
   3.153 +</eucode>
   3.154 +
   3.155 +Normal scope rules apply to ##memstruct## definitions, and so they can be local, ##export##,
   3.156 +##public## or ##global##.  The members are laid out in memory sequentially, though
   3.157 +based on their sizes, Euphoria may add some space in between members, just like a
   3.158 +C compiler would.
   3.159 +
   3.160 +The size of a ##memstruct## may be determined at runtime using ##[[:sizeof]]()##.
   3.161 +It is the sum of the sizes of its members.
   3.162 +
   3.163 +##memstructs## may contain other ##memstructs## or pointers to other ##memstructs##.
   3.164 +
   3.165 +@[memunion|]
   3.166 +==== memunion
   3.167 +
   3.168 +A ##memunion## is like a ##[[:memstruct]]##, except that the various data members
   3.169 +of a ##memunion## are all located at offset zero, which means that they all start
   3.170 +at the same RAM address.  A ##memunion##, like a union in C,
   3.171 +provides different ways to interpret the same location in memory.
   3.172 +
   3.173 +<eucode>
   3.174 +memunion conversion
   3.175 +	int i
   3.176 +	float f
   3.177 +	double d
   3.178 +end memunion
   3.179 +</eucode>
   3.180 +
   3.181 +The size of a ##memunion## may be determined at runtime using ##[[:sizeof]]()##. 
   3.182 +It is the size of the largest member.
   3.183 +
   3.184 +@[memtype|]
   3.185 +==== memtype
   3.186 +
   3.187 +A ##memtype## is an alias of another type that can be used in a ##[[:memstruct]]##
   3.188 +or a ##[[:memunion]]##.  They are used similarly to how ##typedef##s are used in C,
   3.189 +and can make porting C structs easier.  Especially on Windows, it is common for 
   3.190 +many common struct declarations to be typedefs.  The euphoria programmer can 
   3.191 +therefore create a ##memtype## and use the same terminology as the native structs.
   3.192 +
   3.193 +<eucode>
   3.194 +memtype object as HANDLE
   3.195 +
   3.196 +memtype int as BOOL
   3.197 +</eucode>
   3.198 +
   3.199 +
   3.200 +@[char|]
   3.201 +==== char
   3.202 +
   3.203 +A ##char## is a data type that is 1 byte long.  Elements of type ##char## are considered
   3.204 +to be ##[[:signed]]## by default.  The range of a ##signed char## is -128 to 127.  An
   3.205 +##unsigned char## has a range of 0 - 255.  They can only be declared inside of a 
   3.206 +##[[:memstruct]]## or ##[[:memunion]]##.
   3.207 +
   3.208 +<eucode>
   3.209 +memstruct char_types
   3.210 +	char          c   -- signed by default, -128 - 127
   3.211 +	unsigned char uc  -- 0 - 255
   3.212 +	signed char   sc  -- -128 - 127
   3.213 +end memstruct
   3.214 +</eucode>
   3.215 +
   3.216 +
   3.217 +@[short|]
   3.218 +==== short
   3.219 +A ##short## is a data type that is 2 bytes long.  Elements of type ##short## are considered
   3.220 +to be ##[[:signed]]## by default.  The range of a ##signed short## is −32,768 to 32,767.  An
   3.221 +##unsigned short## has a range of 0 - 65,535.  They can only be declared inside of a 
   3.222 +##[[:memstruct]]## or ##[[:memunion]]##.
   3.223 +
   3.224 +<eucode>
   3.225 +memstruct char_types
   3.226 +	short           s  -- signed by default, −32,768 to 32,767
   3.227 +	unsigned short us  -- −32,768 to 32,767
   3.228 +	signed short   ss  -- −32,768 to 32,767
   3.229 +end memstruct
   3.230 +</eucode>
   3.231 +
   3.232 +@[int|]
   3.233 +==== int
   3.234 +
   3.235 +An ##int## is a data type that is 4 bytes long.  Elements of type ##int## are considered
   3.236 +to be ##[[:signed]]## by default.  The range of a ##signed int## is  −2,147,483,648 to 
   3.237 +2,147,483,647.  An ##unsigned int## has a range of 0 - 4,294,967,295.  They can only be 
   3.238 +declared inside of a ##[[:memstruct]]## or ##[[:memunion]]##.
   3.239 +
   3.240 +<eucode>
   3.241 +memstruct char_types
   3.242 +	int           i  -- signed by default, −2,147,483,648 to 2,147,483,647
   3.243 +	unsigned int ui  -- 0 - 4,294,967,295
   3.244 +	signed int   si  --  −2,147,483,648 to 2,147,483,647
   3.245 +end memstruct
   3.246 +</eucode>
   3.247 +
   3.248 +@[long|]
   3.249 +==== long
   3.250 +
   3.251 +A ##long## (can also be ##long int##) varies in size based on the platform.  On Windows
   3.252 +and 32-bit Unix like operating systems, a ##long## is 4 bytes, or the same size as an
   3.253 +##[[:int]]##.  On 64-bit Unix-like operating systems, a ##long## is 64-bits, or the 
   3.254 +same size as a ##[[:long long]]##.
   3.255 +
   3.256 +
   3.257 +@[long long|]
   3.258 +==== long long
   3.259 +
   3.260 +A ##long long## (can also be ##long long int##) is an integer that is 8 bytes (64-bits) in size.
   3.261 +By default, it is signed (−9,223,372,036,854,775,808 to 9,223,372,036,854,775,807).  An ##unsigned
   3.262 +long long## varies from  0 to 18,446,744,073,709,551,615.
   3.263 +
   3.264 +
   3.265 +@[object (memstruct)|]
   3.266 +==== object (memstruct)
   3.267 +
   3.268 +An ##object##, in a ##[[:memstruct]]## or ##[[:memunion]]##, is an integer the same size as a Euphoria
   3.269 +object, and is also the same size as a pointer.  By default, it is signed, but can be declared ##unsigned##.
   3.270 +
   3.271 +@[float|]
   3.272 +==== float
   3.273 +
   3.274 +A ##float## is a 32-bit floating point number, just like those used by ##[[:atom_to_float32]]##
   3.275 +and ##[[:float32_to_atom]]##.
   3.276 +
   3.277 +@[double|]
   3.278 +==== double
   3.279 +
   3.280 +A ##double## is a 64-bit floating point number, just like those used by ##[[:atom_to_float64]]##
   3.281 +and ##[[:float64_to_atom]]##.  This is the size of floating point numbers used by 32-bit
   3.282 +Euphoria.
   3.283 +
   3.284 +@[long double|]
   3.285 +==== long double
   3.286 +
   3.287 +A ##long double## is an 80-bit floating point number, just like those used by ##[[:atom_to_float80]]##
   3.288 +and ##[[:float80_to_atom]]##.  This is the size of floating point numbers used by 64-bit
   3.289 +Euphoria.  Although they only use 80 bits, in ##[[:memstructs]]## they require 16 bytes of storage
   3.290 +for alignment purposes.
   3.291 +
   3.292 +
   3.293 +@[eudouble|]
   3.294 +==== eudouble
   3.295 +
   3.296 +A ##eudouble## is a platform independent floating point data type.  On 32-bit Euphoria, a ##eudouble##
   3.297 +is the same size (64-bits) as a ##double##.  On 64-bit Euphoria, it is 80 bits, the same size
   3.298 +as a ##long double##.
   3.299 +
   3.300 +@[pointer|]
   3.301 +==== pointer
   3.302 +
   3.303 +Data members may have the ##pointer## modifier prepended to their declaration.  This signifies that
   3.304 +the ##memstruct## contains a pointer to that type of element, rather than the element itself.
   3.305 +
   3.306 +@[signed|]
   3.307 +==== signed
   3.308 +
   3.309 +Integer data types may be signed or unsiged.  The default is to be signed, but this can be made
   3.310 +explicit by using the ##signed## modifier.
   3.311 +
   3.312 +@[unsigned|]
   3.313 +==== unsigned
   3.314 +
   3.315 +Integer data types may be signed or unsiged.  The default is to be signed, but to use an ##unsigned##
   3.316 +integer type, use the ##unsigned## modifier.
   3.317 +
   3.318 +=== Using memstructs
   3.319 +
   3.320 +To use a ##[[:memstruct]]## requires a pointer to the memory where the structure is stored.
   3.321 +This can be created by ##[[:allocate]]()##, or as the result of a call to an external library.
   3.322 +No type information is ever stored with the pointer.  Instead, the memory may be manipulated
   3.323 +using a dot notation, where the name of the ##[[:memstruct]]## follows the pointer, and
   3.324 +the names of data elements 
   3.325 +
   3.326 +Example:
   3.327 +<eucode>
   3.328 +include std/machine.e
   3.329 +
   3.330 +memstruct point
   3.331 +    int x
   3.332 +    int y
   3.333 +end memstruct
   3.334 +
   3.335 +memstruct rect
   3.336 +    point upper_left
   3.337 +    point lower_right
   3.338 +end memstruct
   3.339 +
   3.340 +atom my_rect = allocate( sizeof( rect ) )
   3.341 +
   3.342 +my_rect.rect.upper_left.x = 50
   3.343 +my_rect.rect.upper_left.y = 100
   3.344 +
   3.345 +my_rect.rect.lower_right.x = 125
   3.346 +my_rect.rect.lower_right.y = 150
   3.347 +
   3.348 +? my_rect.rect.lower_right.x  -- outputs 125
   3.349 +</eucode>
   3.350 +It is possible to //abuse// the memstruct functionality because there is no type
   3.351 +information associated with the address pointer. For example ...
   3.352 +
   3.353 +<eucode>
   3.354 +include std/machine.e
   3.355 +
   3.356 +memstruct point
   3.357 +    int x
   3.358 +    int y
   3.359 +end memstruct
   3.360 +
   3.361 +memstruct rect
   3.362 +    point upper_left
   3.363 +    point lower_right
   3.364 +end memstruct
   3.365 +
   3.366 +atom my_rect = allocate( sizeof( rect ) )
   3.367 +
   3.368 +my_rect.rect.upper_left.x = 20
   3.369 +my_rect.rect.upper_left.y = 200
   3.370 +? my_rect.rect.upper_left.x  -- outputs 20
   3.371 +
   3.372 +my_rect.point.x = 50
   3.373 +my_rect.point.y = 100
   3.374 +
   3.375 +? my_rect.rect.upper_left.x  -- outputs 50
   3.376 +</eucode>
   3.377 +
   3.378 +
   3.379 +@[addressof|]
   3.380 +==== addressof
   3.381 +
   3.382 +A function that returns the address of a memstruct member. You must supply the
   3.383 +variable that contains the starting RAM address, the memstruct name, and
   3.384 +member name sing the dot notation described above.
   3.385 +
   3.386 +Example:
   3.387 +<eucode>
   3.388 +include std/machine.e
   3.389 +
   3.390 +memstruct point
   3.391 +    int x
   3.392 +    int y
   3.393 +end memstruct
   3.394 +
   3.395 +memstruct rect
   3.396 +    point upper_left
   3.397 +    point lower_right
   3.398 +end memstruct
   3.399 +
   3.400 +atom pa = allocate( sizeof( point ) )
   3.401 +
   3.402 +? addressof(pa.point.x) = pa      -- outputs 1 (true)
   3.403 +? addressof(pa.point.y) = pa + 4  -- outputs 1 (true)
   3.404 +
   3.405 +? addressof(pa.rect.lower_right.y) = pa + 12  -- outputs 1 (true)
   3.406 +
   3.407 +</eucode>
   3.408 +
   3.409 +@[offsetof|]
   3.410 +==== offsetof
   3.411 +
   3.412 +Returns the offset in bytes of a member inside of its memstruct. You can optionally
   3.413 +omit the address pointer variable when calling this, just the memstruct name
   3.414 +and member is required.
   3.415 +
   3.416 +Example:
   3.417 +<eucode>
   3.418 +include std/machine.e
   3.419 +
   3.420 +memstruct point
   3.421 +    int x
   3.422 +    int y
   3.423 +end memstruct
   3.424 +
   3.425 +memstruct rect
   3.426 +    point upper_left
   3.427 +    point lower_right
   3.428 +end memstruct
   3.429 +
   3.430 +atom pa = allocate( sizeof( point ) )
   3.431 +
   3.432 +? offsetof(point.x)    -- outputs 0
   3.433 +? offsetof(pa.point.x) -- outputs 0
   3.434 +? offsetof(point.y)    -- outputs 4
   3.435 +? offsetof(pa.point.y) -- outputs 4
   3.436 +
   3.437 +? offsetof(rect.lower_right.y) -- outputs 12
   3.438 +
   3.439 +</eucode>

     4.1 --- a/docs/release/4.1.0.txt	Mon Dec 19 23:19:58 2011 -0300
     4.2 +++ b/docs/release/4.1.0.txt	Wed Dec 21 16:45:49 2011 -0300
     4.3 @@ -26,3 +26,6 @@
     4.4  * -cc-prefix option for translator
     4.5  * Can [[assign to multiple variables -> :Multiple Assignment]] with one statement using sequence semantics.
     4.6  * Use ##?## to stand in for default parameters.
     4.7 +* [[ticket:735]] The number of lines to be used in ctrace.out by ##trace(3)## can be configured
     4.8 +  using ##-trace-lines n## command line switch. See [[Command line switches -> :command line switches]]
     4.9 +  for more information.
    4.10 \ No newline at end of file

     5.1 --- a/docs/using_euphoria.txt	Mon Dec 19 23:19:58 2011 -0300
     5.2 +++ b/docs/using_euphoria.txt	Wed Dec 21 16:45:49 2011 -0300
     5.3 @@ -541,6 +541,10 @@
     5.4    parameter which enables many editor/IDE programs to test the syntax of your
     5.5    Euphoria source in real time.
     5.6  
     5.7 +; ##-TRACE-LINES n## (all)
     5.8 +: Changes the number of lines that will be used in ctrace.out for lines traced
     5.9 +  under ##trace(3)##.  The default is 500.
    5.10 +
    5.11  ; ##-VERSION## (all)
    5.12  : Displays the version of euphoria that is running.
    5.13  

     6.1 --- a/include/euphoria.h	Mon Dec 19 23:19:58 2011 -0300
     6.2 +++ b/include/euphoria.h	Wed Dec 21 16:45:49 2011 -0300
     6.3 @@ -329,7 +329,8 @@
     6.4  extern IFILE last_w_file_ptr;
     6.5  extern object last_r_file_no;
     6.6  extern IFILE last_r_file_ptr;
     6.7 -extern int insert_pos;;
     6.8 +extern int insert_pos;
     6.9 +extern int trace_lines;
    6.10  
    6.11  object find_from(object,object,object);
    6.12  object e_match_from(object aobj, object bobj, object c);

     7.1 --- a/include/euphoria/debug/debug.e	Mon Dec 19 23:19:58 2011 -0300
     7.2 +++ b/include/euphoria/debug/debug.e	Wed Dec 21 16:45:49 2011 -0300
     7.3 @@ -2,7 +2,6 @@
     7.4  
     7.5  include std/dll.e
     7.6  include std/machine.e
     7.7 -include euphoria/symstruct.e
     7.8  
     7.9  without trace
    7.10  
    7.11 @@ -83,6 +82,59 @@
    7.12  	return machine_func( M_CALL_STACK, {} )
    7.13  end function
    7.14  
    7.15 +public memstruct Var
    7.16 +	pointer symtab_entry declared_in
    7.17 +end memstruct
    7.18 +
    7.19 +public memstruct Block
    7.20 +	unsigned int first_line
    7.21 +	unsigned int last_line
    7.22 +end memstruct
    7.23 +
    7.24 +public memstruct private_block
    7.25 +	int task_number
    7.26 +	pointer private_block next
    7.27 +	object block[2]
    7.28 +end memstruct
    7.29 +
    7.30 +public memstruct Subp
    7.31 +	pointer object code
    7.32 +	pointer symtab_entry temps
    7.33 +	pointer private_block saved_privates
    7.34 +	pointer object block
    7.35 +	pointer int linetab
    7.36 +	unsigned int firstline
    7.37 +	unsigned int num_args
    7.38 +	int resident_task
    7.39 +	unsigned int stack_space
    7.40 +end memstruct
    7.41 +
    7.42 +public memunion U
    7.43 +	Var var
    7.44 +	Subp subp
    7.45 +	Block block
    7.46 +end memunion
    7.47 +
    7.48 +public memstruct symtab_entry
    7.49 +	object obj
    7.50 +	pointer symtab_entry next
    7.51 +	pointer symtab_entry next_in_block
    7.52 +	char mode
    7.53 +	char scope
    7.54 +	unsigned char file_no
    7.55 +	unsigned char dummy
    7.56 +	int token
    7.57 +	pointer char name
    7.58 +	U u
    7.59 +end memstruct
    7.60 +
    7.61 +public memstruct source_line
    7.62 +	pointer char src
    7.63 +	short        line
    7.64 +	char         file_no
    7.65 +	char         options
    7.66 +end memstruct
    7.67 +
    7.68  
    7.69  atom
    7.70  	symbol_table    = 0,
    7.71 @@ -318,27 +370,27 @@
    7.72  end function
    7.73  
    7.74  public function get_name( atom sym )
    7.75 -	return peek_string( peek_pointer( sym + ST_NAME ) )
    7.76 +	return peek_string( sym.symtab_entry.name )
    7.77  end function
    7.78  
    7.79 -public function get_source( integer line )
    7.80 -	return peek_string( peek_pointer( slist + SL_SIZE * line + SL_SRC ) )
    7.81 +public function get_source( integer src_line )
    7.82 +	return peek_string( slist.source_line[src_line].src )
    7.83  end function
    7.84  
    7.85  public function get_file_no( integer line )
    7.86 -	return peek( slist + line * SL_SIZE + SL_FILE_NO )
    7.87 +	return slist.source_line[line].file_no
    7.88  end function
    7.89  
    7.90  public function get_file_name( integer file_no )
    7.91 -	return peek_string( peek_pointer( file_name_ptr + sizeof( C_POINTER ) * file_no ) )
    7.92 +	return peek_string( file_name_ptr + sizeof( pointer ) * file_no )
    7.93  end function
    7.94  
    7.95 -public function get_file_line( integer line )
    7.96 -	return peek2u( slist + line * SL_SIZE + SL_LINE )
    7.97 +public function get_file_line( integer line_no )
    7.98 +	return slist.source_line[line_no].line
    7.99  end function
   7.100  
   7.101  public function get_next( atom sym )
   7.102 -	return peek_pointer( sym + ST_NEXT )
   7.103 +	return sym.symtab_entry.next
   7.104  end function
   7.105  
   7.106  public function is_variable( atom sym_ptr )
   7.107 @@ -346,16 +398,16 @@
   7.108  		return 0
   7.109  	end if
   7.110  	
   7.111 -	return -100 = peek4s( sym_ptr + ST_TOKEN )
   7.112 +	return -100 = sym_ptr.symtab_entry.token
   7.113  end function
   7.114  
   7.115  public function get_parameter_syms( atom rtn_sym )
   7.116 -	integer param_count = peek4u( rtn_sym + ST_NUM_ARGS )
   7.117 +	integer param_count = rtn_sym.symtab_entry.u.subp.num_args
   7.118  	sequence syms = repeat( 0, param_count )
   7.119 -	atom next_sym = peek_pointer( rtn_sym + ST_NEXT )
   7.120 +	atom next_sym = rtn_sym.symtab_entry.next
   7.121  	for i = 1 to param_count do
   7.122 -		while peek( next_sym + ST_SCOPE ) != 3 do -- SC_PRIVATE = 3
   7.123 -			next_sym = peek_pointer( next_sym + ST_NEXT )
   7.124 +		while next_sym.symtab_entry.scope != 3 do -- SC_PRIVATE = 3
   7.125 +			next_sym = next_sym.symtab_entry.next
   7.126  		end while
   7.127  		syms[i] = next_sym
   7.128  	end for

     8.1 --- a/include/euphoria/keywords.e	Mon Dec 19 23:19:58 2011 -0300
     8.2 +++ b/include/euphoria/keywords.e	Wed Dec 21 16:45:49 2011 -0300
     8.3 @@ -25,6 +25,7 @@
     8.4  	"continue",
     8.5      "deprecate",
     8.6  	"do",
     8.7 +	"double",
     8.8  	"else",
     8.9  	"elsedef",
    8.10  	"elsif",
    8.11 @@ -35,6 +36,7 @@
    8.12  	"exit",
    8.13  	"export",
    8.14  	"fallthru",
    8.15 +	"float",
    8.16  	"for",
    8.17  	"function",
    8.18  	"global",
    8.19 @@ -42,21 +44,29 @@
    8.20  	"if",
    8.21  	"ifdef",
    8.22  	"include",
    8.23 +	"int",
    8.24  	"label",
    8.25 +	"long",
    8.26  	"loop",
    8.27 +	"memstruct",
    8.28 +	"memtype",
    8.29 +	"memunion",
    8.30  	"namespace",
    8.31  	"not",
    8.32  	"or",
    8.33  	"override",
    8.34 +	"pointer",
    8.35  	"procedure",
    8.36  	"public",
    8.37  	"retry",
    8.38  	"return",
    8.39  	"routine",
    8.40 +	"signed",
    8.41  	"switch",
    8.42  	"then",
    8.43  	"to",
    8.44  	"type",
    8.45 +	"unsigned",
    8.46  	"until",
    8.47  	"while",
    8.48  	"with",

     9.1 --- a/include/euphoria/symstruct.e	Mon Dec 19 23:19:58 2011 -0300
     9.2 +++ b/include/euphoria/symstruct.e	Wed Dec 21 16:45:49 2011 -0300
     9.3 @@ -28,6 +28,16 @@
     9.4  	ST_FIRST_LINE     = offset( C_INT, ST_DECLARED_IN ), -- 24,
     9.5  	ST_LAST_LINE      = offset( C_INT ), -- 28,
     9.6  	
     9.7 +	-- memstruct:
     9.8 +	ST_MEM_NEXT       = offset( C_POINTER, ST_DECLARED_IN  ),
     9.9 +	ST_MEM_STRUCT     = offset( C_POINTER ),
    9.10 +	ST_MEM_PARENT     = offset( C_POINTER ),
    9.11 +	ST_MEM_SIZE       = offset( C_INT ),
    9.12 +	ST_MEM_OFFSET     = offset( C_INT ),
    9.13 +	ST_MEM_ARRAY      = offset( C_INT ),
    9.14 +	ST_MEM_SIGNED     = offset( C_CHAR ),
    9.15 +	ST_MEM_POINTER    = offset( C_CHAR ),
    9.16 +	
    9.17  	-- routine:
    9.18  	ST_CODE           = offset( C_POINTER, ST_DECLARED_IN ), -- 24,
    9.19  	ST_TEMPS          = offset( C_POINTER ), -- 36,

    10.1 --- a/include/euphoria/tokenize.e	Mon Dec 19 23:19:58 2011 -0300
    10.2 +++ b/include/euphoria/tokenize.e	Wed Dec 21 16:45:49 2011 -0300
    10.3 @@ -1020,7 +1020,7 @@
    10.4  				Token[TDATA] &= Look
    10.5  
    10.6  				scan_char(state)
    10.7 -			else
    10.8 +			elsif find( Look, "0123456789" )  then
    10.9  				-- .number
   10.10  				Token[TTYPE] = T_NUMBER
   10.11  				Token[TDATA] = scan_fraction(0, state)
   10.12 @@ -1038,6 +1038,9 @@
   10.13  						Token[TDATA] = sprintf("%g",{Token[TDATA]})
   10.14  					end if
   10.15  				end if
   10.16 +			else
   10.17 +				-- memstruct
   10.18 +				scan_identifier( state )
   10.19  			end if
   10.20  
   10.21  		elsif (Look = '-') and (Token[TTYPE] = T_MINUS) then

    11.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    11.2 +++ b/include/std/memstruct/windows.e	Wed Dec 21 16:45:49 2011 -0300
    11.3 @@ -0,0 +1,318 @@
    11.4 +--****
    11.5 +-- == Common Windows Memstructs
    11.6 +--
    11.7 +-- <<LEVELTOC level=2 depth=5>>
    11.8 +--
    11.9 +
   11.10 +--****
   11.11 +-- === Windows Type constants for structs
   11.12 +
   11.13 +public memtype
   11.14 +	char as BYTE,
   11.15 +	int as BOOL,
   11.16 +	int as INT,
   11.17 +	unsigned int as UINT,
   11.18 +	long as LONG,
   11.19 +	unsigned long as ULONG,
   11.20 +	double as DOUBLE,
   11.21 +	short as WORD,
   11.22 +	long as DWORD,
   11.23 +	object as HANDLE,
   11.24 +	object as HWND,
   11.25 +	object as LPSTR,
   11.26 +	object as LPTSTR,
   11.27 +	object as WNDPROC,
   11.28 +	object as WPARAM,
   11.29 +	object as LPARAM,
   11.30 +	object as HINSTANCE,
   11.31 +	object as LPCSTR,
   11.32 +	object as LPCTSTR,
   11.33 +	object as LPOFNHOOKPROC,
   11.34 +	object as BFFCALLBACK,
   11.35 +	unsigned short as USHORT,
   11.36 +	object as LPCCHOOKPROC,
   11.37 +	long as COLORREF,
   11.38 +	object as INT_PTR,
   11.39 +	object as UINT_PTR,
   11.40 +	char as TCHAR,
   11.41 +	object as HICON,
   11.42 +	object as HTREEITEM,
   11.43 +	object as LPFRHOOKPROC,
   11.44 +	$
   11.45 +	
   11.46 +--****
   11.47 +-- === Windows structures
   11.48 +
   11.49 +public memstruct WNDCLASSEX
   11.50 +	UINT cbSize
   11.51 +	UINT style
   11.52 +	WNDPROC lpfnWndProc  	--WNDPROC
   11.53 +	INT cbClsExtra
   11.54 +	INT cbWndExtra
   11.55 +	HANDLE hInstance  	--HINSTANCE
   11.56 +	HANDLE hIcon   		--HICON
   11.57 +	HANDLE hCursor  	--HCURSOR
   11.58 +	HANDLE hbrBackground 	--HBRUSH
   11.59 +	LPSTR lpszMenuName  	--LPCSTR
   11.60 +	LPSTR lpszClassName	--LPCSTR
   11.61 +	HANDLE hIconSm		--HICON
   11.62 +end memstruct
   11.63 +
   11.64 +public memstruct POINT
   11.65 +	LONG x
   11.66 +	LONG y
   11.67 +end memstruct
   11.68 +
   11.69 +public memstruct RECT
   11.70 +	LONG left
   11.71 +	LONG top
   11.72 +	LONG right
   11.73 +	LONG bottom
   11.74 +end memstruct
   11.75 +
   11.76 +public memstruct PAINTSTRUCT
   11.77 +	HANDLE hdc		--HDC
   11.78 +	BOOL fErase
   11.79 +	RECT rcPaint		--RECT
   11.80 +	BOOL fRestore
   11.81 +	BOOL fIncUpdate
   11.82 +	BYTE rgbReserved[32]	--BYTE,32
   11.83 +end memstruct
   11.84 +
   11.85 +public memstruct MSG
   11.86 +	HWND hwnd
   11.87 +	UINT message
   11.88 +	WPARAM wParam
   11.89 +	LPARAM lParam
   11.90 +	DWORD time
   11.91 +	POINT pt
   11.92 +end memstruct
   11.93 +
   11.94 +public memstruct NMHDR
   11.95 +	HWND hwndFrom
   11.96 +	UINT_PTR idFrom
   11.97 +	UINT code
   11.98 +end memstruct
   11.99 +
  11.100 +public memstruct LVCOLUMN
  11.101 +	UINT mask
  11.102 +	int fmt
  11.103 +	int cx
  11.104 +	LPTSTR pszText
  11.105 +	int cchTextMax
  11.106 +	int iSubItem
  11.107 +	int iImage
  11.108 +	int iOrder
  11.109 +	int cxMin
  11.110 +	int cxDefault
  11.111 +	int cxIdeal
  11.112 +end memstruct
  11.113 +
  11.114 +public memstruct LVITEM
  11.115 +	UINT mask
  11.116 +	int    iItem
  11.117 +	int    iSubItem
  11.118 +	UINT   state
  11.119 +	UINT   stateMask
  11.120 +	LPTSTR pszText
  11.121 +	int    cchTextMax
  11.122 +	int    iImage
  11.123 +	object lParam
  11.124 +-- 	#if (_WIN32_IE >= 0x0300)
  11.125 +	int    iIndent
  11.126 +-- 	#endif 
  11.127 +-- 	#if (_WIN32_WINNT >= 0x0501)
  11.128 +	int    iGroupId
  11.129 +	UINT   cColumns
  11.130 +	UINT   puColumns
  11.131 +-- 	#endif 
  11.132 +-- 	#if (_WIN32_WINNT >= 0x0600)
  11.133 +	int    piColFmt
  11.134 +	int    iGroup
  11.135 +end memstruct
  11.136 +
  11.137 +public memstruct LV_DISPINFO
  11.138 +	NMHDR hdr
  11.139 +	LVITEM item
  11.140 +end memstruct
  11.141 +
  11.142 +public memstruct OPENFILENAME
  11.143 +  DWORD         lStructSize
  11.144 +  HWND          hwndOwner
  11.145 +  HINSTANCE     hInstance
  11.146 +  LPCTSTR       lpstrFilter
  11.147 +  LPTSTR        lpstrCustomFilter
  11.148 +  DWORD         nMaxCustFilter
  11.149 +  DWORD         nFilterIndex
  11.150 +  LPTSTR        lpstrFile
  11.151 +  DWORD         nMaxFile
  11.152 +  LPTSTR        lpstrFileTitle
  11.153 +  DWORD         nMaxFileTitle
  11.154 +  LPCTSTR       lpstrInitialDir
  11.155 +  LPCTSTR       lpstrTitle
  11.156 +  DWORD         Flags
  11.157 +  WORD          nFileOffset
  11.158 +  WORD          nFileExtension
  11.159 +  LPCTSTR       lpstrDefExt
  11.160 +  LPARAM        lCustData
  11.161 +  LPOFNHOOKPROC lpfnHook
  11.162 +  LPCTSTR       lpTemplateName
  11.163 +-- #if (_WIN32_WINNT >= 0x0500)
  11.164 +  object        pvReserved
  11.165 +  DWORD         dwReserved
  11.166 +  DWORD         FlagsEx
  11.167 +-- #endif 
  11.168 +end memstruct
  11.169 +
  11.170 +public memstruct SHITEMID
  11.171 +	USHORT cb
  11.172 +	pointer BYTE abID
  11.173 +end memstruct
  11.174 +
  11.175 +public memstruct BROWSEINFO
  11.176 +	HWND              hwndOwner
  11.177 +	pointer SHITEMID  pidlRoot
  11.178 +	LPTSTR            pszDisplayName
  11.179 +	LPCTSTR           lpszTitle
  11.180 +	UINT              ulFlags
  11.181 +	BFFCALLBACK       lpfn
  11.182 +	LPARAM            lParam
  11.183 +	int               iImage
  11.184 +end memstruct
  11.185 +
  11.186 +public memstruct CHOOSECOLOR
  11.187 +	DWORD        lStructSize
  11.188 +	HWND         hwndOwner
  11.189 +	HWND         hInstance
  11.190 +	COLORREF     rgbResult
  11.191 +	pointer COLORREF     lpCustColors
  11.192 +	DWORD        Flags
  11.193 +	LPARAM       lCustData
  11.194 +	LPCCHOOKPROC lpfnHook
  11.195 +	LPCTSTR      lpTemplateName
  11.196 +end memstruct
  11.197 +
  11.198 +public memstruct COMBOBOXEXITEM
  11.199 +	UINT    mask
  11.200 +	INT_PTR iItem
  11.201 +	LPTSTR  pszText
  11.202 +	int     cchTextMax
  11.203 +	int     iImage
  11.204 +	int     iSelectedImage
  11.205 +	int     iOverlay
  11.206 +	int     iIndent
  11.207 +	LPARAM  lParam
  11.208 +end memstruct
  11.209 +
  11.210 +public memstruct NMLISTVIEW
  11.211 +	NMHDR  hdr
  11.212 +	int    iItem
  11.213 +	int    iSubItem
  11.214 +	UINT   uNewState
  11.215 +	UINT   uOldState
  11.216 +	UINT   uChanged
  11.217 +	POINT  ptAction
  11.218 +	LPARAM lParam
  11.219 +end memstruct
  11.220 +
  11.221 +public memstruct SHFILEINFO
  11.222 +  HICON hIcon
  11.223 +  int   iIcon
  11.224 +  DWORD dwAttributes
  11.225 +  TCHAR szDisplayName[260]
  11.226 +  TCHAR szTypeName[80]
  11.227 +end memstruct
  11.228 +
  11.229 +public memstruct TVITEM
  11.230 +	UINT      mask
  11.231 +	HTREEITEM hItem
  11.232 +	UINT      state
  11.233 +	UINT      stateMask
  11.234 +	LPTSTR    pszText
  11.235 +	int       cchTextMax
  11.236 +	int       iImage
  11.237 +	int       iSelectedImage
  11.238 +	int       cChildren
  11.239 +	LPARAM    lParam
  11.240 +end memstruct
  11.241 +
  11.242 +public memstruct TVITEMEX
  11.243 +	UINT      mask
  11.244 +	HTREEITEM hItem
  11.245 +	UINT      state
  11.246 +	UINT      stateMask
  11.247 +	LPTSTR    pszText
  11.248 +	int       cchTextMax
  11.249 +	int       iImage
  11.250 +	int       iSelectedImage
  11.251 +	int       cChildren
  11.252 +	LPARAM    lParam
  11.253 +	int       iIntegral
  11.254 +-- 	#if (_WIN32_IE >= 0x0600)
  11.255 +	UINT      uStateEx
  11.256 +	HWND      hwnd
  11.257 +	int       iExpandedImage
  11.258 +-- -- 	#endif 
  11.259 +-- -- 	#if (NTDDI_VERSION >= NTDDI_WIN7)
  11.260 +	int       iReserved
  11.261 +-- 	#endif 
  11.262 +end memstruct
  11.263 +
  11.264 +public memunion TVINSERTUNION
  11.265 +	TVITEMEX itemex
  11.266 +	TVITEM   item
  11.267 +end memunion
  11.268 +
  11.269 +public memstruct TVINSERTSTRUCT
  11.270 +	HTREEITEM hParent
  11.271 +	HTREEITEM hInsertAfter
  11.272 +-- 	#if (_WIN32_IE >= 0x0400)
  11.273 +	TVINSERTUNION u
  11.274 +end memstruct
  11.275 +
  11.276 +public memstruct NMTVDISPINFO
  11.277 +	NMHDR hdr
  11.278 +	TVITEM item
  11.279 +end memstruct
  11.280 +
  11.281 +public memstruct NMTREEVIEW
  11.282 +	NMHDR  hdr
  11.283 +	UINT   action
  11.284 +	TVITEM itemOld
  11.285 +	TVITEM itemNew
  11.286 +	POINT  ptDrag
  11.287 +end memstruct
  11.288 +
  11.289 +public memstruct TVHITTESTINFO
  11.290 +	POINT     pt
  11.291 +	UINT      flags
  11.292 +	HTREEITEM hItem
  11.293 +end memstruct
  11.294 +
  11.295 +public memstruct NMCBEENDEDIT
  11.296 +	NMHDR hdr
  11.297 +	BOOL  fChanged
  11.298 +	int   iNewSelection
  11.299 +	TCHAR szText
  11.300 +	int   iWhy
  11.301 +end memstruct
  11.302 +
  11.303 +public memstruct NMUPDOWN
  11.304 +	NMHDR hdr
  11.305 +	int   iPos
  11.306 +	int   iDelta
  11.307 +end memstruct
  11.308 +
  11.309 +public memstruct FINDREPLACE
  11.310 +	DWORD        lStructSize
  11.311 +	HWND         hwndOwner
  11.312 +	HINSTANCE    hInstance
  11.313 +	DWORD        Flags
  11.314 +	LPTSTR       lpstrFindWhat
  11.315 +	LPTSTR       lpstrReplaceWith
  11.316 +	WORD         wFindWhatLen
  11.317 +	WORD         wReplaceWithLen
  11.318 +	LPARAM       lCustData
  11.319 +	LPFRHOOKPROC lpfnHook
  11.320 +	LPCTSTR      lpTemplateName
  11.321 +end memstruct

    12.1 --- a/source/Makefile.gnu	Mon Dec 19 23:19:58 2011 -0300
    12.2 +++ b/source/Makefile.gnu	Wed Dec 21 16:45:49 2011 -0300
    12.3 @@ -270,6 +270,7 @@
    12.4  	inline.e \
    12.5  	keylist.e \
    12.6  	main.e \
    12.7 +	memstruct.e \
    12.8  	msgtext.e \
    12.9  	mode.e \
   12.10  	opnames.e \
   12.11 @@ -295,6 +296,7 @@
   12.12  	buildsys.e \
   12.13  	c_decl.e \
   12.14  	c_out.e \
   12.15 +	c_struct.e \
   12.16  	cominit.e \
   12.17  	compile.e \
   12.18  	compress.e \
   12.19 @@ -334,6 +336,7 @@
   12.20  	$(BUILDDIR)/$(OBJDIR)/back/be_symtab.o \
   12.21  	$(BUILDDIR)/$(OBJDIR)/back/be_socket.o \
   12.22  	$(BUILDDIR)/$(OBJDIR)/back/be_w.o \
   12.23 +	$(BUILDDIR)/$(OBJDIR)/back/be_memstruct.o \
   12.24  	$(PREFIXED_PCRE_OBJECTS)
   12.25  
   12.26  EU_LIB_OBJECTS = \
   12.27 @@ -1005,18 +1008,18 @@
   12.28  # The dependencies below are automatically generated using the depend target above.
   12.29  # DO NOT DELETE
   12.30  
   12.31 -$(BUILDDIR)/intobj/back/be_alloc.o: be_alloc.h  alldefs.h global.h object.h symtab.h
   12.32 -$(BUILDDIR)/intobj/back/be_alloc.o: be_alloc.h  execute.h reswords.h be_runtime.h
   12.33 -$(BUILDDIR)/intobj/back/be_alloc.o: be_alloc.h  be_alloc.h
   12.34 +$(BUILDDIR)/intobj/back/be_alloc.o: alldefs.h global.h object.h symtab.h
   12.35 +$(BUILDDIR)/intobj/back/be_alloc.o: execute.h reswords.h be_runtime.h
   12.36 +$(BUILDDIR)/intobj/back/be_alloc.o: be_alloc.h
   12.37  $(BUILDDIR)/intobj/back/be_callc.o: alldefs.h global.h object.h symtab.h
   12.38  $(BUILDDIR)/intobj/back/be_callc.o: execute.h reswords.h be_runtime.h
   12.39  $(BUILDDIR)/intobj/back/be_callc.o: be_machine.h be_alloc.h
   12.40  $(BUILDDIR)/intobj/back/be_coverage.o: be_coverage.h be_machine.h global.h
   12.41  $(BUILDDIR)/intobj/back/be_coverage.o: object.h symtab.h execute.h
   12.42  $(BUILDDIR)/intobj/back/be_debug.o: execute.h global.h object.h symtab.h
   12.43 -$(BUILDDIR)/intobj/back/be_debug.o: be_alloc.h be_debug.h be_execute.h
   12.44 -$(BUILDDIR)/intobj/back/be_debug.o: be_machine.h be_rterror.h be_runtime.h
   12.45 -$(BUILDDIR)/intobj/back/be_debug.o: reswords.h
   12.46 +$(BUILDDIR)/intobj/back/be_debug.o: redef.h reswords.h be_alloc.h be_debug.h
   12.47 +$(BUILDDIR)/intobj/back/be_debug.o: be_execute.h be_machine.h be_rterror.h
   12.48 +$(BUILDDIR)/intobj/back/be_debug.o: be_runtime.h be_symtab.h
   12.49  $(BUILDDIR)/intobj/back/be_decompress.o: alldefs.h global.h object.h symtab.h
   12.50  $(BUILDDIR)/intobj/back/be_decompress.o: execute.h reswords.h be_alloc.h
   12.51  $(BUILDDIR)/intobj/back/be_decompress.o: be_runtime.h
   12.52 @@ -1026,6 +1029,7 @@
   12.53  $(BUILDDIR)/intobj/back/be_execute.o: be_inline.h be_machine.h be_task.h
   12.54  $(BUILDDIR)/intobj/back/be_execute.o: be_rterror.h be_symtab.h be_w.h
   12.55  $(BUILDDIR)/intobj/back/be_execute.o: be_callc.h be_coverage.h be_execute.h
   12.56 +$(BUILDDIR)/intobj/back/be_execute.o: be_debug.h be_memstruct.h
   12.57  $(BUILDDIR)/intobj/back/be_inline.o: alldefs.h global.h object.h symtab.h
   12.58  $(BUILDDIR)/intobj/back/be_inline.o: execute.h reswords.h be_alloc.h
   12.59  $(BUILDDIR)/intobj/back/be_machine.o: global.h object.h symtab.h alldefs.h
   12.60 @@ -1039,9 +1043,12 @@
   12.61  $(BUILDDIR)/intobj/back/be_main.o: execute.h reswords.h be_runtime.h
   12.62  $(BUILDDIR)/intobj/back/be_main.o: be_execute.h be_alloc.h be_rterror.h
   12.63  $(BUILDDIR)/intobj/back/be_main.o: be_w.h
   12.64 -$(BUILDDIR)/intobj/back/be_pcre.o: be_alloc.h  alldefs.h global.h object.h symtab.h
   12.65 -$(BUILDDIR)/intobj/back/be_pcre.o: be_alloc.h  execute.h reswords.h be_alloc.h
   12.66 -$(BUILDDIR)/intobj/back/be_pcre.o: be_alloc.h  be_runtime.h be_pcre.h pcre/pcre.h
   12.67 +$(BUILDDIR)/intobj/back/be_memstruct.o: execute.h global.h object.h symtab.h
   12.68 +$(BUILDDIR)/intobj/back/be_memstruct.o: reswords.h be_alloc.h be_machine.h
   12.69 +$(BUILDDIR)/intobj/back/be_memstruct.o: be_memstruct.h be_runtime.h
   12.70 +$(BUILDDIR)/intobj/back/be_pcre.o: alldefs.h global.h object.h symtab.h
   12.71 +$(BUILDDIR)/intobj/back/be_pcre.o: execute.h reswords.h be_alloc.h
   12.72 +$(BUILDDIR)/intobj/back/be_pcre.o: be_runtime.h be_pcre.h pcre/pcre.h
   12.73  $(BUILDDIR)/intobj/back/be_pcre.o: be_machine.h
   12.74  $(BUILDDIR)/intobj/back/be_rterror.o: alldefs.h global.h object.h symtab.h
   12.75  $(BUILDDIR)/intobj/back/be_rterror.o: execute.h reswords.h be_rterror.h
   12.76 @@ -1067,23 +1074,23 @@
   12.77  $(BUILDDIR)/intobj/back/be_task.o: reswords.h be_runtime.h be_task.h
   12.78  $(BUILDDIR)/intobj/back/be_task.o: be_alloc.h be_machine.h be_execute.h
   12.79  $(BUILDDIR)/intobj/back/be_task.o: be_symtab.h alldefs.h
   12.80 -$(BUILDDIR)/intobj/back/be_w.o: be_alloc.h  alldefs.h global.h object.h symtab.h
   12.81 -$(BUILDDIR)/intobj/back/be_w.o: be_alloc.h  execute.h reswords.h be_w.h be_machine.h
   12.82 -$(BUILDDIR)/intobj/back/be_w.o: be_alloc.h  be_runtime.h be_rterror.h be_alloc.h
   12.83 +$(BUILDDIR)/intobj/back/be_w.o: alldefs.h global.h object.h symtab.h
   12.84 +$(BUILDDIR)/intobj/back/be_w.o: execute.h reswords.h be_w.h be_machine.h
   12.85 +$(BUILDDIR)/intobj/back/be_w.o: be_runtime.h be_rterror.h be_alloc.h
   12.86  $(BUILDDIR)/intobj/back/rbt.o: rbt.h
   12.87  
   12.88 -$(BUILDDIR)/transobj/back/be_alloc.o: be_alloc.h  alldefs.h global.h object.h symtab.h
   12.89 -$(BUILDDIR)/transobj/back/be_alloc.o: be_alloc.h  execute.h reswords.h be_runtime.h
   12.90 -$(BUILDDIR)/transobj/back/be_alloc.o: be_alloc.h  be_alloc.h
   12.91 +$(BUILDDIR)/transobj/back/be_alloc.o: alldefs.h global.h object.h symtab.h
   12.92 +$(BUILDDIR)/transobj/back/be_alloc.o: execute.h reswords.h be_runtime.h
   12.93 +$(BUILDDIR)/transobj/back/be_alloc.o: be_alloc.h
   12.94  $(BUILDDIR)/transobj/back/be_callc.o: alldefs.h global.h object.h symtab.h
   12.95  $(BUILDDIR)/transobj/back/be_callc.o: execute.h reswords.h be_runtime.h
   12.96  $(BUILDDIR)/transobj/back/be_callc.o: be_machine.h be_alloc.h
   12.97  $(BUILDDIR)/transobj/back/be_coverage.o: be_coverage.h be_machine.h global.h
   12.98  $(BUILDDIR)/transobj/back/be_coverage.o: object.h symtab.h execute.h
   12.99  $(BUILDDIR)/transobj/back/be_debug.o: execute.h global.h object.h symtab.h
  12.100 -$(BUILDDIR)/transobj/back/be_debug.o: be_alloc.h be_debug.h be_execute.h
  12.101 -$(BUILDDIR)/transobj/back/be_debug.o: be_machine.h be_rterror.h be_runtime.h
  12.102 -$(BUILDDIR)/transobj/back/be_debug.o: reswords.h
  12.103 +$(BUILDDIR)/transobj/back/be_debug.o: redef.h reswords.h be_alloc.h
  12.104 +$(BUILDDIR)/transobj/back/be_debug.o: be_debug.h be_execute.h be_machine.h
  12.105 +$(BUILDDIR)/transobj/back/be_debug.o: be_rterror.h be_runtime.h be_symtab.h
  12.106  $(BUILDDIR)/transobj/back/be_decompress.o: alldefs.h global.h object.h
  12.107  $(BUILDDIR)/transobj/back/be_decompress.o: symtab.h execute.h reswords.h
  12.108  $(BUILDDIR)/transobj/back/be_decompress.o: be_alloc.h be_runtime.h
  12.109 @@ -1093,6 +1100,7 @@
  12.110  $(BUILDDIR)/transobj/back/be_execute.o: be_inline.h be_machine.h be_task.h
  12.111  $(BUILDDIR)/transobj/back/be_execute.o: be_rterror.h be_symtab.h be_w.h
  12.112  $(BUILDDIR)/transobj/back/be_execute.o: be_callc.h be_coverage.h be_execute.h
  12.113 +$(BUILDDIR)/transobj/back/be_execute.o: be_debug.h be_memstruct.h
  12.114  $(BUILDDIR)/transobj/back/be_inline.o: alldefs.h global.h object.h symtab.h
  12.115  $(BUILDDIR)/transobj/back/be_inline.o: execute.h reswords.h be_alloc.h
  12.116  $(BUILDDIR)/transobj/back/be_machine.o: global.h object.h symtab.h alldefs.h
  12.117 @@ -1107,9 +1115,13 @@
  12.118  $(BUILDDIR)/transobj/back/be_main.o: execute.h reswords.h be_runtime.h
  12.119  $(BUILDDIR)/transobj/back/be_main.o: be_execute.h be_alloc.h be_rterror.h
  12.120  $(BUILDDIR)/transobj/back/be_main.o: be_w.h
  12.121 -$(BUILDDIR)/transobj/back/be_pcre.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.122 -$(BUILDDIR)/transobj/back/be_pcre.o: be_alloc.h  execute.h reswords.h be_alloc.h
  12.123 -$(BUILDDIR)/transobj/back/be_pcre.o: be_alloc.h  be_runtime.h be_pcre.h pcre/pcre.h
  12.124 +$(BUILDDIR)/transobj/back/be_memstruct.o: execute.h global.h object.h
  12.125 +$(BUILDDIR)/transobj/back/be_memstruct.o: symtab.h reswords.h be_alloc.h
  12.126 +$(BUILDDIR)/transobj/back/be_memstruct.o: be_machine.h be_memstruct.h
  12.127 +$(BUILDDIR)/transobj/back/be_memstruct.o: be_runtime.h
  12.128 +$(BUILDDIR)/transobj/back/be_pcre.o: alldefs.h global.h object.h symtab.h
  12.129 +$(BUILDDIR)/transobj/back/be_pcre.o: execute.h reswords.h be_alloc.h
  12.130 +$(BUILDDIR)/transobj/back/be_pcre.o: be_runtime.h be_pcre.h pcre/pcre.h
  12.131  $(BUILDDIR)/transobj/back/be_pcre.o: be_machine.h
  12.132  $(BUILDDIR)/transobj/back/be_rterror.o: alldefs.h global.h object.h symtab.h
  12.133  $(BUILDDIR)/transobj/back/be_rterror.o: execute.h reswords.h be_rterror.h
  12.134 @@ -1136,23 +1148,23 @@
  12.135  $(BUILDDIR)/transobj/back/be_task.o: reswords.h be_runtime.h be_task.h
  12.136  $(BUILDDIR)/transobj/back/be_task.o: be_alloc.h be_machine.h be_execute.h
  12.137  $(BUILDDIR)/transobj/back/be_task.o: be_symtab.h alldefs.h
  12.138 -$(BUILDDIR)/transobj/back/be_w.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.139 -$(BUILDDIR)/transobj/back/be_w.o: be_alloc.h  execute.h reswords.h be_w.h be_machine.h
  12.140 -$(BUILDDIR)/transobj/back/be_w.o: be_alloc.h  be_runtime.h be_rterror.h be_alloc.h
  12.141 +$(BUILDDIR)/transobj/back/be_w.o: alldefs.h global.h object.h symtab.h
  12.142 +$(BUILDDIR)/transobj/back/be_w.o: execute.h reswords.h be_w.h be_machine.h
  12.143 +$(BUILDDIR)/transobj/back/be_w.o: be_runtime.h be_rterror.h be_alloc.h
  12.144  $(BUILDDIR)/transobj/back/rbt.o: rbt.h
  12.145  
  12.146 -$(BUILDDIR)/backobj/back/be_alloc.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.147 -$(BUILDDIR)/backobj/back/be_alloc.o: be_alloc.h  execute.h reswords.h be_runtime.h
  12.148 -$(BUILDDIR)/backobj/back/be_alloc.o: be_alloc.h  be_alloc.h
  12.149 +$(BUILDDIR)/backobj/back/be_alloc.o: alldefs.h global.h object.h symtab.h
  12.150 +$(BUILDDIR)/backobj/back/be_alloc.o: execute.h reswords.h be_runtime.h
  12.151 +$(BUILDDIR)/backobj/back/be_alloc.o: be_alloc.h
  12.152  $(BUILDDIR)/backobj/back/be_callc.o: alldefs.h global.h object.h symtab.h
  12.153  $(BUILDDIR)/backobj/back/be_callc.o: execute.h reswords.h be_runtime.h
  12.154  $(BUILDDIR)/backobj/back/be_callc.o: be_machine.h be_alloc.h
  12.155  $(BUILDDIR)/backobj/back/be_coverage.o: be_coverage.h be_machine.h global.h
  12.156  $(BUILDDIR)/backobj/back/be_coverage.o: object.h symtab.h execute.h
  12.157  $(BUILDDIR)/backobj/back/be_debug.o: execute.h global.h object.h symtab.h
  12.158 -$(BUILDDIR)/backobj/back/be_debug.o: be_alloc.h be_debug.h be_execute.h
  12.159 -$(BUILDDIR)/backobj/back/be_debug.o: be_machine.h be_rterror.h be_runtime.h
  12.160 -$(BUILDDIR)/backobj/back/be_debug.o: reswords.h
  12.161 +$(BUILDDIR)/backobj/back/be_debug.o: redef.h reswords.h be_alloc.h be_debug.h
  12.162 +$(BUILDDIR)/backobj/back/be_debug.o: be_execute.h be_machine.h be_rterror.h
  12.163 +$(BUILDDIR)/backobj/back/be_debug.o: be_runtime.h be_symtab.h
  12.164  $(BUILDDIR)/backobj/back/be_decompress.o: alldefs.h global.h object.h
  12.165  $(BUILDDIR)/backobj/back/be_decompress.o: symtab.h execute.h reswords.h
  12.166  $(BUILDDIR)/backobj/back/be_decompress.o: be_alloc.h be_runtime.h
  12.167 @@ -1162,6 +1174,7 @@
  12.168  $(BUILDDIR)/backobj/back/be_execute.o: be_inline.h be_machine.h be_task.h
  12.169  $(BUILDDIR)/backobj/back/be_execute.o: be_rterror.h be_symtab.h be_w.h
  12.170  $(BUILDDIR)/backobj/back/be_execute.o: be_callc.h be_coverage.h be_execute.h
  12.171 +$(BUILDDIR)/backobj/back/be_execute.o: be_debug.h be_memstruct.h
  12.172  $(BUILDDIR)/backobj/back/be_inline.o: alldefs.h global.h object.h symtab.h
  12.173  $(BUILDDIR)/backobj/back/be_inline.o: execute.h reswords.h be_alloc.h
  12.174  $(BUILDDIR)/backobj/back/be_machine.o: global.h object.h symtab.h alldefs.h
  12.175 @@ -1175,9 +1188,12 @@
  12.176  $(BUILDDIR)/backobj/back/be_main.o: execute.h reswords.h be_runtime.h
  12.177  $(BUILDDIR)/backobj/back/be_main.o: be_execute.h be_alloc.h be_rterror.h
  12.178  $(BUILDDIR)/backobj/back/be_main.o: be_w.h
  12.179 -$(BUILDDIR)/backobj/back/be_pcre.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.180 -$(BUILDDIR)/backobj/back/be_pcre.o: be_alloc.h  execute.h reswords.h be_alloc.h
  12.181 -$(BUILDDIR)/backobj/back/be_pcre.o: be_alloc.h  be_runtime.h be_pcre.h pcre/pcre.h
  12.182 +$(BUILDDIR)/backobj/back/be_memstruct.o: execute.h global.h object.h symtab.h
  12.183 +$(BUILDDIR)/backobj/back/be_memstruct.o: reswords.h be_alloc.h be_machine.h
  12.184 +$(BUILDDIR)/backobj/back/be_memstruct.o: be_memstruct.h be_runtime.h
  12.185 +$(BUILDDIR)/backobj/back/be_pcre.o: alldefs.h global.h object.h symtab.h
  12.186 +$(BUILDDIR)/backobj/back/be_pcre.o: execute.h reswords.h be_alloc.h
  12.187 +$(BUILDDIR)/backobj/back/be_pcre.o: be_runtime.h be_pcre.h pcre/pcre.h
  12.188  $(BUILDDIR)/backobj/back/be_pcre.o: be_machine.h
  12.189  $(BUILDDIR)/backobj/back/be_rterror.o: alldefs.h global.h object.h symtab.h
  12.190  $(BUILDDIR)/backobj/back/be_rterror.o: execute.h reswords.h be_rterror.h
  12.191 @@ -1203,23 +1219,23 @@
  12.192  $(BUILDDIR)/backobj/back/be_task.o: reswords.h be_runtime.h be_task.h
  12.193  $(BUILDDIR)/backobj/back/be_task.o: be_alloc.h be_machine.h be_execute.h
  12.194  $(BUILDDIR)/backobj/back/be_task.o: be_symtab.h alldefs.h
  12.195 -$(BUILDDIR)/backobj/back/be_w.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.196 -$(BUILDDIR)/backobj/back/be_w.o: be_alloc.h  execute.h reswords.h be_w.h be_machine.h
  12.197 -$(BUILDDIR)/backobj/back/be_w.o: be_alloc.h  be_runtime.h be_rterror.h be_alloc.h
  12.198 +$(BUILDDIR)/backobj/back/be_w.o: alldefs.h global.h object.h symtab.h
  12.199 +$(BUILDDIR)/backobj/back/be_w.o: execute.h reswords.h be_w.h be_machine.h
  12.200 +$(BUILDDIR)/backobj/back/be_w.o: be_runtime.h be_rterror.h be_alloc.h
  12.201  $(BUILDDIR)/backobj/back/rbt.o: rbt.h
  12.202  
  12.203 -$(BUILDDIR)/libobj/back/be_alloc.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.204 -$(BUILDDIR)/libobj/back/be_alloc.o: be_alloc.h  execute.h reswords.h be_runtime.h
  12.205 -$(BUILDDIR)/libobj/back/be_alloc.o: be_alloc.h  be_alloc.h
  12.206 +$(BUILDDIR)/libobj/back/be_alloc.o: alldefs.h global.h object.h symtab.h
  12.207 +$(BUILDDIR)/libobj/back/be_alloc.o: execute.h reswords.h be_runtime.h
  12.208 +$(BUILDDIR)/libobj/back/be_alloc.o: be_alloc.h
  12.209  $(BUILDDIR)/libobj/back/be_callc.o: alldefs.h global.h object.h symtab.h
  12.210  $(BUILDDIR)/libobj/back/be_callc.o: execute.h reswords.h be_runtime.h
  12.211  $(BUILDDIR)/libobj/back/be_callc.o: be_machine.h be_alloc.h
  12.212  $(BUILDDIR)/libobj/back/be_coverage.o: be_coverage.h be_machine.h global.h
  12.213  $(BUILDDIR)/libobj/back/be_coverage.o: object.h symtab.h execute.h
  12.214  $(BUILDDIR)/libobj/back/be_debug.o: execute.h global.h object.h symtab.h
  12.215 -$(BUILDDIR)/libobj/back/be_debug.o: be_alloc.h be_debug.h be_execute.h
  12.216 -$(BUILDDIR)/libobj/back/be_debug.o: be_machine.h be_rterror.h be_runtime.h
  12.217 -$(BUILDDIR)/libobj/back/be_debug.o: reswords.h
  12.218 +$(BUILDDIR)/libobj/back/be_debug.o: redef.h reswords.h be_alloc.h be_debug.h
  12.219 +$(BUILDDIR)/libobj/back/be_debug.o: be_execute.h be_machine.h be_rterror.h
  12.220 +$(BUILDDIR)/libobj/back/be_debug.o: be_runtime.h be_symtab.h
  12.221  $(BUILDDIR)/libobj/back/be_decompress.o: alldefs.h global.h object.h symtab.h
  12.222  $(BUILDDIR)/libobj/back/be_decompress.o: execute.h reswords.h be_alloc.h
  12.223  $(BUILDDIR)/libobj/back/be_decompress.o: be_runtime.h
  12.224 @@ -1229,6 +1245,7 @@
  12.225  $(BUILDDIR)/libobj/back/be_execute.o: be_inline.h be_machine.h be_task.h
  12.226  $(BUILDDIR)/libobj/back/be_execute.o: be_rterror.h be_symtab.h be_w.h
  12.227  $(BUILDDIR)/libobj/back/be_execute.o: be_callc.h be_coverage.h be_execute.h
  12.228 +$(BUILDDIR)/libobj/back/be_execute.o: be_debug.h be_memstruct.h
  12.229  $(BUILDDIR)/libobj/back/be_inline.o: alldefs.h global.h object.h symtab.h
  12.230  $(BUILDDIR)/libobj/back/be_inline.o: execute.h reswords.h be_alloc.h
  12.231  $(BUILDDIR)/libobj/back/be_machine.o: global.h object.h symtab.h alldefs.h
  12.232 @@ -1242,9 +1259,12 @@
  12.233  $(BUILDDIR)/libobj/back/be_main.o: execute.h reswords.h be_runtime.h
  12.234  $(BUILDDIR)/libobj/back/be_main.o: be_execute.h be_alloc.h be_rterror.h
  12.235  $(BUILDDIR)/libobj/back/be_main.o: be_w.h
  12.236 -$(BUILDDIR)/libobj/back/be_pcre.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.237 -$(BUILDDIR)/libobj/back/be_pcre.o: be_alloc.h  execute.h reswords.h be_alloc.h
  12.238 -$(BUILDDIR)/libobj/back/be_pcre.o: be_alloc.h  be_runtime.h be_pcre.h pcre/pcre.h
  12.239 +$(BUILDDIR)/libobj/back/be_memstruct.o: execute.h global.h object.h symtab.h
  12.240 +$(BUILDDIR)/libobj/back/be_memstruct.o: reswords.h be_alloc.h be_machine.h
  12.241 +$(BUILDDIR)/libobj/back/be_memstruct.o: be_memstruct.h be_runtime.h
  12.242 +$(BUILDDIR)/libobj/back/be_pcre.o: alldefs.h global.h object.h symtab.h
  12.243 +$(BUILDDIR)/libobj/back/be_pcre.o: execute.h reswords.h be_alloc.h
  12.244 +$(BUILDDIR)/libobj/back/be_pcre.o: be_runtime.h be_pcre.h pcre/pcre.h
  12.245  $(BUILDDIR)/libobj/back/be_pcre.o: be_machine.h
  12.246  $(BUILDDIR)/libobj/back/be_rterror.o: alldefs.h global.h object.h symtab.h
  12.247  $(BUILDDIR)/libobj/back/be_rterror.o: execute.h reswords.h be_rterror.h
  12.248 @@ -1270,7 +1290,7 @@
  12.249  $(BUILDDIR)/libobj/back/be_task.o: reswords.h be_runtime.h be_task.h
  12.250  $(BUILDDIR)/libobj/back/be_task.o: be_alloc.h be_machine.h be_execute.h
  12.251  $(BUILDDIR)/libobj/back/be_task.o: be_symtab.h alldefs.h
  12.252 -$(BUILDDIR)/libobj/back/be_w.o: be_alloc.h  alldefs.h global.h object.h symtab.h
  12.253 -$(BUILDDIR)/libobj/back/be_w.o: be_alloc.h  execute.h reswords.h be_w.h be_machine.h
  12.254 -$(BUILDDIR)/libobj/back/be_w.o: be_alloc.h  be_runtime.h be_rterror.h be_alloc.h
  12.255 +$(BUILDDIR)/libobj/back/be_w.o: alldefs.h global.h object.h symtab.h
  12.256 +$(BUILDDIR)/libobj/back/be_w.o: execute.h reswords.h be_w.h be_machine.h
  12.257 +$(BUILDDIR)/libobj/back/be_w.o: be_runtime.h be_rterror.h be_alloc.h
  12.258  $(BUILDDIR)/libobj/back/rbt.o: rbt.h

    13.1 --- a/source/Makefile.wat	Mon Dec 19 23:19:58 2011 -0300
    13.2 +++ b/source/Makefile.wat	Wed Dec 21 16:45:49 2011 -0300
    13.3 @@ -120,6 +120,7 @@
    13.4  	inline.e &
    13.5  	keylist.e &
    13.6  	main.e &
    13.7 +	memstruct.e &
    13.8  	msgtext.e &
    13.9  	mode.e &
   13.10  	opnames.e &
   13.11 @@ -176,6 +177,7 @@
   13.12  	$(BUILDDIR)\$(OBJDIR)\back\be_syncolor.obj &
   13.13  	$(BUILDDIR)\$(OBJDIR)\back\be_task.obj &
   13.14  	$(BUILDDIR)\$(OBJDIR)\back\be_w.obj &
   13.15 +	$(BUILDDIR)\$(OBJDIR)\back\be_memstruct.obj &
   13.16  	$(PCRE_OBJECTS)
   13.17  
   13.18  EU_LIB_OBJECTS = &
   13.19 @@ -800,7 +802,8 @@
   13.20  $(BUILDDIR)\$(OBJDIR)\back\be_symtab.obj : be_symtab.c *.h $(CONFIG) 
   13.21  $(BUILDDIR)\$(OBJDIR)\back\be_w.obj : be_w.c *.h $(CONFIG) 
   13.22  $(BUILDDIR)\$(OBJDIR)\back\be_socket.obj : be_socket.c *.h $(CONFIG)
   13.23 -$(BUILDDIR)\$(OBJDIR)\back\be_pcre.obj : be_pcre.c *.h $(CONFIG) 
   13.24 +$(BUILDDIR)\$(OBJDIR)\back\be_pcre.obj : be_pcre.c *.h $(CONFIG)
   13.25 +$(BUILDDIR)\$(OBJDIR)\back\be_memstruct.obj : be_memstruct.c *.h $(CONFIG) 
   13.26  
   13.27  # end of OBJDIR exists
   13.28  !endif

    14.1 --- a/source/backend.e	Mon Dec 19 23:19:58 2011 -0300
    14.2 +++ b/source/backend.e	Wed Dec 21 16:45:49 2011 -0300
    14.3 @@ -109,35 +109,52 @@
    14.4  			if eentry[S_MODE] = M_NORMAL then
    14.5  				-- vars and routines
    14.6  				
    14.7 -				if find(eentry[S_TOKEN], RTN_TOKS) then
    14.8 -					-- routines only
    14.9 -					if sequence(eentry[S_CODE]) and (get_backend() or eentry[S_OPCODE]=0) then  
   14.10 -						-- routines with code
   14.11 -						e_addr = allocate( sizeof( C_POINTER ) * (length(eentry[S_CODE]) + 1 ) ) -- IL code
   14.12 -						poke_pointer(e_addr, length(eentry[S_CODE]))
   14.13 -						poke_pointer(e_addr + sizeof( C_POINTER ), eentry[S_CODE])
   14.14 -						poke_pointer(addr + ST_CODE, e_addr)
   14.15 +				switch eentry[S_TOKEN] do
   14.16 +					case PROC, FUNC, TYPE then
   14.17 +						-- routines only
   14.18 +						if sequence(eentry[S_CODE]) and (get_backend() or eentry[S_OPCODE]=0) then  
   14.19 +							-- routines with code
   14.20 +							e_addr = allocate( sizeof( C_POINTER ) * (length(eentry[S_CODE]) + 1 ) ) -- IL code
   14.21 +							poke_pointer(e_addr, length(eentry[S_CODE]))
   14.22 +							poke_pointer(e_addr + sizeof( C_POINTER ), eentry[S_CODE])
   14.23 +							poke_pointer(addr + ST_CODE, e_addr)
   14.24 +						
   14.25 +							if sequence(eentry[S_LINETAB]) then
   14.26 +								-- line table
   14.27 +								l_addr = allocate( 4 * length(eentry[S_LINETAB])) 
   14.28 +								poke4(l_addr, eentry[S_LINETAB])
   14.29 +								poke_pointer(addr + ST_LINETAB, l_addr)
   14.30 +							else
   14.31 +								-- pointer to linetable will be NULL
   14.32 +							end if
   14.33 +						end if
   14.34 +						poke4(addr + ST_FIRSTLINE, eentry[S_FIRSTLINE])
   14.35 +						poke_pointer(addr + ST_TEMPS, eentry[S_TEMPS])
   14.36 +						poke4(addr + ST_NUM_ARGS, eentry[S_NUM_ARGS])
   14.37 +						--
   14.38 +						--
   14.39 +						poke4(addr + ST_STACK_SPACE, eentry[S_STACK_SPACE])
   14.40 +						poke_pointer(addr + ST_BLOCK, eentry[S_BLOCK])
   14.41  					
   14.42 -						if sequence(eentry[S_LINETAB]) then
   14.43 -							-- line table
   14.44 -							l_addr = allocate( 4 * length(eentry[S_LINETAB])) 
   14.45 -							poke4(l_addr, eentry[S_LINETAB])
   14.46 -							poke_pointer(addr + ST_LINETAB, l_addr)
   14.47 -						else
   14.48 -							-- pointer to linetable will be NULL
   14.49 +					case MEMSTRUCT, MEMUNION, MEMTYPE, MS_MEMBER, 
   14.50 +							MS_OBJECT, MS_CHAR, MS_SHORT, MS_INT,
   14.51 +							MS_LONG, MS_LONGLONG, 
   14.52 +							MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
   14.53 +						if SIZEOF_MEMSTRUCT_ENTRY = length( eentry ) then
   14.54 +							poke_pointer( addr + ST_MEM_NEXT, eentry[S_MEM_NEXT] )
   14.55 +							poke_pointer( addr + ST_MEM_STRUCT, eentry[S_MEM_STRUCT] )
   14.56 +							poke_pointer( addr + ST_MEM_PARENT, eentry[S_MEM_PARENT] )
   14.57 +							
   14.58 +							poke4( addr + ST_MEM_SIZE, eentry[S_MEM_SIZE] )
   14.59 +							poke4( addr + ST_MEM_OFFSET, eentry[S_MEM_OFFSET] )
   14.60 +							poke4( addr + ST_MEM_ARRAY, eentry[S_MEM_ARRAY] )
   14.61 +							poke( addr + ST_MEM_SIGNED, eentry[S_MEM_SIGNED] )
   14.62 +							poke( addr + ST_MEM_POINTER, eentry[S_MEM_POINTER] )
   14.63  						end if
   14.64 -					end if
   14.65 -					poke4(addr + ST_FIRSTLINE, eentry[S_FIRSTLINE])
   14.66 -					poke_pointer(addr + ST_TEMPS, eentry[S_TEMPS])
   14.67 -					poke4(addr + ST_NUM_ARGS, eentry[S_NUM_ARGS])
   14.68 -					--
   14.69 -					--
   14.70 -					poke4(addr + ST_STACK_SPACE, eentry[S_STACK_SPACE])
   14.71 -					poke_pointer(addr + ST_BLOCK, eentry[S_BLOCK])
   14.72 -					
   14.73 -				else
   14.74 -					poke_pointer(addr + ST_DECLARED_IN, eentry[S_BLOCK] )
   14.75 -				end if
   14.76 +						
   14.77 +					case else
   14.78 +						poke_pointer(addr + ST_DECLARED_IN, eentry[S_BLOCK] )
   14.79 +				end switch
   14.80  				
   14.81  			elsif eentry[S_MODE] = M_BLOCK then
   14.82  				poke_pointer(addr + ST_NEXT_IN_BLOCK, eentry[S_NEXT_IN_BLOCK] )
   14.83 @@ -146,7 +163,8 @@
   14.84  					poke4(addr + ST_FIRST_LINE, eentry[S_FIRST_LINE] )
   14.85  					poke4(addr + ST_LAST_LINE, eentry[S_LAST_LINE] )
   14.86  				end if
   14.87 -				
   14.88 +			
   14.89 +			
   14.90  			elsif (length(eentry) < S_NAME and eentry[S_MODE] = M_CONSTANT) or
   14.91  			(length(eentry) >= S_TOKEN and compare( eentry[S_OBJ], NOVALUE )) then
   14.92  				-- compress constants and literal values in memory
   14.93 @@ -287,6 +305,7 @@
   14.94  			routine_id( "write_coverage_db" ),
   14.95  			routine_id( "DisplayColorLine" ),
   14.96  			external_debugger_ptr,
   14.97 +			trace_lines,
   14.98  			$
   14.99  		})
  14.100  end procedure

    15.1 --- a/source/be_execute.c	Mon Dec 19 23:19:58 2011 -0300
    15.2 +++ b/source/be_execute.c	Wed Dec 21 16:45:49 2011 -0300
    15.3 @@ -73,6 +73,7 @@
    15.4  #include "be_coverage.h"
    15.5  #include "be_execute.h"
    15.6  #include "be_debug.h"
    15.7 +#include "be_memstruct.h"
    15.8  
    15.9  /******************/
   15.10  /* Local defines  */
   15.11 @@ -959,7 +960,7 @@
   15.12  void code_set_pointers(intptr_t **code)
   15.13  /* adjust code pointers, changing some indexes into pointers */
   15.14  {
   15.15 -	intptr_t len, i, j, n, sub, word;
   15.16 +	intptr_t len, i, j, n, sub, word, array;
   15.17  
   15.18  	len = (intptr_t) code[0];
   15.19  	i = 1;
   15.20 @@ -1017,6 +1018,7 @@
   15.21  			case DEREF_TEMP:
   15.22  			case REF_TEMP:
   15.23  			case NOVALUE_TEMP:
   15.24 +			case MEM_TYPE_CHECK:
   15.25  				// one operand
   15.26  				code[i+1] = SET_OPERAND(code[i+1]);
   15.27  				i += 2;
   15.28 @@ -1060,6 +1062,8 @@
   15.29  			case RAND:
   15.30  			case PEEK:
   15.31  			case SIZEOF:
   15.32 +			case ADDRESSOF:
   15.33 +			case OFFSETOF:
   15.34  			case PEEK_STRING:
   15.35  			case PEEKS:
   15.36  			case FLOOR:
   15.37 @@ -1165,13 +1169,31 @@
   15.38  			case TAIL:
   15.39  			case DELETE_ROUTINE:
   15.40  			case RETURNF:
   15.41 +			case MEMSTRUCT_READ:
   15.42  				// 3 operands follow
   15.43  				code[i+1] = SET_OPERAND(code[i+1]);
   15.44  				code[i+2] = SET_OPERAND(code[i+2]);
   15.45  				code[i+3] = SET_OPERAND(code[i+3]);
   15.46  				i += 4;
   15.47  				break;
   15.48 -
   15.49 +			case MEMSTRUCT_PLUS:
   15.50 +			case MEMSTRUCT_MINUS:
   15.51 +			case MEMSTRUCT_DIVIDE:
   15.52 +			case MEMSTRUCT_MULTIPLY:
   15.53 +			case MEMSTRUCT_ASSIGN:
   15.54 +				// 3 operands follow
   15.55 +				code[i+1] = SET_OPERAND(code[i+1]);
   15.56 +				code[i+2] = SET_OPERAND(code[i+2]);
   15.57 +				code[i+3] = SET_OPERAND(code[i+3]);
   15.58 +				i += 5;
   15.59 +				break;
   15.60 +			case PEEK_MEMBER:
   15.61 +				// 3 operands follow
   15.62 +				code[i+1] = SET_OPERAND(code[i+1]);
   15.63 +				code[i+2] = SET_OPERAND(code[i+2]);
   15.64 +				code[i+4] = SET_OPERAND(code[i+4]);
   15.65 +				i += 5;
   15.66 +				break;
   15.67  			case SC1_AND_IF:
   15.68  			case SC1_OR_IF:
   15.69  			case SC1_AND:
   15.70 @@ -1217,6 +1239,8 @@
   15.71  			case INSERT:
   15.72  			case REMOVE:
   15.73  			case OPEN:
   15.74 +			case MEMSTRUCT_ARRAY:
   15.75 +			case PEEK_ARRAY:
   15.76  				// 4 operands follow
   15.77  				code[i+1] = SET_OPERAND(code[i+1]);
   15.78  				code[i+2] = SET_OPERAND(code[i+2]);
   15.79 @@ -1328,7 +1352,25 @@
   15.80  
   15.81  				i += n + 3;
   15.82  				break;
   15.83 -
   15.84 +			case MEMSTRUCT_ACCESS:
   15.85 +			case ARRAY_ACCESS:
   15.86 +				n = (intptr_t)code[i+1] + 1;
   15.87 +				array = (word == ARRAY_ACCESS);
   15.88 +				for (j = 1; j <= n; j++) {
   15.89 +					word = (intptr_t)code[i+1+j];
   15.90 +					code[i+1+j] = SET_OPERAND(word);
   15.91 +				}
   15.92 +				
   15.93 +				word = (intptr_t)code[i+n+2];
   15.94 +				
   15.95 +				code[i+n+2] = SET_OPERAND(word);
   15.96 +				if( array ){
   15.97 +					word = (intptr_t)code[i+n+3];
   15.98 +					code[i+n+3] = SET_OPERAND( word );
   15.99 +				}
  15.100 +				
  15.101 +				i += n + 3 + array;
  15.102 +				break;
  15.103  			default:
  15.104  				RTFatal("UNKNOWN IL OPCODE");
  15.105  		}
  15.106 @@ -1374,6 +1416,15 @@
  15.107  				}
  15.108  				s->u.subp.block = (symtab_ptr)SET_OPERAND( s->u.subp.block );
  15.109  			}
  15.110 +			else if(s->token == MEMSTRUCT ||
  15.111 +					s->token == MEMUNION  ||
  15.112 +					s->token == MS_MEMBER ){
  15.113 +				
  15.114 +				s->u.memstruct.next        = (symtab_ptr)SET_OPERAND( s->u.memstruct.next );
  15.115 +				s->u.memstruct.struct_type = (symtab_ptr)SET_OPERAND( s->u.memstruct.struct_type );
  15.116 +				s->u.memstruct.parent      = (symtab_ptr)SET_OPERAND( s->u.memstruct.parent );
  15.117 +				
  15.118 +			}
  15.119  			else{
  15.120  				s->u.var.declared_in = (symtab_ptr)SET_OPERAND( s->u.var.declared_in );
  15.121  			}
  15.122 @@ -1399,6 +1450,7 @@
  15.123  			// M_TEMP - temps
  15.124  			// leave obj as 0
  15.125  		}
  15.126 +		
  15.127  		s++;
  15.128  	}
  15.129  }
  15.130 @@ -1816,8 +1868,17 @@
  15.131  /* 214 (previous) */
  15.132    &&L_POKE_POINTER, &&L_PEEK_POINTER,
  15.133  /* 215 (previous) */
  15.134 -  &&L_SIZEOF, &&L_STARTLINE_BREAK
  15.135 -  };
  15.136 +  &&L_SIZEOF, &&L_STARTLINE_BREAK,
  15.137 +  
  15.138 +  &&L_MEMSTRUCT_ACCESS, &&L_MEMSTRUCT_ARRAY, &&L_PEEK_MEMBER,
  15.139 +  &&L_MEMSTRUCT_READ, &&L_MEMSTRUCT_ASSIGN, &&L_MEMSTRUCT_PLUS,
  15.140 +  &&L_MEMSTRUCT_MINUS, &&L_MEMSTRUCT_MULTIPLY, &&L_MEMSTRUCT_DIVIDE,
  15.141 +  &&L_MEM_TYPE_CHECK, &&L_ADDRESSOF, &&L_OFFSETOF, &&L_PEEK_ARRAY,
  15.142 +  &&L_ARRAY_ACCESS
  15.143 +/* 232 (previous) */
  15.144 +  
  15.145 +
  15.146 +	};
  15.147  #endif
  15.148  #endif
  15.149  	if (start_pc == NULL) {
  15.150 @@ -2485,7 +2546,7 @@
  15.151  				BREAK;
  15.152  
  15.153  			case L_TYPE_CHECK: /* top has TRUE/FALSE */
  15.154 -			deprintf("case L_TYPE_CHECK:");
  15.155 +				deprintf("case L_TYPE_CHECK:");
  15.156  				/* type check for a user-defined type */
  15.157  				/* this always follows a type-call */
  15.158  				top = *(object_ptr)pc[-1];
  15.159 @@ -2509,6 +2570,29 @@
  15.160  				}
  15.161  				BREAK;
  15.162  
  15.163 +			case L_MEM_TYPE_CHECK:
  15.164 +				deprintf("case L_MEM_TYPE_CHECK:");
  15.165 +				top = *(object_ptr)pc[-1];
  15.166 +				pc += 2;
  15.167 +				if (top == ATOM_1) {
  15.168 +					thread();
  15.169 +					BREAK;  /* usual case L_*/
  15.170 +				}
  15.171 +				else if (IS_ATOM_INT(top)) {
  15.172 +					if (top == ATOM_0)
  15.173 +						RTFatalMemType(pc-4, pc[-1]);
  15.174 +				}
  15.175 +				else if (IS_ATOM_DBL(top)) {
  15.176 +					if (DBL_PTR(top)->dbl == 0.0)
  15.177 +						RTFatalMemType(pc-4, pc[-1]);
  15.178 +				}
  15.179 +				else  {/* sequence */
  15.180 +					type_error_msg =
  15.181 +						"\ntype_check failure (type returned a sequence!), ";
  15.182 +					RTFatalMemType(pc-4, pc[-1]);
  15.183 +				}
  15.184 +				BREAK;
  15.185 +				
  15.186  			case L_NOP2:
  15.187  			deprintf("case L_NOP2:");
  15.188  				thread2();
  15.189 @@ -4528,10 +4612,62 @@
  15.190  				BREAK;
  15.191  
  15.192  			case L_SIZEOF:
  15.193 -				a = *(object_ptr)pc[1]; /* the data type */
  15.194 +				tpc = pc;  // in case of machine exception
  15.195  				top = *(object_ptr)pc[2];
  15.196 -				tpc = pc;  // in case of machine exception
  15.197 -				*(object_ptr)pc[2] = eu_sizeof( a );
  15.198 +				if( ((symtab_ptr)pc[1])->token == MEMSTRUCT ||
  15.199 +					((symtab_ptr)pc[1])->token == MEMUNION ||
  15.200 +					((symtab_ptr)pc[1])->token == MS_MEMBER ||
  15.201 +					((symtab_ptr)pc[1])->token == MEMTYPE
  15.202 +				){
  15.203 +					*(object_ptr)pc[2] = ((symtab_ptr)pc[1])->u.memstruct.size;
  15.204 +				}
  15.205 +				else if( ((symtab_ptr)pc[1])->token == MS_CHAR       ){ *(object_ptr)pc[2] = sizeof( char ); }
  15.206 +				else if( ((symtab_ptr)pc[1])->token == MS_SHORT      ){ *(object_ptr)pc[2] = sizeof( short ); }
  15.207 +				else if( ((symtab_ptr)pc[1])->token == MS_INT        ){ *(object_ptr)pc[2] = sizeof( int ); }
  15.208 +				else if( ((symtab_ptr)pc[1])->token == MS_LONG       ){ *(object_ptr)pc[2] = sizeof( long ); }
  15.209 +				else if( ((symtab_ptr)pc[1])->token == MS_LONGLONG   ){ *(object_ptr)pc[2] = sizeof( long long ); }
  15.210 +				else if( ((symtab_ptr)pc[1])->token == MS_OBJECT     ){ *(object_ptr)pc[2] = sizeof( void * ); }
  15.211 +				else if( ((symtab_ptr)pc[1])->token == MS_FLOAT      ){ *(object_ptr)pc[2] = sizeof( float ); }
  15.212 +				else if( ((symtab_ptr)pc[1])->token == MS_DOUBLE     ){ *(object_ptr)pc[2] = sizeof( double ); }
  15.213 +				else if( ((symtab_ptr)pc[1])->token == MS_LONGDOUBLE ){ *(object_ptr)pc[2] = sizeof( long double ); }
  15.214 +				else if( ((symtab_ptr)pc[1])->token == MS_EUDOUBLE   ){ *(object_ptr)pc[2] = sizeof( eudouble ); }
  15.215 +				else{
  15.216 +					
  15.217 +					a = *(object_ptr)pc[1]; /* the data type */
  15.218 +					*(object_ptr)pc[2] = eu_sizeof( a );
  15.219 +				}
  15.220 +				DeRef( top );
  15.221 +				inc3pc();
  15.222 +				thread();
  15.223 +				BREAK;
  15.224 +			
  15.225 +			case L_ADDRESSOF:
  15.226 +				deprintf("case L_ADDRESSOF:");
  15.227 +				tpc = pc;
  15.228 +				top = *(object_ptr)pc[2];
  15.229 +#if INTPTR_MAX == INT32_MAX
  15.230 +				if ( (uintptr_t)*(object_ptr)pc[1] > (uintptr_t)MAXINT){
  15.231 +					top = NewDouble((eudouble) *(object_ptr)pc[1]);
  15.232 +				}
  15.233 +				else{
  15.234 +					*(object_ptr)pc[2] = *(object_ptr)pc[1];
  15.235 +				}
  15.236 +#else
  15.237 +				// 64-bit ptr always fits in an eu integer
  15.238 +				*(object_ptr)pc[2] = *(object_ptr)pc[1];
  15.239 +#endif
  15.240 +				Ref( *(object_ptr)pc[2] );
  15.241 +				DeRef( top );
  15.242 +				inc3pc();
  15.243 +				thread();
  15.244 +				BREAK;
  15.245 +				
  15.246 +			case L_OFFSETOF:
  15.247 +				deprintf("case L_ADDRESSOF:");
  15.248 +				tpc = pc;
  15.249 +				top = *(object_ptr)pc[2];
  15.250 +				*(object_ptr)pc[2] = ((symtab_ptr)pc[1])->u.memstruct.offset;
  15.251 +				Ref( *(object_ptr)pc[2] );
  15.252  				DeRef( top );
  15.253  				inc3pc();
  15.254  				thread();
  15.255 @@ -5282,6 +5418,112 @@
  15.256  				thread2();
  15.257  				BREAK;
  15.258  
  15.259 +			case L_MEMSTRUCT_ASSIGN:
  15.260 +				deprintf("case L_MEMSTRUCT_ASSIGN");
  15.261 +				tpc = pc;
  15.262 +				
  15.263 +				sym = (symtab_ptr) pc[2];
  15.264 +				if( sym->u.memstruct.pointer && !pc[4] ){
  15.265 +					poke_member( (object_ptr) pc[1], sym, (object_ptr) pc[3], 0 );
  15.266 +				}
  15.267 +				else if( sym->token == MEMSTRUCT ){
  15.268 +					write_member( (object_ptr) pc[1], sym, (object_ptr) pc[3], pc[4] );
  15.269 +				}
  15.270 +				else if( sym->token == MEMUNION ){
  15.271 +					write_union( (object_ptr) pc[1], sym, (object_ptr) pc[3], pc[4] );
  15.272 +				}
  15.273 +				else{
  15.274 +					poke_member( (object_ptr) pc[1], sym, (object_ptr) pc[3], pc[4] );
  15.275 +				}
  15.276 +				thread5();
  15.277 +				BREAK;
  15.278 +				
  15.279 +			case L_MEMSTRUCT_PLUS:
  15.280 +				deprintf("case LMEMSTRUCT_PLUS");
  15.281 +				a = MEMSTRUCT_PLUS;
  15.282 +				goto mem_assign_op;
  15.283 +				
  15.284 +			case L_MEMSTRUCT_MINUS:
  15.285 +				deprintf("case LMEMSTRUCT_MINUS");
  15.286 +				a = MEMSTRUCT_MINUS;
  15.287 +				goto mem_assign_op;
  15.288 +				
  15.289 +			case L_MEMSTRUCT_DIVIDE:
  15.290 +				deprintf("case LMEMSTRUCT_DIVIDE");
  15.291 +				a = MEMSTRUCT_DIVIDE;
  15.292 +				goto mem_assign_op;
  15.293 +				
  15.294 +			case L_MEMSTRUCT_MULTIPLY:
  15.295 +				deprintf("case LMEMSTRUCT_MULTIPLY");
  15.296 +				a = MEMSTRUCT_MULTIPLY;
  15.297 +				
  15.298 +				mem_assign_op:
  15.299 +				tpc = pc;
  15.300 +				memstruct_assignop( a, (object_ptr)pc[1], (symtab_ptr) pc[2], (object_ptr) pc[3], pc[4] );
  15.301 +				thread5();
  15.302 +				BREAK;
  15.303 +				
  15.304 +			case L_MEMSTRUCT_READ:
  15.305 +				deprintf("case L_MEMSTRUCT_READ");
  15.306 +				tpc = pc;
  15.307 +				a = read_memstruct( (object_ptr) pc[1], 0, (symtab_ptr) pc[2] );
  15.308 +				obj_ptr = (object_ptr) pc[3];
  15.309 +				DeRef( *obj_ptr );
  15.310 +				*obj_ptr = a;
  15.311 +				thread4();
  15.312 +				BREAK;
  15.313 +			case L_PEEK_MEMBER:
  15.314 +				deprintf("case L_PEEK_MEMBER");
  15.315 +				tpc = pc;
  15.316 +				a = peek_member( (object_ptr) pc[1], (symtab_ptr) pc[2], -1, 0, pc[3] );
  15.317 +				obj_ptr = (object_ptr) pc[4];
  15.318 +				DeRef( *obj_ptr );
  15.319 +				*obj_ptr = a;
  15.320 +				thread5();
  15.321 +				BREAK;
  15.322 +				
  15.323 +			case L_MEMSTRUCT_ACCESS:
  15.324 +				deprintf("case L_MEMSTRUCT_ACCESS");
  15.325 +				tpc = pc;
  15.326 +				b = pc[1];
  15.327 +				a = memstruct_access( b, (object_ptr) pc[2], (symtab_ptr *) pc + 3 );
  15.328 +				obj_ptr = (object_ptr) pc[b+3];
  15.329 +				DeRef( *obj_ptr );
  15.330 +				*obj_ptr = a;
  15.331 +				pc += b + 4;
  15.332 +				thread();
  15.333 +				BREAK;
  15.334 +			case L_ARRAY_ACCESS:
  15.335 +				deprintf("case L_ARRAY_ACCESS");
  15.336 +				tpc = pc;
  15.337 +				b = pc[1];
  15.338 +				a = array_access( b, (object_ptr) pc[2], (symtab_ptr *) pc + 3,  (symtab_ptr) pc[4]);
  15.339 +				obj_ptr = (object_ptr) pc[b+4];
  15.340 +				DeRef( *obj_ptr );
  15.341 +				*obj_ptr = a;
  15.342 +				pc += b + 5;
  15.343 +				thread();
  15.344 +				BREAK;
  15.345 +			case L_MEMSTRUCT_ARRAY:
  15.346 +				deprintf("case L_MEMSTRUCT_ARRAY");
  15.347 +				tpc = pc;
  15.348 +				a = memstruct_array( (object_ptr)pc[1], (symtab_ptr)pc[2], (object_ptr)pc[3] );
  15.349 +				obj_ptr = (object_ptr) pc[4];
  15.350 +				DeRef( *obj_ptr );
  15.351 +				*obj_ptr = a;
  15.352 +				thread5();
  15.353 +				BREAK;
  15.354 +			case L_PEEK_ARRAY:
  15.355 +				deprintf("case L_PEEK_ARRAY");
  15.356 +				
  15.357 +				tpc = pc;
  15.358 +				a = peek_array( (object_ptr)pc[1], (symtab_ptr)pc[2], (object_ptr)pc[3] );
  15.359 +				obj_ptr = (object_ptr) pc[4];
  15.360 +				DeRef( *obj_ptr );
  15.361 +				*obj_ptr = a;
  15.362 +				
  15.363 +				thread5();
  15.364 +				BREAK;
  15.365  			default:
  15.366  				RTFatal("Unsupported Op Code ");
  15.367  

    16.1 --- a/source/be_machine.c	Mon Dec 19 23:19:58 2011 -0300
    16.2 +++ b/source/be_machine.c	Wed Dec 21 16:45:49 2011 -0300
    16.3 @@ -224,7 +224,7 @@
    16.4  	if (IS_ATOM_INT(x))
    16.5  		return INT_VAL(x);
    16.6  	else if (IS_ATOM(x))
    16.7 -		return (unsigned long)(DBL_PTR(x)->dbl);
    16.8 +		return (uintptr_t)(DBL_PTR(x)->dbl);
    16.9  	else {
   16.10  		RTFatal("%s: an integer was expected, not a sequence", where);
   16.11  	}
   16.12 @@ -1833,7 +1833,7 @@
   16.13  }
   16.14  #endif
   16.15  
   16.16 -static object float_to_atom(object x, int flen)
   16.17 +object float_to_atom(object x, int flen)
   16.18  /* convert a sequence of 4, 8 or 10 bytes in IEEE format to an atom */
   16.19  {
   16.20  	int len, i;
   16.21 @@ -2767,8 +2767,8 @@
   16.22  
   16.23  	x_ptr = SEQ_PTR(x);
   16.24  
   16.25 -	if (IS_ATOM(x) || x_ptr->length != 12)
   16.26 -		RTFatal("BACKEND requires a sequence of length 12");
   16.27 +	if (IS_ATOM(x) || x_ptr->length != 13)
   16.28 +		RTFatal("BACKEND requires a sequence of length 13");
   16.29  
   16.30  	fe.st = (symtab_ptr)     get_pos_int(w, *(x_ptr->base+1));
   16.31  	fe.sl = (struct sline *) get_pos_int(w, *(x_ptr->base+2));
   16.32 @@ -2786,6 +2786,7 @@
   16.33  	
   16.34  	set_debugger( (char*) get_pos_int(w, *(x_ptr->base+12)) );
   16.35  	
   16.36 +	trace_lines = get_pos_int(w, *(x_ptr->base+13));
   16.37  	// This is checked when we try to write coverage to make sure
   16.38  	// we need to output an error message.
   16.39  	in_backend = 1;

    17.1 --- a/source/be_machine.h	Mon Dec 19 23:19:58 2011 -0300
    17.2 +++ b/source/be_machine.h	Wed Dec 21 16:45:49 2011 -0300
    17.3 @@ -82,4 +82,5 @@
    17.4  						   uintptr_t arg1, uintptr_t arg2, uintptr_t arg3,
    17.5  						   uintptr_t arg4, uintptr_t arg5, uintptr_t arg6,
    17.6  						   uintptr_t arg7, uintptr_t arg8, uintptr_t arg9);
    17.7 +
    17.8  #endif

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/source/be_memstruct.c	Wed Dec 21 16:45:49 2011 -0300
    18.3 @@ -0,0 +1,666 @@
    18.4 +#include <stdint.h>
    18.5 +#include <stdio.h>
    18.6 +
    18.7 +#include "execute.h"
    18.8 +#include "object.h"
    18.9 +#include "reswords.h"
   18.10 +#include "symtab.h"
   18.11 +#include "be_alloc.h"
   18.12 +#include "be_machine.h"
   18.13 +#include "be_memstruct.h"
   18.14 +#include "be_runtime.h"
   18.15 +
   18.16 +static object read_member( void *pointer, symtab_ptr member_sym );
   18.17 +static object read_memunion( void *pointer, symtab_ptr member_sym );
   18.18 +static int memaccess = 0;
   18.19 +
   18.20 +static object box_int( intptr_t x )
   18.21 +{
   18.22 +	if(x > NOVALUE && x < TOO_BIG_INT)
   18.23 +		return (object) x;
   18.24 +	else
   18.25 +		return (object)NewDouble((eudouble)x);
   18.26 +}	
   18.27 +
   18.28 +object peek_member_value( void *pointer, int data_type, int is_signed, symtab_ptr memsym ){
   18.29 +	switch( data_type ){
   18.30 +		case MS_CHAR:
   18.31 +			if( is_signed ) return *(char*) pointer;
   18.32 +			else            return *(unsigned char*) pointer;
   18.33 +		case MS_SHORT:
   18.34 +			if( is_signed ) return *(short*) pointer;
   18.35 +			else            return *(unsigned short*) pointer;
   18.36 +		case MS_INT:
   18.37 +			if( is_signed ) return box_int( *(int*) pointer );
   18.38 +			else            return box_int( *(unsigned int*) pointer );
   18.39 +		case MS_LONG:
   18.40 +			if( is_signed ) return box_int( *(long*) pointer );
   18.41 +			else            return box_int( *(unsigned long*) pointer );
   18.42 +		case MS_LONGLONG:
   18.43 +			if( is_signed ) return box_int( *(long long int*) pointer );
   18.44 +			else            return box_int( *(unsigned long long int*) pointer );
   18.45 +		case MS_OBJECT:
   18.46 +			if( is_signed ) return box_int( *(intptr_t*) pointer );
   18.47 +			else            return box_int( *(uintptr_t*) pointer );
   18.48 +		case MS_FLOAT:
   18.49 +			return NewDouble( (eudouble) *(float*)pointer );
   18.50 +		case MS_DOUBLE:
   18.51 +			return NewDouble( (eudouble) *(double*)pointer );
   18.52 +		case MS_LONGDOUBLE:
   18.53 +			return NewDouble( (eudouble) *(long double*)pointer );
   18.54 +		default:
   18.55 +			return read_member( pointer, memsym );
   18.56 +	}
   18.57 +}
   18.58 +
   18.59 +object peek_array( object_ptr source, symtab_ptr memsym, object_ptr subscript ){
   18.60 +	uintptr_t pointer;
   18.61 +	int array_index;
   18.62 +	int data_type;
   18.63 +	char is_signed;
   18.64 +	
   18.65 +	pointer = get_pos_int( "memstruct array", *source );
   18.66 +	array_index = get_pos_int( "memstruct array subscript", *subscript );
   18.67 +	pointer += memsym->u.memstruct.offset;
   18.68 +	pointer += memsym->u.memstruct.size / memsym->u.memstruct.array * array_index;
   18.69 +	data_type = memsym->token;
   18.70 +	is_signed = memsym->u.memstruct.is_signed;
   18.71 +	if( pointer == 0 ){
   18.72 +		pointer = get_pos_int( "peek member", *source );
   18.73 +	}
   18.74 +	
   18.75 +	if( memsym->u.memstruct.pointer ){
   18.76 +		data_type = MS_OBJECT;
   18.77 +		is_signed = 0;
   18.78 +	}
   18.79 +	
   18.80 +	return peek_member_value( (void*) pointer, data_type, is_signed, memsym );
   18.81 +}
   18.82 +
   18.83 +object peek_member( object_ptr source, symtab_ptr memsym, int array_index, void *pointer, intptr_t deref_ptr ){
   18.84 +	int data_type;
   18.85 +	char is_signed;
   18.86 +	s1_ptr s;
   18.87 +	int i;
   18.88 +	
   18.89 +	data_type  = memsym->token;
   18.90 +	is_signed = memsym->u.memstruct.is_signed;
   18.91 +	if( pointer == 0 ){
   18.92 +		pointer = (void*) get_pos_int( "peek member", *source );
   18.93 +	}
   18.94 +	
   18.95 +	if( deref_ptr ){
   18.96 +		pointer = *(void**)pointer;
   18.97 +	}
   18.98 +	else if( memsym->u.memstruct.pointer ){
   18.99 +		data_type = MS_OBJECT;
  18.100 +		is_signed = 0;
  18.101 +	}
  18.102 +	else if( array_index != -1 ){
  18.103 +		uintptr_t size = memsym->u.memstruct.size;
  18.104 +		if( memsym->u.memstruct.array ){
  18.105 +			size /= memsym->u.memstruct.array;
  18.106 +		}
  18.107 +		pointer = (void*) (((intptr_t)pointer) + (array_index * size));
  18.108 +	}
  18.109 +	else if( memsym->u.memstruct.array ){
  18.110 +		s = NewS1( memsym->u.memstruct.array );
  18.111 +		for( i = 0; i < memsym->u.memstruct.array; ++i ){
  18.112 +			s->base[i+1] = peek_member( 0, memsym, i, pointer, 0 );
  18.113 +		}
  18.114 +		return MAKE_SEQ( s );
  18.115 +	}
  18.116 +	return peek_member_value( (void*)pointer, data_type, is_signed, memsym );
  18.117 +	
  18.118 +}
  18.119 +
  18.120 +static object read_member( void *pointer, symtab_ptr member_sym ){
  18.121 +	
  18.122 +	int token;
  18.123 +	
  18.124 +	token      = member_sym->token;
  18.125 +	
  18.126 +	if( token >= MS_SIGNED && token <= MS_OBJECT ){
  18.127 +		// simple serialization of primitives
  18.128 +		return peek_member( 0, member_sym, -1, pointer, 0 );
  18.129 +	}
  18.130 +	
  18.131 +	token = member_sym->token;
  18.132 +	while(1){
  18.133 +		// should only go twice through at most
  18.134 +		if( token == MEMSTRUCT ){
  18.135 +			return read_memstruct( 0, pointer, member_sym );
  18.136 +		}
  18.137 +		else if( token == MEMUNION ){
  18.138 +			return read_memunion( pointer, member_sym );
  18.139 +		}
  18.140 +		
  18.141 +		// get the member's actual struct
  18.142 +		token = member_sym->u.memstruct.struct_type->token;
  18.143 +	}
  18.144 +}
  18.145 +
  18.146 +static object read_memunion( void *pointer, symtab_ptr member_sym ){
  18.147 +	s1_ptr s;
  18.148 +	int size;
  18.149 +	int i;
  18.150 +	unsigned char *source;
  18.151 +	object_ptr target;
  18.152 +	
  18.153 +	source = (unsigned char*) pointer;
  18.154 +	size = member_sym->u.memstruct.size;
  18.155 +	s = NewS1( size );
  18.156 +	target = s->base;
  18.157 +	for( i = 1; i <= size; ++i ){
  18.158 +		*(++target) = *(source++);
  18.159 +	}
  18.160 +	return MAKE_SEQ( s );
  18.161 +}
  18.162 +
  18.163 +object read_memstruct( object_ptr source, void *pointer, symtab_ptr member_sym ){
  18.164 +	symtab_ptr sym;
  18.165 +	int size;
  18.166 +	s1_ptr s;
  18.167 +	uintptr_t src_pointer;
  18.168 +	
  18.169 +	if( pointer == 0 ){
  18.170 +		src_pointer = (uintptr_t)get_pos_int( "read memstruct", *source );
  18.171 +	}
  18.172 +	else{
  18.173 +		src_pointer = (uintptr_t) pointer;
  18.174 +	}
  18.175 +	
  18.176 +	if( member_sym->token == MEMUNION ){
  18.177 +		// Unions are handled specially
  18.178 +		int i;
  18.179 +		unsigned char *target;
  18.180 +		
  18.181 +		size = member_sym->u.memstruct.size;
  18.182 +		target = (unsigned char*) src_pointer;
  18.183 +		s = NewS1( size );
  18.184 +		for( i = 1; i <= size; ++i, ++target ){
  18.185 +			s->base[i] = (object) *target;
  18.186 +		}
  18.187 +	}
  18.188 +	else{
  18.189 +		if( member_sym->token != MEMSTRUCT ){
  18.190 +			member_sym = member_sym->u.memstruct.struct_type;
  18.191 +		}
  18.192 +		size = 0;
  18.193 +		for( sym = member_sym->u.memstruct.next; sym != 0; sym = sym->u.memstruct.next ){
  18.194 +			++size;
  18.195 +		}
  18.196 +		s = NewS1( size );
  18.197 +		size = 0;
  18.198 +		for( sym = member_sym->u.memstruct.next; sym != 0; sym = sym->u.memstruct.next ){
  18.199 +			pointer = (void*) (src_pointer + sym->u.memstruct.offset);
  18.200 +			s->base[++size] = peek_member( 0, sym, -1, pointer, 0 );
  18.201 +			
  18.202 +		}
  18.203 +	}
  18.204 +	return MAKE_SEQ( s );
  18.205 +}
  18.206 +void write_member( object_ptr source, symtab_ptr sym, object_ptr val, intptr_t deref_ptr ){
  18.207 +	s1_ptr src;
  18.208 +	int free_src;
  18.209 +	symtab_ptr member;
  18.210 +	int i;
  18.211 +	uintptr_t pointer, src_pointer;
  18.212 +	intptr_t zero;
  18.213 +	#if INTPTR_MAX == INT32_MAX
  18.214 +	struct d dbl;
  18.215 +	object dbl_ptr;
  18.216 +	dbl_ptr = MAKE_DBL( &dbl );
  18.217 +	dbl.ref = -1;
  18.218 +	#endif
  18.219 +	zero = 0;
  18.220 +	
  18.221 +	if( IS_ATOM_INT( *val ) || IS_ATOM( *val ) ){
  18.222 +		src = NewS1( 1 );
  18.223 +		src->base[1] = *val;
  18.224 +		free_src = 1;
  18.225 +	}
  18.226 +	else{
  18.227 +		src = SEQ_PTR( *val );
  18.228 +		free_src = 0;
  18.229 +	}
  18.230 +	
  18.231 +	src_pointer = (uintptr_t)get_pos_int( "write member", *source );
  18.232 +	if( deref_ptr ){
  18.233 +		src_pointer = *(uintptr_t*) src_pointer;
  18.234 +	}
  18.235 +	for( member = sym->u.memstruct.next, i = 1; member && i <= src->length; ++i, member = member->u.memstruct.next ){
  18.236 +		pointer = src_pointer + member->u.memstruct.offset;
  18.237 +		#if INTPTR_MAX == INT32_MAX
  18.238 +		if( IS_ATOM_INT( (intptr_t)pointer ) )
  18.239 +		#endif
  18.240 +			poke_member( (object_ptr)&pointer, member, src->base + i, 0 );
  18.241 +		#if INTPTR_MAX == INT32_MAX
  18.242 +		else{
  18.243 +			dbl.dbl = (eudouble) pointer;
  18.244 +			poke_member( &dbl_ptr, member, src->base + i );
  18.245 +		}
  18.246 +		#endif
  18.247 +		
  18.248 +	}
  18.249 +	
  18.250 +	// Zero out the rest...
  18.251 +	for( ; member; ++i, member = member->u.memstruct.next ){
  18.252 +		pointer = src_pointer + member->u.memstruct.offset;
  18.253 +		#if INTPTR_MAX == INT32_MAX
  18.254 +		if( IS_ATOM_INT( (intptr_t)pointer ) )
  18.255 +		#endif
  18.256 +			poke_member( (object_ptr)&pointer, member, &zero, 0);
  18.257 +		#if INTPTR_MAX == INT32_MAX
  18.258 +		else{
  18.259 +			dbl.dbl = (eudouble) pointer;
  18.260 +			poke_member( &dbl_ptr, member, &zero, 0);
  18.261 +		}
  18.262 +		#endif
  18.263 +	}
  18.264 +	
  18.265 +	if( free_src ){
  18.266 +		EFree( (char*)src );
  18.267 +	}
  18.268 +}
  18.269 +
  18.270 +
  18.271 +void write_union( object_ptr source, symtab_ptr sym, object_ptr val, intptr_t deref_ptr ){
  18.272 +	
  18.273 +	s1_ptr src;
  18.274 +	int free_src;
  18.275 +	int i;
  18.276 +	char *pointer;
  18.277 +	
  18.278 +	if( IS_ATOM_INT( *val ) || IS_ATOM( *val ) ){
  18.279 +		src = NewS1( 1 );
  18.280 +		src->base[1] = *val;
  18.281 +		free_src = 1;
  18.282 +	}
  18.283 +	else{
  18.284 +		src = SEQ_PTR( *val );
  18.285 +		free_src = 0;
  18.286 +	}
  18.287 +	
  18.288 +	pointer = (char*)get_pos_int( "write union", *source );
  18.289 +	if( deref_ptr ){
  18.290 +		pointer = *(char**) pointer;
  18.291 +	}
  18.292 +	for( i = 1; i <= src->length && i <= sym->u.memstruct.size; ++i, ++pointer ){
  18.293 +		*pointer = src->base[i];
  18.294 +	}
  18.295 +	
  18.296 +	// Zero out the rest...
  18.297 +	for( ; i <= sym->u.memstruct.size; ++i, ++pointer ){
  18.298 +		*pointer = 0;
  18.299 +	}
  18.300 +	
  18.301 +	if( free_src ){
  18.302 +		EFree( (char*)src );
  18.303 +	}
  18.304 +}
  18.305 +
  18.306 +static uintptr_t mem_access(  int access_count, object_ptr source, symtab_ptr *access_sym ){
  18.307 +	uintptr_t pointer;
  18.308 +	int i;
  18.309 +	
  18.310 +	pointer = (uintptr_t)get_pos_int( "memstruct access", *source );
  18.311 +	for( i = 0; i < access_count; ++i ){
  18.312 +		pointer += access_sym[i]->u.memstruct.offset;
  18.313 +		if( access_sym[i]->u.memstruct.pointer && (i+1) < access_count ){
  18.314 +			pointer = *(uintptr_t*)pointer;
  18.315 +		}
  18.316 +	}
  18.317 +	return pointer;
  18.318 +}
  18.319 +object memstruct_access( int access_count, object_ptr source, symtab_ptr *access_sym ){
  18.320 +	uintptr_t pointer;
  18.321 +	memaccess = MEMSTRUCT_ACCESS;
  18.322 +	pointer = mem_access( access_count, source, access_sym );
  18.323 +	return box_int( pointer );
  18.324 +}
  18.325 +
  18.326 +object array_access( int access_count, object_ptr source, symtab_ptr *access_sym, symtab_ptr subscript ){
  18.327 +	uintptr_t pointer;
  18.328 +	uintptr_t element_size;
  18.329 +	intptr_t sub_val;
  18.330 +	memaccess = ARRAY_ACCESS;
  18.331 +	pointer = mem_access( access_count, source, access_sym );
  18.332 +	element_size = access_sym[access_count-1]->u.memstruct.size;
  18.333 +	if( access_sym[access_count-1]->u.memstruct.array ){
  18.334 +		element_size /= access_sym[access_count-1]->u.memstruct.array;
  18.335 +	}
  18.336 +	sub_val = get_pos_int( "array access subscript", subscript->obj);
  18.337 +	pointer += sub_val * element_size;
  18.338 +	return box_int( pointer );
  18.339 +}
  18.340 +
  18.341 +object memstruct_array( object_ptr source, symtab_ptr sym, object_ptr subscript ){
  18.342 +	uintptr_t pointer;
  18.343 +	int array_index;
  18.344 +	
  18.345 +	pointer = get_pos_int( "memstruct array", *source );
  18.346 +	array_index = get_pos_int( "memstruct array subscript", *subscript );
  18.347 +	
  18.348 +	pointer += sym->u.memstruct.size * array_index;
  18.349 +	return box_int( pointer );
  18.350 +}
  18.351 +
  18.352 +static void poke_member_value( void *pointer, int data_type, object_ptr val, int is_signed ){
  18.353 +	eudouble d;
  18.354 +	switch( data_type ){
  18.355 +		case MS_CHAR:
  18.356 +			if( is_signed) *(char*)pointer = (char) get_pos_int( "store char data", *val );
  18.357 +			else           *(unsigned char*)pointer = (unsigned char) get_pos_int( "store char data", *val );
  18.358 +			break;
  18.359 +		case MS_SHORT:
  18.360 +			if( is_signed) *(short*)pointer = (short) get_pos_int( "store short data", *val );
  18.361 +			else           *(unsigned short*)pointer = (unsigned short) get_pos_int( "store short data", *val );
  18.362 +			break;
  18.363 +		case MS_INT:
  18.364 +			if( is_signed) *(int*)pointer = (int) get_pos_int( "store int data", *val );
  18.365 +			else           *(unsigned int*)pointer = (unsigned int) get_pos_int( "store int data", *val );
  18.366 +			break;
  18.367 +		case MS_LONG:
  18.368 +			if( is_signed) *(long*)pointer =  (long) get_pos_int( "store long data", *val );
  18.369 +			else           *(unsigned long*)pointer = (unsigned long) get_pos_int( "store long data", *val );
  18.370 +			break;
  18.371 +		case MS_LONGLONG:
  18.372 +			if( is_signed) *(long long*)pointer = (long long) get_pos_int( "store long long int data", *val );
  18.373 +			else           *(unsigned long long*)pointer = (unsigned long long) get_pos_int( "store long long int data", *val );
  18.374 +			break;
  18.375 +		case MS_OBJECT:
  18.376 +			if( is_signed) *(intptr_t*)pointer = (intptr_t) get_pos_int( "store object data", *val );
  18.377 +			else           *(uintptr_t*)pointer = (uintptr_t) get_pos_int( "store object data", *val );
  18.378 +			break;
  18.379 +		case MS_FLOAT:
  18.380 +		case MS_DOUBLE:
  18.381 +		case MS_LONGDOUBLE:
  18.382 +		case MS_EUDOUBLE:
  18.383 +			if( IS_ATOM_INT( *val ) ){
  18.384 +				d = (eudouble) *val;
  18.385 +			}
  18.386 +			else if( IS_ATOM( *val ) ){
  18.387 +				d = DBL_PTR( *val )->dbl;
  18.388 +			}
  18.389 +			else{
  18.390 +				RTFatal( "Trying to store a sequence into a floating point memory location" );
  18.391 +			}
  18.392 +			if( data_type == MS_DOUBLE ){
  18.393 +				*(double*)pointer = d;
  18.394 +			}
  18.395 +			else if( data_type == MS_FLOAT ){
  18.396 +				*(float*)pointer = (float)d;
  18.397 +			}
  18.398 +			if( data_type == MS_EUDOUBLE ){
  18.399 +				*(eudouble*)pointer = d;
  18.400 +			}
  18.401 +			if( data_type == MS_LONGDOUBLE ){
  18.402 +#ifdef __GNUC__
  18.403 +				*(long double*)pointer = d;
  18.404 +#else
  18.405 +				RTFatal( "long doubles not implemented yet for storing into memory on non-gcc compilers" );
  18.406 +#endif
  18.407 +			}
  18.408 +			break;
  18.409 +		default:
  18.410 +			RTFatal( "Error assigning to a memstruct (%s) -- can only assign primitive data members" );
  18.411 +	}
  18.412 +}
  18.413 +
  18.414 +
  18.415 +void poke_member( object_ptr source, symtab_ptr sym, object_ptr val, intptr_t deref_ptr ){
  18.416 +	int data_type;
  18.417 +	int is_signed;
  18.418 +	uintptr_t pointer;
  18.419 +	
  18.420 +	data_type = sym->token;
  18.421 +	while( data_type == MEMTYPE ){
  18.422 +		sym = sym->u.memstruct.parent;
  18.423 +		data_type = sym->token;
  18.424 +	}
  18.425 +	is_signed = sym->u.memstruct.is_signed;
  18.426 +	
  18.427 +	
  18.428 +	
  18.429 +	pointer = get_pos_int( "storing memory data", *source );
  18.430 +	if( deref_ptr ){
  18.431 +		pointer = *(uintptr_t*) pointer;
  18.432 +	}
  18.433 +	else if( sym->u.memstruct.pointer ){
  18.434 +		data_type = MS_OBJECT;
  18.435 +		is_signed = 0;
  18.436 +	}
  18.437 +	
  18.438 +	if( sym->u.memstruct.array ){
  18.439 +		
  18.440 +		
  18.441 +		if( memaccess == ARRAY_ACCESS ){
  18.442 +			poke_member_value( (void*)pointer, data_type, val, is_signed );
  18.443 +		}
  18.444 +		else{
  18.445 +			int i, array_length, max, size;
  18.446 +			s1_ptr v;
  18.447 +			intptr_t zero = 0;
  18.448 +			array_length =  sym->u.memstruct.array;
  18.449 +			size = sym->u.memstruct.size / array_length;
  18.450 +			if( IS_ATOM( *val ) ){
  18.451 +				RTFatal( "expected a sequence to assign to the array" );
  18.452 +			}
  18.453 +			v = SEQ_PTR( *val );
  18.454 +			max = v->length;
  18.455 +			if( max > array_length ){
  18.456 +				max = array_length;
  18.457 +			}
  18.458 +			
  18.459 +			for( i = 0; i < max; ++i ){
  18.460 +				poke_member_value( (void*)pointer, data_type, v->base + i + 1, is_signed );
  18.461 +				pointer += size;
  18.462 +			}
  18.463 +			for( ; i < array_length; ++i ){
  18.464 +				poke_member_value( (void*)pointer, data_type, (object_ptr)&zero, is_signed );
  18.465 +				pointer += size;
  18.466 +			}
  18.467 +		}
  18.468 +	}
  18.469 +	else{
  18.470 +		poke_member_value( (void*)pointer, data_type, val, is_signed );
  18.471 +	}
  18.472 +	
  18.473 +}
  18.474 +
  18.475 +#define CALCULATE( type ) \
  18.476 +		type a, c;\
  18.477 +		a = *( type *) pointer;\
  18.478 +		if( IS_ATOM_INT( *opnd ) ){\
  18.479 +			c = (type) *opnd;\
  18.480 +		}\
  18.481 +		else if( IS_ATOM( *opnd ) ){\
  18.482 +			c = (type) DBL_PTR( *opnd )->dbl;\
  18.483 +		}\
  18.484 +		else{\
  18.485 +			c = (type) get_pos_int( "assign op for object", *opnd );\
  18.486 +		}\
  18.487 +		switch( op ){\
  18.488 +			case MEMSTRUCT_PLUS:\
  18.489 +				a += c;\
  18.490 +				break;\
  18.491 +			case MEMSTRUCT_MINUS:\
  18.492 +				a -= c;\
  18.493 +				break;\
  18.494 +			case MEMSTRUCT_MULTIPLY:\
  18.495 +				a *= c;\
  18.496 +				break;\
  18.497 +			case MEMSTRUCT_DIVIDE:\
  18.498 +				if( !c ){\
  18.499 +					RTFatal("attempt to divide by zero");\
  18.500 +				}\
  18.501 +				a /= c;\
  18.502 +				break;\
  18.503 +			default:\
  18.504 +				RTFatal("illegal assign op");\
  18.505 +		}\
  18.506 +		*(type*) pointer = a;
  18.507 +void ms_char( intptr_t op, void* pointer, object_ptr opnd, char is_signed ){
  18.508 +	
  18.509 +	if( is_signed ){
  18.510 +		CALCULATE( char )
  18.511 +	}
  18.512 +	else{
  18.513 +		CALCULATE( unsigned char )
  18.514 +	}
  18.515 +}
  18.516 +
  18.517 +void ms_short( intptr_t op, void* pointer, object_ptr opnd, char is_signed ){
  18.518 +	
  18.519 +	if( is_signed ){
  18.520 +		CALCULATE( short )
  18.521 +	}
  18.522 +	else{
  18.523 +		CALCULATE( unsigned short )
  18.524 +	}
  18.525 +}
  18.526 +
  18.527 +
  18.528 +void ms_int( intptr_t op, void* pointer, object_ptr opnd, char is_signed ){
  18.529 +	
  18.530 +	if( is_signed ){
  18.531 +		CALCULATE( int )
  18.532 +	}
  18.533 +	else{
  18.534 +		CALCULATE( unsigned int )
  18.535 +	}
  18.536 +}
  18.537 +
  18.538 +void ms_long( intptr_t op, void* pointer, object_ptr opnd, char is_signed ){
  18.539 +	
  18.540 +	if( is_signed ){
  18.541 +		CALCULATE( long )
  18.542 +	}
  18.543 +	else{
  18.544 +		CALCULATE( unsigned long )
  18.545 +	}
  18.546 +}
  18.547 +
  18.548 +
  18.549 +void ms_longlong( intptr_t op, void* pointer, object_ptr opnd, char is_signed ){
  18.550 +	
  18.551 +	if( is_signed ){
  18.552 +		CALCULATE( long long int )
  18.553 +	}
  18.554 +	else{
  18.555 +		CALCULATE( unsigned long long int )
  18.556 +	}
  18.557 +}
  18.558 +
  18.559 +
  18.560 +void ms_object( intptr_t op, void* pointer, object_ptr opnd, char is_signed ){
  18.561 +	
  18.562 +	if( is_signed ){
  18.563 +		CALCULATE( intptr_t )
  18.564 +	}
  18.565 +	else{
  18.566 +		CALCULATE( uintptr_t )
  18.567 +	}
  18.568 +}
  18.569 +
  18.570 +#define FLOAT_CALCULATE( type ) \
  18.571 +	type a, c;\
  18.572 +	if( IS_ATOM_INT(  *opnd ) ){\
  18.573 +		c = (type) *opnd;\
  18.574 +	}\
  18.575 +	else if( IS_ATOM( *opnd ) ){\
  18.576 +		c = (type) DBL_PTR( *opnd )->dbl;\
  18.577 +	}\
  18.578 +	else{\
  18.579 +		RTFatal( "Trying to assign a sequence to ##type data" );\
  18.580 +	}\
  18.581 +	a = *(type*)pointer;\
  18.582 +	switch( op ){\
  18.583 +		case MEMSTRUCT_PLUS:\
  18.584 +			a += c;\
  18.585 +			break;\
  18.586 +		case MEMSTRUCT_MINUS:\
  18.587 +			a -= c;\
  18.588 +			break;\
  18.589 +		case MEMSTRUCT_MULTIPLY:\
  18.590 +			a *= c;\
  18.591 +			break;\
  18.592 +		case MEMSTRUCT_DIVIDE:\
  18.593 +			if( c == (type) 0 ){\
  18.594 +				RTFatal("attempt to divide by zero");\
  18.595 +			}\
  18.596 +			a /= c;\
  18.597 +			break;\
  18.598 +		default:\
  18.599 +			RTFatal("illegal assign op");\
  18.600 +	}\
  18.601 +	*(type*)pointer = a;
  18.602 +	
  18.603 +void ms_float( intptr_t op, void* pointer, object_ptr opnd ){
  18.604 +	FLOAT_CALCULATE( float )
  18.605 +}
  18.606 +
  18.607 +void ms_double( intptr_t op, void* pointer, object_ptr opnd ){
  18.608 +	FLOAT_CALCULATE( double )
  18.609 +}
  18.610 +
  18.611 +void ms_longdouble( intptr_t op, void* pointer, object_ptr opnd ){
  18.612 +#ifdef __GNUC__
  18.613 +	FLOAT_CALCULATE( long double )
  18.614 +#else
  18.615 +	// TODO: convert to doubles and do arithmetic that way? Or more machine code hacks?
  18.616 +	RTFatal( "Extended precision arithmetic not available" );
  18.617 +#endif
  18.618 +}
  18.619 +
  18.620 +void ms_eudouble( intptr_t op, void* pointer, object_ptr opnd ){
  18.621 +	FLOAT_CALCULATE( eudouble )
  18.622 +}
  18.623 +
  18.624 +void memstruct_assignop( intptr_t op, object_ptr source, symtab_ptr sym, object_ptr opnd, intptr_t deref_ptr ){
  18.625 +	void *pointer;
  18.626 +	char is_signed;
  18.627 +	
  18.628 +	pointer   = (void*) get_pos_int( "memstruct assign op", *source );
  18.629 +	if( deref_ptr ){
  18.630 +		pointer = *(void**)pointer;
  18.631 +	}
  18.632 +	is_signed = sym->u.memstruct.is_signed;
  18.633 +	
  18.634 +	switch( sym->token ){
  18.635 +		case MS_CHAR:
  18.636 +			ms_char( op, pointer, opnd, is_signed );
  18.637 +			break;
  18.638 +		case MS_SHORT:
  18.639 +			ms_short( op, pointer, opnd, is_signed );
  18.640 +			break;
  18.641 +		case MS_INT:
  18.642 +			ms_int( op, pointer, opnd, is_signed );
  18.643 +			break;
  18.644 +		case MS_LONG:
  18.645 +			ms_long( op, pointer, opnd, is_signed );
  18.646 +			break;
  18.647 +		case MS_LONGLONG:
  18.648 +			ms_longlong( op, pointer, opnd, is_signed );
  18.649 +			break;
  18.650 +		case MS_OBJECT:
  18.651 +			ms_object( op, pointer, opnd, is_signed );
  18.652 +			break;
  18.653 +		case MS_FLOAT:
  18.654 +			ms_float( op, pointer, opnd );
  18.655 +			break;
  18.656 +		case MS_DOUBLE:
  18.657 +			ms_double( op, pointer, opnd );
  18.658 +			break;
  18.659 +		case MS_LONGDOUBLE:
  18.660 +			ms_longdouble( op, pointer, opnd );
  18.661 +			break;
  18.662 +		case MS_EUDOUBLE:
  18.663 +			ms_eudouble( op, pointer, opnd );
  18.664 +			break;
  18.665 +		default:
  18.666 +			RTFatal( "Target of the assignment must be a primitive data type" );
  18.667 +	}
  18.668 +	
  18.669 +}

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/source/be_memstruct.h	Wed Dec 21 16:45:49 2011 -0300
    19.3 @@ -0,0 +1,22 @@
    19.4 +#ifndef BE_MEMSTRUCT_H_
    19.5 +#define BE_MEMSTRUCT_H_
    19.6 +
    19.7 +#include "execute.h"
    19.8 +#include "object.h"
    19.9 +#include "symtab.h"
   19.10 +
   19.11 +object peek_member( object_ptr source, symtab_ptr memsym, int array_index, void *pointer, intptr_t deref_ptr );
   19.12 +void poke_member( object_ptr source, symtab_ptr sym, object_ptr val, intptr_t deref_ptr );
   19.13 +void write_member( object_ptr source, symtab_ptr sym, object_ptr val, intptr_t deref_ptr );
   19.14 +void write_union( object_ptr source, symtab_ptr sym, object_ptr val, intptr_t deref_ptr );
   19.15 +
   19.16 +object memstruct_array( object_ptr source, symtab_ptr sym, object_ptr subscript );
   19.17 +object peek_array( object_ptr source, symtab_ptr sym, object_ptr subscript );
   19.18 +object memstruct_access( int access_count, object_ptr source, symtab_ptr* access_sym );
   19.19 +object array_access( int access_count, object_ptr source, symtab_ptr* access_sym, symtab_ptr subscript_sym );
   19.20 +object read_memstruct( object_ptr source, void *pointer, symtab_ptr member_sym );
   19.21 +
   19.22 +
   19.23 +void memstruct_assignop( intptr_t op, object_ptr source, symtab_ptr sym, object_ptr opnd, intptr_t deref_ptr );
   19.24 +
   19.25 +#endif

    20.1 --- a/source/be_rterror.c	Mon Dec 19 23:19:58 2011 -0300
    20.2 +++ b/source/be_rterror.c	Wed Dec 21 16:45:49 2011 -0300
    20.3 @@ -93,6 +93,7 @@
    20.4  int file_trace;                 /* log statements to ctrace.out */
    20.5  int trace_enabled = TRUE;       /* flag to disable tracing */
    20.6  char *type_error_msg = "\ntype_check failure, ";   /* changeable message */
    20.7 +char *type_check_sym = NULL;    /* used for memstruct type check errors */
    20.8  
    20.9  /*******************/
   20.10  /* Local variables */
   20.11 @@ -1200,7 +1201,11 @@
   20.12  			}
   20.13  			else {
   20.14  				sf_output(type_error_msg); // test
   20.15 -				snprintf(TPTempBuff, TPTEMP_BUFF_SIZE, "%s is ", s_ptr->name);
   20.16 +				if( type_check_sym == NULL ){
   20.17 +					type_check_sym = s_ptr->name;
   20.18 +				}
   20.19 +				snprintf(TPTempBuff, TPTEMP_BUFF_SIZE, "%s is ", type_check_sym);
   20.20 +				
   20.21  				TPTempBuff[TPTEMP_BUFF_SIZE-1] = 0;
   20.22  				sf_output(TPTempBuff);
   20.23  				if (screen_err_out)
   20.24 @@ -1414,6 +1419,15 @@
   20.25  	va_end(ap);
   20.26  }
   20.27  
   20.28 +void RTFatalMemType(intptr_t *pc, intptr_t member){
   20.29 +	symtab_ptr s_ptr;
   20.30 +	tpc = pc; /* points within the offending assignment/parm setting */
   20.31 +	s_ptr = *(symtab_ptr *)pc;
   20.32 +	type_check_sym = ((symtab_ptr)member)->name;
   20.33 +	CleanUpError(NULL, s_ptr);
   20.34 +
   20.35 +}
   20.36 +
   20.37  void RTFatalType(intptr_t *pc)
   20.38  /* handle type-check failures */
   20.39  /* pc points to variable in instruction stream */ 

    21.1 --- a/source/be_rterror.h	Mon Dec 19 23:19:58 2011 -0300
    21.2 +++ b/source/be_rterror.h	Wed Dec 21 16:45:49 2011 -0300
    21.3 @@ -4,7 +4,13 @@
    21.4  #include <stdint.h>
    21.5  
    21.6  void RTFatalType(intptr_t *pc)
    21.7 -#ifdef EUNIX
    21.8 +#ifdef __GNUC__
    21.9 +__attribute__ ((noreturn))
   21.10 +#endif
   21.11 +;
   21.12 +
   21.13 +void RTFatalMemType(intptr_t *pc, intptr_t member)
   21.14 +#ifdef __GNUC__
   21.15  __attribute__ ((noreturn))
   21.16  #endif
   21.17  ;
   21.18 @@ -38,7 +44,7 @@
   21.19  void NoValue(symtab_ptr s);
   21.20  
   21.21  void CleanUpError_va(char *msg, symtab_ptr s_ptr, va_list ap)
   21.22 -#if defined(EUNIX) || defined(EMINGW)
   21.23 +#ifdef __GNUC__
   21.24   __attribute__ ((noreturn))
   21.25  #else
   21.26  #pragma aux CleanUpError_va aborts;

    22.1 --- a/source/be_runtime.c	Mon Dec 19 23:19:58 2011 -0300
    22.2 +++ b/source/be_runtime.c	Wed Dec 21 16:45:49 2011 -0300
    22.3 @@ -4590,6 +4590,7 @@
    22.4  
    22.5  static int trace_line = 0;
    22.6  static IFILE trace_file;
    22.7 +int trace_lines = 500;
    22.8  
    22.9  static void one_trace_line(char *line)
   22.10  /* write a line to the ctrace.out file */
   22.11 @@ -4615,7 +4616,7 @@
   22.12  		}
   22.13  		if (trace_file != NULL) {
   22.14  			trace_line++;
   22.15 -			if (trace_line >= 500) {
   22.16 +			if (trace_line >= trace_lines) {
   22.17  				one_trace_line("");
   22.18  				one_trace_line("               "); // erase THE END
   22.19  				trace_line = 0;

    23.1 --- a/source/be_runtime.h	Mon Dec 19 23:19:58 2011 -0300
    23.2 +++ b/source/be_runtime.h	Wed Dec 21 16:45:49 2011 -0300
    23.3 @@ -50,6 +50,8 @@
    23.4  
    23.5  extern struct op_info optable[MAX_OPCODE+1];
    23.6  
    23.7 +extern int trace_lines;
    23.8 +
    23.9  void debug_msg(char *msg);
   23.10  
   23.11  void UserCleanup(int status)

    24.1 --- a/source/c_decl.e	Mon Dec 19 23:19:58 2011 -0300
    24.2 +++ b/source/c_decl.e	Wed Dec 21 16:45:49 2011 -0300
    24.3 @@ -1162,7 +1162,8 @@
    24.4  
    24.5  	c_puts("#include \"include/euphoria.h\"\n")
    24.6  
    24.7 -	c_puts("#include \"main-.h\"\n\n")
    24.8 +	c_puts("#include \"main-.h\"\n")
    24.9 +	c_puts("#include \"struct.h\"\n\n")
   24.10  
   24.11  	if not TUNIX then
   24.12  		name = lower(name)  -- for faster compare later

    25.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.2 +++ b/source/c_struct.e	Wed Dec 21 16:45:49 2011 -0300
    25.3 @@ -0,0 +1,1086 @@
    25.4 +-- Translator code for dealing with memstructs
    25.5 +
    25.6 +include c_decl.e
    25.7 +include c_out.e
    25.8 +include compile.e
    25.9 +include emit.e
   25.10 +include error.e
   25.11 +include global.e
   25.12 +include reswords.e
   25.13 +include symtab.e
   25.14 +
   25.15 +-- Use this to communicate between ops so we can avoid changing
   25.16 +-- pointers into doubles.
   25.17 +sequence target_is_pointer = {}
   25.18 +
   25.19 +integer memaccess = 0
   25.20 +
   25.21 +function is_pointer( integer pointer )
   25.22 +	return find( pointer, target_is_pointer )
   25.23 +end function
   25.24 +
   25.25 +procedure add_pointer( integer pointer )
   25.26 +	if not is_pointer( pointer ) then
   25.27 +		target_is_pointer &= pointer
   25.28 +	end if
   25.29 +end procedure
   25.30 +
   25.31 +procedure remove_pointer( integer pointer )
   25.32 +	integer px = is_pointer( pointer )
   25.33 +	if px then
   25.34 +		target_is_pointer = remove( target_is_pointer, px )
   25.35 +	end if
   25.36 +end procedure
   25.37 +
   25.38 +
   25.39 +function struct_type( symtab_index sym )
   25.40 +	sym = SymTab[sym][S_MEM_PARENT]
   25.41 +	integer token = sym_token( sym )
   25.42 +	sequence type_name = ""
   25.43 +	if token = MEMSTRUCT then
   25.44 +		type_name &= "struct "
   25.45 +	else
   25.46 +		type_name &= "union "
   25.47 +	end if
   25.48 +	return type_name & decorated_name( sym )
   25.49 +end function
   25.50 +
   25.51 +procedure get_pointer( integer pointer, integer target )
   25.52 +	if not is_pointer( target ) and pointer != target then
   25.53 +		CDeRef( target )
   25.54 +	end if
   25.55 +	
   25.56 +	if is_pointer( pointer ) then
   25.57 +		if target != pointer then
   25.58 +			
   25.59 +			c_stmt( "@ = @;\n", {target, pointer}, target )
   25.60 +		end if
   25.61 +	else
   25.62 +		c_stmt( "_0 = @;\n", pointer )
   25.63 +	
   25.64 +		if not TypeIs( pointer, TYPE_INTEGER ) then
   25.65 +			c_stmt0("if( !IS_ATOM_INT( _0 ) ){\n" )
   25.66 +				c_stmt0("_0 = (intptr_t) DBL_PTR( _0 )->dbl;\n" )
   25.67 +			c_stmt0( "}\n")
   25.68 +		end if
   25.69 +		
   25.70 +		c_stmt( "@ = _0;\n", target, target )
   25.71 +		if target != pointer then
   25.72 +			dispose_temp( pointer, compile:DISCARD_TEMP, REMOVE_FROM_MAP )
   25.73 +		end if
   25.74 +	end if
   25.75 +	
   25.76 +	add_pointer( target )
   25.77 +	SetBBType( target, TYPE_INTEGER, {MININT, MAXINT}, TYPE_INTEGER, 0 )
   25.78 +	
   25.79 +end procedure
   25.80 +
   25.81 +procedure mem_access( integer access_count, integer pointer, integer target )
   25.82 +	get_pointer( pointer, target )
   25.83 +	symtab_index sym = Code[pc+3]
   25.84 +	
   25.85 +	c_stmt( sprintf("@ = (intptr_t) &(((%s*)@)",{struct_type(sym)}), { target, target }, target )
   25.86 +	
   25.87 +	integer 
   25.88 +		first_pc    = pc + 3,
   25.89 +		last_pc     = pc + 2 + access_count,
   25.90 +		was_pointer = 1
   25.91 +	
   25.92 +	for i = first_pc to last_pc do
   25.93 +		if was_pointer then
   25.94 +			c_puts("->")
   25.95 +		else
   25.96 +			c_puts(".")
   25.97 +		end if
   25.98 +		CName( Code[i] )
   25.99 +		was_pointer = SymTab[Code[i]][S_MEM_POINTER]
  25.100 +	end for
  25.101 +	c_puts( ");\n")
  25.102 +end procedure
  25.103 +
  25.104 +export procedure opARRAY_ACCESS()
  25.105 +	integer 
  25.106 +		access_count = Code[pc+1],
  25.107 +		pointer      = Code[pc+2],
  25.108 +		subscript    = Code[pc + 3 + access_count],
  25.109 +		target       = Code[pc + 4 + access_count]
  25.110 +	mem_access( access_count, pointer, target )
  25.111 +	memaccess = ARRAY_ACCESS
  25.112 +	symtab_index sym = Code[pc + 2 + access_count]
  25.113 +	c_stmt( sprintf("@ = (intptr_t) (((%s *)@) + @);\n",{get_data_type(sym)}), { target, target, subscript }, target )
  25.114 +	
  25.115 +	pc += access_count + 5
  25.116 +end procedure
  25.117 +
  25.118 +export procedure opMEMSTRUCT_ACCESS()
  25.119 +	integer 
  25.120 +		access_count = Code[pc+1],
  25.121 +		pointer      = Code[pc+2],
  25.122 +		target       = Code[pc+ 3 + access_count]
  25.123 +	
  25.124 +	mem_access( access_count, pointer, target )
  25.125 +	memaccess = MEMSTRUCT_ACCESS
  25.126 +	pc += access_count + 4
  25.127 +end procedure
  25.128 +
  25.129 +export procedure opMEMSTRUCT_ARRAY()
  25.130 +	integer
  25.131 +		pointer   = Code[pc+1],
  25.132 +		member    = Code[pc+2],
  25.133 +		subscript = Code[pc+3],
  25.134 +		target    = Code[pc+4]
  25.135 +	
  25.136 +	get_pointer( pointer, target )
  25.137 +	sequence type_name
  25.138 +	integer data_type = sym_token( member )
  25.139 +	switch data_type do
  25.140 +		case MS_MEMBER then
  25.141 +			member = SymTab[member][S_MEM_STRUCT]
  25.142 +			fallthru
  25.143 +			
  25.144 +		case MEMSTRUCT, MEMUNION then
  25.145 +			sequence tag
  25.146 +			if data_type = MEMSTRUCT then
  25.147 +				tag = "struct"
  25.148 +			else
  25.149 +				tag = "union"
  25.150 +			end if
  25.151 +			type_name = sprintf( "%s %s", { tag, decorated_name( member ) } )
  25.152 +		case else
  25.153 +			type_name = mem_name( data_type )
  25.154 +	end switch
  25.155 +	
  25.156 +	integer is_integer = TypeIs( subscript, TYPE_INTEGER )
  25.157 +	if not is_integer then
  25.158 +		c_stmt("if( IS_ATOM_INT( @ ) ){\n", subscript )
  25.159 +	end if
  25.160 +	c_stmt("_1 = @;\n", subscript )
  25.161 +	
  25.162 +	if not is_integer then
  25.163 +		c_stmt0( "}\n" )
  25.164 +		c_stmt0( "else{\n" )
  25.165 +		c_stmt(  "_1 = (intptr_t)DBL_PTR( @ )->dbl;\n", subscript )
  25.166 +		c_stmt0( "}\n" )
  25.167 +	end if
  25.168 +	
  25.169 +	dispose_temp( subscript, compile:DISCARD_TEMP, REMOVE_FROM_MAP )
  25.170 +	c_stmt( sprintf( "@ = (intptr_t) &(((%s*)@)[_1]);\n", { type_name } ), { target, target }, target )
  25.171 +	
  25.172 +	pc += 5
  25.173 +end procedure
  25.174 +
  25.175 +function get_tagged_name( symtab_index sym )
  25.176 +	sequence tag
  25.177 +	
  25.178 +	while sym_token( sym ) = MEMTYPE do
  25.179 +		sym = SymTab[S_MEM_PARENT]
  25.180 +	end while
  25.181 +	
  25.182 +	if SymTab[sym][S_TOKEN] = MEMSTRUCT then
  25.183 +		tag = "struct"
  25.184 +	else
  25.185 +		tag = "union"
  25.186 +	end if
  25.187 +	return sprintf( "%s %s", { tag, decorated_name( sym ) } )
  25.188 +end function
  25.189 +
  25.190 +export procedure opPEEK_ARRAY()
  25.191 +	integer
  25.192 +		pointer   = Code[pc+1],
  25.193 +		sym       = Code[pc+2],
  25.194 +		subscript = Code[pc+3],
  25.195 +		target    = Code[pc+4],
  25.196 +		parent    = SymTab[sym][S_MEM_PARENT]
  25.197 +	
  25.198 +	integer data_type  = SymTab[sym][S_TOKEN]
  25.199 +	integer signed     = SymTab[sym][S_MEM_SIGNED]
  25.200 +	integer is_pointer = SymTab[sym][S_MEM_POINTER]
  25.201 +	sequence type_name, struct_name
  25.202 +	
  25.203 +	get_pointer( pointer, target )
  25.204 +	
  25.205 +	struct_name = get_tagged_name( parent )
  25.206 +	
  25.207 +	switch data_type do
  25.208 +		case MS_MEMBER then
  25.209 +			sym = SymTab[sym][S_MEM_STRUCT]
  25.210 +			fallthru
  25.211 +			
  25.212 +		case MEMSTRUCT, MEMUNION then
  25.213 +			type_name = struct_name
  25.214 +		case else
  25.215 +			type_name = mem_name( data_type )
  25.216 +	end switch
  25.217 +	
  25.218 +	sequence array_modifier = "[_1]"
  25.219 +	integer index_is_int = TypeIs( subscript, TYPE_INTEGER)
  25.220 +	if not index_is_int then
  25.221 +		c_stmt("if( !IS_ATOM_INT( @ ) && IS_ATOM( @ ) ){\n", { subscript, subscript}, subscript )
  25.222 +			c_stmt("_1 = (intptr_t)DBL_PTR( @)->dbl;\n", { subscript })
  25.223 +		c_stmt0("}\n")
  25.224 +		c_stmt0("else{\n")
  25.225 +	end if
  25.226 +	c_stmt( "_1 = @;\n", { subscript } )
  25.227 +	if not index_is_int then
  25.228 +		c_stmt0("}\n")
  25.229 +	end if
  25.230 +	
  25.231 +	c_stmt( sprintf("@ = (intptr_t)&((%s *)@)->%s;\n", {struct_name, decorated_name( sym ) }), { target, target } )
  25.232 +	
  25.233 +	peek_member_value( target, sym, data_type, is_pointer, array_modifier, type_name, signed, target )
  25.234 +	remove_pointer( pointer )
  25.235 +	remove_pointer( target )
  25.236 +	
  25.237 +	pc += 5
  25.238 +end procedure
  25.239 +
  25.240 +--**
  25.241 +-- Stores the value pointed to by _0 into the target.  If target is 0,
  25.242 +-- then the caller has already emitted the LHS, and peek_member will
  25.243 +-- only print the RHS.
  25.244 +procedure peek_member( integer pointer, integer sym, integer target, integer array_index = -1, integer deref_ptr = 0 )
  25.245 +	integer data_type  = SymTab[sym][S_TOKEN]
  25.246 +	integer signed     = SymTab[sym][S_MEM_SIGNED]
  25.247 +	integer is_pointer = SymTab[sym][S_MEM_POINTER]
  25.248 +	sequence type_name
  25.249 +	sequence array_modifier = ""
  25.250 +	
  25.251 +	type_name = mem_name( sym_token( sym ) )
  25.252 +	if is_pointer and not deref_ptr then
  25.253 +		data_type = MS_OBJECT
  25.254 +		signed    = 0
  25.255 +		type_name = "object"
  25.256 +	end if
  25.257 +	
  25.258 +	if target then
  25.259 +		CDeRef( target )
  25.260 +	end if
  25.261 +	
  25.262 +	if not signed then
  25.263 +		switch data_type do
  25.264 +			case MS_OBJECT then
  25.265 +				type_name = "uintptr_t"
  25.266 +			case MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
  25.267 +				-- nothing
  25.268 +			case else
  25.269 +				type_name = "unsigned " & type_name
  25.270 +		end switch
  25.271 +	end if
  25.272 +	
  25.273 +	if data_type = MS_MEMBER then
  25.274 +		data_type = sym_token( SymTab[sym][S_MEM_STRUCT] )
  25.275 +	end if
  25.276 +	
  25.277 +	if array_index != -1 then
  25.278 +		array_modifier = sprintf("[%d]", array_index )
  25.279 +	elsif SymTab[sym][S_MEM_ARRAY] and memaccess = MEMSTRUCT_ACCESS then
  25.280 +	
  25.281 +		c_stmt0( sprintf( "_2 = NewS1( %d );\n", SymTab[sym][S_MEM_ARRAY] ) )
  25.282 +		for i = 1 to SymTab[sym][S_MEM_ARRAY] do
  25.283 +			peek_member( pointer, sym, 0, i-1 )
  25.284 +			c_stmt0( sprintf( "((s1_ptr)_2)->base[%d] = _0;\n", i ) )
  25.285 +		end for
  25.286 +		if target then
  25.287 +			c_stmt( "@ = MAKE_SEQ( _2 );\n", target )
  25.288 +		else
  25.289 +			c_stmt0( "_0 = MAKE_SEQ( _2 );\n" )
  25.290 +		end if
  25.291 +		return
  25.292 +		
  25.293 +	end if
  25.294 +	
  25.295 +	if deref_ptr then
  25.296 +		c_stmt( "@ = *(intptr_t*)@;\n", { pointer, pointer }, pointer )
  25.297 +	end if
  25.298 +	peek_member_value( pointer, sym, data_type, is_pointer, array_modifier, type_name, signed, target )
  25.299 +	memaccess = MEMSTRUCT_ACCESS
  25.300 +end procedure
  25.301 +
  25.302 +procedure peek_member_value( integer pointer, integer sym, integer data_type,
  25.303 +							 integer is_pointer, sequence array_modifier,
  25.304 +							 sequence type_name, integer signed, integer target )
  25.305 +	integer parent
  25.306 +	switch data_type do
  25.307 +		case MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
  25.308 +			sequence indirect_float = ""
  25.309 +			if not length( array_modifier ) then
  25.310 +				indirect_float = "*"
  25.311 +			end if
  25.312 +			if target then
  25.313 +				c_stmt( sprintf("@ = NewDouble( (eudouble) %s((%s*)@)%s );\n",
  25.314 +								{indirect_float, type_name, array_modifier}),
  25.315 +								{ target, pointer }, target )
  25.316 +			else
  25.317 +				parent =  SymTab[sym][S_MEM_PARENT]
  25.318 +				sequence parent_struct
  25.319 +				switch sym_token( parent ) do
  25.320 +					case MEMSTRUCT, MEMUNION, QUALIFIED_MEMSTRUCT, QUALIFIED_MEMUNION then
  25.321 +						parent_struct = decorated_name( parent )
  25.322 +					case else
  25.323 +						parent_struct = decorated_name( SymTab[parent][S_MEM_STRUCT] )
  25.324 +				end switch
  25.325 +				
  25.326 +				c_stmt( 
  25.327 +						sprintf("_0 = NewDouble( (eudouble) %s(((%s*)@)%s) );\n", 
  25.328 +							{
  25.329 +								indirect_float,
  25.330 +								type_name,
  25.331 +								array_modifier
  25.332 +							}
  25.333 +						), 
  25.334 +						{ pointer }
  25.335 +					)
  25.336 +				
  25.337 +			end if
  25.338 +		
  25.339 +		case MEMUNION then
  25.340 +			read_memunion( pointer, sym )
  25.341 +			if target then
  25.342 +				c_stmt( "@ = _0;\n", target, target )
  25.343 +			end if
  25.344 +		case MEMSTRUCT then
  25.345 +			read_memstruct( pointer, sym )
  25.346 +			if target then
  25.347 +				c_stmt( "@ = _0;\n", target, target )
  25.348 +			end if
  25.349 +		case else
  25.350 +			sequence indirect_read = ""
  25.351 +			if not length( array_modifier ) then
  25.352 +				indirect_read = "*"
  25.353 +			end if
  25.354 +			if target then
  25.355 +				c_stmt( sprintf("@ = %s((%s*)@)%s;\n", {indirect_read, type_name, array_modifier}), { target, pointer }, target )
  25.356 +			else
  25.357 +				c_stmt( 
  25.358 +						sprintf("_0 = %s((%s*)@)%s;\n", 
  25.359 +							{
  25.360 +								indirect_read,
  25.361 +								type_name,
  25.362 +								array_modifier
  25.363 +							}
  25.364 +						),  { pointer } )
  25.365 +				
  25.366 +				if data_type != MS_CHAR and data_type != MS_SHORT label "convert" then
  25.367 +					ifdef E64 then
  25.368 +						ifdef WINDOWS then
  25.369 +							if data_type = MS_LONG then
  25.370 +								-- a long is still 32-bits on 64-bit windows
  25.371 +								break "convert"
  25.372 +							end if
  25.373 +						end ifdef
  25.374 +						
  25.375 +						if data_type = MS_INT /*or is_pointer*/ then
  25.376 +							-- these are always safe under 64-bit arch
  25.377 +							break "convert"
  25.378 +						end if
  25.379 +						
  25.380 +					end ifdef
  25.381 +					c_stmt0("if ((uintptr_t)_0 > (uintptr_t)MAXINT){\n" )
  25.382 +					if signed then
  25.383 +						c_stmt0("_0 = NewDouble((eudouble)(intptr_t)_0);\n" )
  25.384 +					else
  25.385 +						c_stmt0("_0 = NewDouble((eudouble)(uintptr_t)_0);\n" )
  25.386 +					end if
  25.387 +					c_stmt0("}\n")
  25.388 +				end if
  25.389 +			end if
  25.390 +			
  25.391 +	end switch
  25.392 +end procedure
  25.393 +
  25.394 +export procedure opPEEK_MEMBER()
  25.395 +	integer
  25.396 +		pointer = Code[pc+1],
  25.397 +		member  = Code[pc+2],
  25.398 +		deref   = Code[pc+3],
  25.399 +		target  = Code[pc+4]
  25.400 +	
  25.401 +	get_pointer( pointer, target )
  25.402 +	
  25.403 +	peek_member( pointer, member, target, /* array index */, deref )
  25.404 +	
  25.405 +	remove_pointer( pointer )
  25.406 +	remove_pointer( target )
  25.407 +	pc += 5
  25.408 +end procedure
  25.409 +
  25.410 +integer serialize_level = 0
  25.411 +
  25.412 +--**
  25.413 +-- Serialize the specified memstruct into a sequence and store the object in _2.
  25.414 +procedure read_memstruct( integer pointer, symtab_pointer member_sym )
  25.415 +	
  25.416 +	if sym_token( member_sym ) != MEMSTRUCT then
  25.417 +		-- we want to walk the actual struct
  25.418 +		member_sym = SymTab[member_sym][S_MEM_STRUCT]
  25.419 +	end if
  25.420 +	
  25.421 +	
  25.422 +	integer size = 0
  25.423 +	integer size_sym = member_sym
  25.424 +	while size_sym with entry do
  25.425 +		size += 1
  25.426 +	entry
  25.427 +		size_sym = SymTab[size_sym][S_MEM_NEXT]
  25.428 +	end while
  25.429 +	
  25.430 +	serialize_level += 1
  25.431 +	c_stmt0( "{\n" )
  25.432 +	c_stmt0( sprintf("s1_ptr serialize_%d;\n", serialize_level ) )
  25.433 +	c_stmt0( sprintf("serialize_%d = NewS1( %d );\n", { serialize_level, size } ) )
  25.434 +	c_stmt( "_1 = @;\n", pointer )
  25.435 +	integer ix = 0
  25.436 +	sequence parent = get_tagged_name( member_sym )
  25.437 +	while member_sym with entry do
  25.438 +		ifdef DEBUG then
  25.439 +			c_stmt0( sprintf("// peek member: %s.%s\n", {decorated_name( SymTab[member_sym][S_MEM_PARENT] ),  decorated_name( member_sym ) }))
  25.440 +		end ifdef
  25.441 +		c_stmt( sprintf("@ = (intptr_t) & ((%s*)_1)->%s;\n",  { parent, decorated_name( member_sym )}), pointer )
  25.442 +		peek_member( pointer, member_sym, 0  )
  25.443 +		ix += 1
  25.444 +		c_stmt0( sprintf( "serialize_%d->base[%d] = _0;\n", { serialize_level, ix } ) )
  25.445 +		
  25.446 +	entry
  25.447 +		member_sym = SymTab[member_sym][S_MEM_NEXT]
  25.448 +	end while
  25.449 +	
  25.450 +	c_stmt0( sprintf( "_0 = MAKE_SEQ( serialize_%d );\n", serialize_level ) )
  25.451 +	c_stmt( "@ = _1;\n", pointer, pointer )
  25.452 +	c_stmt0( "}\n" )
  25.453 +	serialize_level -= 1
  25.454 +end procedure
  25.455 +
  25.456 +--**
  25.457 +-- Serialize the specified memunion into a sequence and store the object in _0.
  25.458 +-- Also uses _1.
  25.459 +procedure read_memunion( integer pointer, symtab_pointer member_sym )
  25.460 +	integer size = SymTab[member_sym][S_MEM_SIZE]
  25.461 +	
  25.462 +	c_stmt0( sprintf( "_1 = NewS1( %d );\n", size ) )
  25.463 +	
  25.464 +	for i = 1 to size do
  25.465 +		c_stmt( sprintf( "((s1_ptr)_1)->base[%d] = ((unsigned char *) @)[%d];\n", {i, i-1} ), pointer )
  25.466 +	end for
  25.467 +	c_stmt0( "_0 = MAKE_SEQ( _1 );\n" )
  25.468 +end procedure
  25.469 +
  25.470 +function read_member( integer pointer, integer sym  )
  25.471 +	symtab_pointer member_sym = sym
  25.472 +	integer tid = sym_token( sym )
  25.473 +	if tid >= MS_SIGNED and tid <= MS_OBJECT then
  25.474 +		-- simple serialization of primitives...
  25.475 +		peek_member( pointer, sym, 0 )
  25.476 +		return 0
  25.477 +	end if
  25.478 +	
  25.479 +	integer member_token = sym_token( member_sym )
  25.480 +	if member_token = MEMSTRUCT then
  25.481 +		read_memstruct( pointer, member_sym )
  25.482 +	
  25.483 +	elsif member_token = MEMUNION then
  25.484 +		read_memunion( pointer, member_sym  )
  25.485 +		
  25.486 +	else
  25.487 +		member_token = SymTab[SymTab[member_sym][S_MEM_STRUCT]][S_TOKEN]
  25.488 +		if member_token = MEMSTRUCT then
  25.489 +			read_memstruct( pointer, member_sym )
  25.490 +			
  25.491 +		elsif member_token = MEMUNION then
  25.492 +			read_memunion( pointer, member_sym )
  25.493 +		else
  25.494 +			InternalErr( "Cannot serialize a: [1]", { LexName( member_token )  })
  25.495 +		end if
  25.496 +	end if
  25.497 +	return 1
  25.498 +end function
  25.499 +
  25.500 +export procedure opMEMSTRUCT_READ()
  25.501 +	integer
  25.502 +		pointer = Code[pc+1],
  25.503 +		member  = Code[pc+2],
  25.504 +		target  = Code[pc+3]
  25.505 +	
  25.506 +	CDeRef( target )
  25.507 +	get_pointer( pointer, target )
  25.508 +	
  25.509 +	integer is_sequence = read_member( target, member )
  25.510 +	
  25.511 +	c_stmt( "@ = _0;\n", target, target )
  25.512 +	if is_sequence then
  25.513 +		SetBBType( target, TYPE_SEQUENCE, {MININT, MAXINT}, TYPE_OBJECT, 0 )
  25.514 +	else
  25.515 +		SetBBType( target, TYPE_ATOM, {MININT, MAXINT}, TYPE_OBJECT, 0 )
  25.516 +	end if
  25.517 +	remove_pointer( pointer )
  25.518 +	
  25.519 +	pc += 4
  25.520 +end procedure
  25.521 +
  25.522 +procedure poke_member_value( symtab_index target, symtab_index val, integer data_type, sequence type_name, integer array_index )
  25.523 +	if array_index != -1 then
  25.524 +		c_stmt( sprintf( "_1 = SEQ_PTR( @ )->base[%d];\n", array_index + 1), val )
  25.525 +	end if
  25.526 +	switch data_type do
  25.527 +		case MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
  25.528 +			integer is_double = TypeIs( val, TYPE_DOUBLE )
  25.529 +			if not is_double then
  25.530 +				
  25.531 +				if array_index = -1 then
  25.532 +					c_stmt( "if( IS_ATOM_INT( @ ) ){\n", val )
  25.533 +					c_stmt( sprintf("*(%s*)@ = (%s)@;\n", {type_name, type_name}), { target, val }, target )
  25.534 +				else
  25.535 +					c_stmt0( "if( IS_ATOM_INT( _1 ) ){\n" )
  25.536 +					c_stmt( sprintf("((%s*)@)[%d] = (%s)_1;\n", {type_name, array_index, type_name}), { target }, target )
  25.537 +				end if
  25.538 +				c_stmt0( "}\n" )
  25.539 +				c_stmt0( "else{\n")
  25.540 +			end if
  25.541 +			if array_index = -1 then
  25.542 +				c_stmt( sprintf("*(%s*)@ = (%s)DBL_PTR( @ )->dbl;\n", {type_name, type_name}), { target, val }, target )
  25.543 +			else
  25.544 +				c_stmt( sprintf("((%s*)@)[%d] = (%s)DBL_PTR( _1 )->dbl;\n", {type_name, array_index, type_name}), { target }, target )
  25.545 +			end if
  25.546 +			
  25.547 +			if not is_double then
  25.548 +				c_stmt0( "}\n")
  25.549 +			end if
  25.550 +		
  25.551 +		case MEMUNION then
  25.552 +			-- TODO
  25.553 +		case MEMSTRUCT then
  25.554 +			-- TODO
  25.555 +		case else
  25.556 +			integer is_integer = TypeIs( val, TYPE_INTEGER )
  25.557 +			if not is_integer then
  25.558 +				if array_index = -1 then
  25.559 +					c_stmt( "if( IS_ATOM_INT( @ ) ){\n", val )
  25.560 +				else
  25.561 +					c_stmt0( "if( IS_ATOM_INT( _1 ) ){\n" )
  25.562 +				end if
  25.563 +			end if
  25.564 +			
  25.565 +			if array_index = -1 then
  25.566 +				c_stmt( sprintf("*(%s*) @ = (%s) @;\n", {type_name, type_name}), {target, val}, target )
  25.567 +			else
  25.568 +				c_stmt( sprintf("((%s*) @)[%d] = (%s) _1;\n", {type_name, array_index, type_name}), {target }, target )
  25.569 +			end if
  25.570 +			
  25.571 +			if not is_integer then
  25.572 +				c_stmt0("}\n" )
  25.573 +				c_stmt0( "else{\n")
  25.574 +				if array_index = -1 then
  25.575 +					c_stmt( sprintf("*(%s*) @ = (%s) DBL_PTR( @ )->dbl;\n", {type_name, type_name}), {target, val}, target )
  25.576 +				else
  25.577 +					c_stmt( sprintf("((%s*) @)[%d] = (%s) DBL_PTR( _1 )->dbl;\n", {type_name, array_index, type_name}), {target }, target )
  25.578 +				end if
  25.579 +				c_stmt0("}\n" )
  25.580 +			end if
  25.581 +	end switch
  25.582 +end procedure
  25.583 +
  25.584 +--**
  25.585 +-- Stores the value into the memory pointed to by _0
  25.586 +procedure poke_member( symtab_index target, symtab_index member, symtab_index val, integer deref_ptr )
  25.587 +	integer data_type = SymTab[member][S_TOKEN]
  25.588 +	integer signed    = SymTab[member][S_MEM_SIGNED]
  25.589 +	
  25.590 +	sequence type_name = mem_name( sym_token( member ) )
  25.591 +	
  25.592 +	if SymTab[member][S_MEM_POINTER] and not deref_ptr then
  25.593 +		data_type = MS_OBJECT
  25.594 +		signed    = 0
  25.595 +		type_name = "object"
  25.596 +	end if
  25.597 +	
  25.598 +	if not signed then
  25.599 +		switch data_type do
  25.600 +			case MS_OBJECT then
  25.601 +				type_name = "uintptr_t"
  25.602 +			case MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
  25.603 +			case else
  25.604 +				type_name = "unsigned " & type_name
  25.605 +		end switch
  25.606 +	end if
  25.607 +	
  25.608 +	if SymTab[member][S_MEM_ARRAY] and memaccess = MEMSTRUCT_ACCESS then
  25.609 +		c_stmt("switch( SEQ_PTR( @ )->length ){\n", val )
  25.610 +		c_stmt0("default:\n")
  25.611 +		for i = SymTab[member][S_MEM_ARRAY] to 1 by -1 do
  25.612 +			c_stmt0( sprintf("case %d:\n", i ) )
  25.613 +			poke_member_value( target, val, data_type, type_name, i-1 )
  25.614 +		end for
  25.615 +		c_stmt0("case 0: ;\n")
  25.616 +		c_stmt0("}\n")
  25.617 +	else
  25.618 +		poke_member_value( target, val, data_type, type_name, -1 )
  25.619 +	end if
  25.620 +	memaccess = MEMSTRUCT_ACCESS
  25.621 +end procedure
  25.622 +
  25.623 +procedure poke_memstruct( symtab_index target, symtab_index struct_sym, symtab_index member, integer subscript )
  25.624 +	integer data_type = SymTab[member][S_TOKEN]
  25.625 +	integer signed    = SymTab[member][S_MEM_SIGNED]
  25.626 +	
  25.627 +	sequence type_name
  25.628 +	
  25.629 +	if SymTab[member][S_MEM_POINTER] then
  25.630 +		data_type = MS_OBJECT
  25.631 +		signed    = 0
  25.632 +		type_name = "object"
  25.633 +	else
  25.634 +		type_name = mem_name( sym_token( member ) )
  25.635 +	end if
  25.636 +	
  25.637 +	sequence rhs
  25.638 +	if subscript then
  25.639 +		rhs = sprintf( "src_s1->base[%d]", subscript )
  25.640 +	else
  25.641 +		rhs = "0"
  25.642 +	end if
  25.643 +	
  25.644 +	switch data_type do
  25.645 +		case MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
  25.646 +			
  25.647 +			if subscript then
  25.648 +				c_stmt0( sprintf( "if( IS_ATOM_INT( %s ) ){\n", { rhs } ) )
  25.649 +			end if
  25.650 +				c_stmt( sprintf("((struct %s*)@)->%s = (%s)%s;\n",
  25.651 +								{ decorated_name( struct_sym), decorated_name( member) ,type_name, rhs}), { target }, target )
  25.652 +			if subscript then
  25.653 +				c_stmt0( "}\n" )
  25.654 +				c_stmt0( "else{\n")
  25.655 +					c_stmt( sprintf("((struct %s*)@)->%s = (%s)DBL_PTR( %s )->dbl;\n",
  25.656 +								{decorated_name( struct_sym), decorated_name( member) , type_name, rhs}), { target }, target )
  25.657 +				c_stmt0( "}\n")
  25.658 +			end if
  25.659 +		case MEMUNION then
  25.660 +			-- TODO
  25.661 +		case MEMSTRUCT then
  25.662 +			-- TODO
  25.663 +		case else
  25.664 +			if not signed then
  25.665 +				if data_type = MS_OBJECT then
  25.666 +					type_name = "uintptr_t"
  25.667 +				else
  25.668 +					type_name = "unsigned " & type_name
  25.669 +				end if
  25.670 +			end if
  25.671 +			if subscript then
  25.672 +				c_stmt0( sprintf("if( IS_ATOM_INT( %s ) ){\n", {rhs} ) )
  25.673 +			end if
  25.674 +				c_stmt( sprintf("((struct %s*) @)->%s = (%s) %s;\n",
  25.675 +							{decorated_name( struct_sym), decorated_name( member) , type_name, rhs}), {target}, target )
  25.676 +			if subscript then
  25.677 +				c_stmt0("}\n" )
  25.678 +				c_stmt0( "else{\n")
  25.679 +				c_stmt( sprintf("((struct %s*) @)->%s = (%s) DBL_PTR( %s )->dbl;\n",
  25.680 +								{decorated_name( struct_sym), decorated_name( member) , type_name, rhs}), {target}, target )
  25.681 +				c_stmt0("}\n" )
  25.682 +			end if
  25.683 +			
  25.684 +	end switch
  25.685 +end procedure
  25.686 +
  25.687 +function set_up_assign_sequence( integer source_val )
  25.688 +	
  25.689 +	atom seqlen
  25.690 +	integer is_sequence = TypeIs( source_val, TYPE_SEQUENCE )
  25.691 +	
  25.692 +	
  25.693 +	c_stmt0("s1_ptr src_s1;\n")	
  25.694 +	
  25.695 +	if is_sequence then
  25.696 +		-- see if we know how big the sequence is:
  25.697 +		seqlen = SeqLen( source_val )
  25.698 +		c_stmt("src_s1 = SEQ_PTR( @ );\n", source_val )
  25.699 +	else
  25.700 +		c_stmt0("int free_src;\n" )
  25.701 +		-- might be an atom
  25.702 +		seqlen = NOVALUE
  25.703 +		c_stmt("if( IS_ATOM( @ ) || IS_ATOM_INT( @ ) ){\n", { source_val, source_val } )
  25.704 +			c_stmt0("free_src = 1;\n")
  25.705 +			c_stmt0("src_s1 = NewS1( 1 );\n" )
  25.706 +			c_stmt("src_s1->base[1] = @;\n", source_val )
  25.707 +		c_stmt0("}\n")
  25.708 +		c_stmt0("else {\n" )
  25.709 +			c_stmt0("free_src = 0;\n")
  25.710 +			c_stmt("src_s1 = SEQ_PTR( @ );\n", source_val )
  25.711 +		c_stmt0("}\n")
  25.712 +	end if
  25.713 +	return is_sequence & seqlen
  25.714 +end function
  25.715 +
  25.716 +procedure assign_memstruct( integer pointer, integer struct_sym, integer source_val )
  25.717 +	-- use a private block
  25.718 +	c_stmt0("{\n")
  25.719 +	sequence seq_len     = set_up_assign_sequence( source_val )
  25.720 +	integer  is_sequence = seq_len[1]
  25.721 +	atom     seqlen      = seq_len[2]
  25.722 +	
  25.723 +	integer members = 0
  25.724 +	integer member_sym = struct_sym
  25.725 +	sequence member_list = {}
  25.726 +	while member_sym with entry do
  25.727 +		members += 1
  25.728 +		member_list &= member_sym
  25.729 +	entry
  25.730 +		member_sym = SymTab[member_sym][S_MEM_NEXT]
  25.731 +	end while
  25.732 +	
  25.733 +	if seqlen != NOVALUE then
  25.734 +		integer ix = 1
  25.735 +		member_sym = SymTab[struct_sym][S_MEM_NEXT]
  25.736 +		while ix <= seqlen and member_sym do
  25.737 +			poke_memstruct( pointer, struct_sym, member_sym, ix )
  25.738 +			ix += 1
  25.739 +			member_sym = SymTab[member_sym][S_MEM_NEXT]
  25.740 +		end while
  25.741 +		
  25.742 +		while member_sym do
  25.743 +			-- zero out the rest
  25.744 +			poke_memstruct( pointer, struct_sym, member_sym, 0 )
  25.745 +			member_sym = SymTab[member_sym][S_MEM_NEXT]
  25.746 +		end while
  25.747 +	else
  25.748 +		-- unknown length:
  25.749 +		c_stmt0( "switch( src_s1->length ){\n" )
  25.750 +			-- the sequence is bigger than the struct:
  25.751 +			c_stmt0("default:\n")
  25.752 +			for i = members to 1 by -1 do
  25.753 +				c_stmt0( sprintf( "case %d:\n", i ) )
  25.754 +				poke_memstruct( pointer, struct_sym, member_list[i], i )
  25.755 +			end for
  25.756 +			c_stmt0( "case 0: break;\n" )
  25.757 +		c_stmt0("}\n")
  25.758 +		
  25.759 +		c_stmt0( "switch( src_s1->length + 1 ){\n" )
  25.760 +			for i = 0 to members do
  25.761 +				c_stmt0( sprintf( "case %d:\n", i ) )
  25.762 +				if i then
  25.763 +					poke_memstruct( pointer, struct_sym, member_list[i], 0 )
  25.764 +				end if
  25.765 +			end for
  25.766 +			c_stmt0("default: break;\n")
  25.767 +		c_stmt0("}\n")
  25.768 +	end if
  25.769 +	
  25.770 +	if not is_sequence then
  25.771 +		c_stmt0("if( free_src ){\n")
  25.772 +		c_stmt0("DeRefDS( MAKE_SEQ(src_s1) );\n")
  25.773 +		c_stmt0("}\n" )
  25.774 +	end if
  25.775 +	
  25.776 +	c_stmt0("}\n")
  25.777 +end procedure
  25.778 +
  25.779 +procedure assign_memunion( integer pointer, integer struct_sym, integer source_val )
  25.780 +	c_stmt0("{\n")
  25.781 +	c_stmt0("unsigned char *ptr;\n")
  25.782 +	c_stmt0("int i;\n")
  25.783 +	sequence seq_len     = set_up_assign_sequence( source_val )
  25.784 +	integer  is_sequence = seq_len[1]
  25.785 +	atom     seqlen      = seq_len[2]
  25.786 +	
  25.787 +	integer union_size = SymTab[struct_sym][S_MEM_SIZE]
  25.788 +	
  25.789 +	c_stmt("ptr = (unsigned char *) @;\n", pointer )
  25.790 +	if seqlen = NOVALUE then
  25.791 +		-- unknown length
  25.792 +		c_stmt0(sprintf("for( i = 1; i <= src_s1->length && i <= %d; ++i, ++ptr ){\n", union_size ) )
  25.793 +			c_stmt0("*ptr = (unsigned char) src_s1->base[i];\n")
  25.794 +		c_stmt0("}\n")
  25.795 +		
  25.796 +		c_stmt0(sprintf("for( i = src_s1->length + 1; i <= %d; ++i, ++ptr ){\n", union_size ) )
  25.797 +			c_stmt0("*ptr = 0;\n")
  25.798 +		c_stmt0("}\n")
  25.799 +		
  25.800 +	else
  25.801 +		-- we know the length
  25.802 +		if seqlen > union_size then
  25.803 +			seqlen = union_size
  25.804 +		end if
  25.805 +		
  25.806 +		for i = 1 to seqlen do
  25.807 +			c_stmt0( sprintf("*ptr++ = (unsigned char) src_s1->base[%d];\n", i ) )
  25.808 +		end for
  25.809 +		
  25.810 +		for i = seqlen + 1 to union_size do
  25.811 +			c_stmt0( "*ptr++ = 0;\n" )
  25.812 +		end for
  25.813 +	end if
  25.814 +	
  25.815 +	if not is_sequence then
  25.816 +		c_stmt0("if( free_src ){\n")
  25.817 +		c_stmt0("DeRefDS( MAKE_SEQ(src_s1) );\n")
  25.818 +		c_stmt0("}\n" )
  25.819 +	end if
  25.820 +	c_stmt0("}\n")
  25.821 +end procedure
  25.822 +
  25.823 +
  25.824 +export procedure opMEMSTRUCT_ASSIGN()
  25.825 +	integer
  25.826 +		pointer   = Code[pc+1],
  25.827 +		member    = Code[pc+2],
  25.828 +		val       = Code[pc+3],
  25.829 +		deref_ptr = Code[pc+4]
  25.830 +	
  25.831 +	get_pointer( pointer, pointer )
  25.832 +	
  25.833 +	integer tok = sym_token( member )
  25.834 +	if SymTab[member][S_MEM_POINTER] then
  25.835 +		if deref_ptr then
  25.836 +			c_stmt( "@ = *(intptr_t*)@;\n", { pointer, pointer }, pointer )
  25.837 +		else
  25.838 +			tok = MS_MEMBER
  25.839 +		end if
  25.840 +	end if
  25.841 +	
  25.842 +	switch tok do
  25.843 +		case MEMSTRUCT then
  25.844 +			assign_memstruct( pointer, member, val )
  25.845 +		case MEMUNION then
  25.846 +			assign_memunion( pointer, member, val )
  25.847 +		case else
  25.848 +			poke_member( pointer, member, val, deref_ptr )
  25.849 +	end switch
  25.850 +	
  25.851 +	
  25.852 +	dispose_temp( val, compile:DISCARD_TEMP, REMOVE_FROM_MAP )
  25.853 +	remove_pointer( pointer )
  25.854 +	
  25.855 +	pc += 5
  25.856 +end procedure
  25.857 +
  25.858 +
  25.859 +export procedure opMEMSTRUCT_ASSIGNOP()
  25.860 +	integer
  25.861 +		op        = Code[pc],
  25.862 +		pointer   = Code[pc+1],
  25.863 +		member    = Code[pc+2],
  25.864 +		val       = Code[pc+3],
  25.865 +		deref_ptr = Code[pc+4]
  25.866 +	
  25.867 +	get_pointer( pointer, pointer )
  25.868 +	
  25.869 +	if deref_ptr then
  25.870 +		c_stmt( "@ = *(intptr_t**) @;\n", { pointer, pointer }, pointer )
  25.871 +	end if
  25.872 +	sequence optext
  25.873 +	switch op do
  25.874 +		case MEMSTRUCT_PLUS then
  25.875 +			optext = "+"
  25.876 +		case MEMSTRUCT_MINUS then
  25.877 +			optext = "-"
  25.878 +		case MEMSTRUCT_DIVIDE then
  25.879 +			optext = "/"
  25.880 +		case MEMSTRUCT_MULTIPLY then
  25.881 +			optext = "*"
  25.882 +	end switch
  25.883 +	
  25.884 +	integer data_type = sym_token( member )
  25.885 +	sequence type_name = mem_name( data_type )
  25.886 +	switch data_type do
  25.887 +		case MS_FLOAT, MS_DOUBLE, MS_LONGDOUBLE, MS_EUDOUBLE then
  25.888 +			integer is_double = TypeIs( val, TYPE_DOUBLE )
  25.889 +			if not is_double then
  25.890 +				c_stmt( "if( IS_ATOM_INT( @ ) ){\n", val )
  25.891 +					c_stmt( sprintf("*(%s*)@ %s= (%s)@;\n", {type_name, optext, type_name}), { pointer, val }, pointer )
  25.892 +				c_stmt0( "}\n" )
  25.893 +				c_stmt0( "else{\n")
  25.894 +			end if
  25.895 +			
  25.896 +			c_stmt( sprintf("*(%s*)@ %s= (%s)DBL_PTR( @ )->dbl;\n", {type_name, optext, type_name}), { pointer, val }, pointer )
  25.897 +			
  25.898 +			if not is_double then
  25.899 +				c_stmt0( "}\n")
  25.900 +			end if
  25.901 +		
  25.902 +		case MEMUNION then
  25.903 +			-- TODO
  25.904 +		case MEMSTRUCT then
  25.905 +			-- TODO
  25.906 +		case else
  25.907 +			integer is_integer = TypeIs( val, TYPE_INTEGER )
  25.908 +			if not is_integer then
  25.909 +				c_stmt( "if( IS_ATOM_INT( @ ) ){\n", val )
  25.910 +			end if
  25.911 +			
  25.912 +			c_stmt( sprintf("*(%s*) @ %s= (%s) @;\n", {type_name, optext, type_name}), {pointer, val}, pointer )
  25.913 +			
  25.914 +			if not is_integer then
  25.915 +				c_stmt0("}\n" )
  25.916 +				c_stmt0( "else{\n")
  25.917 +				c_stmt( sprintf("*(%s*) @ %s= (%s) DBL_PTR( @ )->dbl;\n", {type_name, optext, type_name}), {pointer, val}, pointer )
  25.918 +				c_stmt0("}\n" )
  25.919 +			end if
  25.920 +	end switch
  25.921 +	dispose_temp( val, compile:DISCARD_TEMP, REMOVE_FROM_MAP )
  25.922 +	remove_pointer( pointer )
  25.923 +	pc += 5
  25.924 +end procedure
  25.925 +
  25.926 +export procedure opADDRESSOF()
  25.927 +	integer
  25.928 +		ptr    = Code[pc+1],
  25.929 +		target = Code[pc+2]
  25.930 +	CDeRef( target )
  25.931 +	c_stmt("if( IS_ATOM_INT( @ ) ){\n", ptr )
  25.932 +		c_stmt("@ = @;\n", { target, ptr }, target )
  25.933 +	c_stmt0("}\n")
  25.934 +	c_stmt0("else {\n")
  25.935 +		c_stmt("@ = NewDouble( (eudouble) @ );\n", {target, ptr}, target )
  25.936 +	c_stmt0( "}\n")
  25.937 +	SetBBType( target, TYPE_ATOM, {MININT, MAXINT}, TYPE_OBJECT, 0 )
  25.938 +	
  25.939 +	pc += 3
  25.940 +end procedure
  25.941 +
  25.942 +export procedure opOFFSETOF()
  25.943 +	integer
  25.944 +		member  = Code[pc+1],
  25.945 +		target  = Code[pc+2],
  25.946 +		parent  = SymTab[member][S_MEM_PARENT]
  25.947 +	
  25.948 +	CDeRef( target )
  25.949 +	sequence 
  25.950 +		memstruct_name = decorated_name( parent ),
  25.951 +		member_name    = decorated_name( member )
  25.952 +	c_stmt( sprintf("@ = offsetof( %s %s, %s);\n", { mem_name( sym_token( parent ) ), memstruct_name, member_name } ), { target }, target )
  25.953 +	
  25.954 +	pc += 3
  25.955 +end procedure
  25.956 +
  25.957 +function decorated_name( symtab_index sym )
  25.958 +	return sprintf( "_%d%s", { SymTab[sym][S_FILE_NO], sym_name( sym ) } )
  25.959 +end function
  25.960 +
  25.961 +function mem_name( integer tid )
  25.962 +	switch tid do
  25.963 +		case MS_CHAR then
  25.964 +			return "char"
  25.965 +		case MS_SHORT then
  25.966 +			return "short"
  25.967 +		case MS_INT then
  25.968 +			return "int"
  25.969 +		case MS_LONG then
  25.970 +			return "long"
  25.971 +		case MS_OBJECT then
  25.972 +			return "object"
  25.973 +		case MS_LONGLONG then
  25.974 +			return "long long int"
  25.975 +		case MS_FLOAT then
  25.976 +			return "float"
  25.977 +		case MS_DOUBLE then
  25.978 +			return "double"
  25.979 +		case MS_LONGDOUBLE then
  25.980 +			return "long double"
  25.981 +		case MS_EUDOUBLE then
  25.982 +			return "eudouble"
  25.983 +		case MEMSTRUCT then
  25.984 +			return "struct"
  25.985 +		case MEMUNION then
  25.986 +			return "union"
  25.987 +		case MS_MEMBER then
  25.988 +			return ""
  25.989 +		case else
  25.990 +			InternalErr("error finding name for token: [1] [2]", { tid, LexName( tid ) })
  25.991 +	end switch
  25.992 +end function
  25.993 +
  25.994 +function get_data_type( symtab_index member )
  25.995 +	integer data_type = SymTab[member][S_TOKEN]
  25.996 +	sequence name = ""
  25.997 +	
  25.998 +-- 	printf(1, "Writing data type for: %s - %s\n", { sym_name(member), LexName( data_type )})
  25.999 +	-- signed / unsigned
 25.1000 +	if not SymTab[member][S_MEM_SIGNED]
 25.1001 +	and data_type != MS_OBJECT
 25.1002 +	and data_type != MS_MEMBER
 25.1003 +	and data_type != MS_FLOAT
 25.1004 +	and data_type != MS_DOUBLE 
 25.1005 +	and data_type != MS_LONGDOUBLE 
 25.1006 +	and data_type != MS_EUDOUBLE
 25.1007 +	then
 25.1008 +		-- floating points are always marked signed
 25.1009 +		name &= "unsigned "
 25.1010 +	end if
 25.1011 +	
 25.1012 +	if data_type = MS_OBJECT and not SymTab[member][S_MEM_SIGNED] then
 25.1013 +		-- this one can't just take an unsigned
 25.1014 +		name &= "uintptr_t "
 25.1015 +	elsif data_type != MS_MEMBER then
 25.1016 +		name &= sprintf( "%s ", { mem_name( data_type )})
 25.1017 +	else
 25.1018 +		data_type = SymTab[SymTab[member][S_MEM_STRUCT]][S_TOKEN]
 25.1019 +		if data_type = MEMUNION then
 25.1020 +			-- embedded union
 25.1021 +			name &= sprintf( "union %s ", {decorated_name( SymTab[member][S_MEM_STRUCT] ) } )
 25.1022 +		else
 25.1023 +			-- embedded struct
 25.1024 +			name &= sprintf( "struct %s ", {decorated_name( SymTab[member][S_MEM_STRUCT] ) } )
 25.1025 +		end if
 25.1026 +	end if
 25.1027 +	
 25.1028 +	if SymTab[member][S_MEM_POINTER] then
 25.1029 +		name &= "*"
 25.1030 +	end if
 25.1031 +	return name
 25.1032 +end function
 25.1033 +
 25.1034 +procedure write_data_type( atom struct_h, symtab_index member )
 25.1035 +	puts( struct_h, get_data_type( member ) )
 25.1036 +end procedure
 25.1037 +
 25.1038 +procedure write_memstruct( atom struct_h, symtab_index sym )
 25.1039 +	symtab_pointer member = sym
 25.1040 +	while member with entry do
 25.1041 +		puts( struct_h, "\t" )
 25.1042 +		write_data_type( struct_h, member )
 25.1043 +		puts( struct_h, decorated_name( member ) )
 25.1044 +		if SymTab[member][S_MEM_ARRAY] then
 25.1045 +			printf( struct_h, "[%d]", SymTab[member][S_MEM_ARRAY] )
 25.1046 +		end if
 25.1047 +		printf( struct_h, "; // %d\n", SymTab[member][S_TOKEN] )
 25.1048 +	entry
 25.1049 +		member = SymTab[member][S_MEM_NEXT]
 25.1050 +	end while
 25.1051 +	puts( struct_h, "};\n\n" )
 25.1052 +end procedure
 25.1053 +
 25.1054 +export procedure write_struct_header()
 25.1055 +	atom struct_h = open( output_dir & "struct.h", "w", 1 )
 25.1056 +	generated_files = append( generated_files, "struct.h" )
 25.1057 +	
 25.1058 +	puts( struct_h, "#ifndef STRUCT_H_\n" )
 25.1059 +	puts( struct_h, "#define STRUCT_H_\n\n" )
 25.1060 +	puts( struct_h, "#include <stdint.h>\n")
 25.1061 +	puts( struct_h, "#include <stddef.h>\n")
 25.1062 +	puts( struct_h, "#include \"include/euphoria.h\"\n\n" )
 25.1063 +	
 25.1064 +	sequence structs = {}
 25.1065 +	for i = TopLevelSub to length( SymTab ) do
 25.1066 +		integer tok = sym_token( i )
 25.1067 +		if tok = MEMSTRUCT then
 25.1068 +			printf( struct_h, "struct %s %s;\n", repeat( decorated_name( i ), 2 ) )
 25.1069 +			structs &= i
 25.1070 +		elsif tok = MEMUNION then
 25.1071 +			printf( struct_h, "union %s %s;\n", repeat( decorated_name( i ), 2 ) )
 25.1072 +			structs &= i
 25.1073 +		end if
 25.1074 +	end for
 25.1075 +	
 25.1076 +	for i = 1 to length( structs ) do
 25.1077 +		integer tok = sym_token( structs[i] )
 25.1078 +		if tok = MEMSTRUCT then
 25.1079 +			printf( struct_h, "struct %s{\n", { decorated_name( structs[i] )} )
 25.1080 +			write_memstruct( struct_h, structs[i] )
 25.1081 +		elsif tok = MEMUNION then
 25.1082 +			printf( struct_h, "union %s{\n", { decorated_name( structs[i])} )
 25.1083 +			write_memstruct( struct_h, structs[i] )
 25.1084 +		end if
 25.1085 +	end for
 25.1086 +	
 25.1087 +	puts( struct_h, "#endif\n" )
 25.1088 +	
 25.1089 +end procedure