RiscLua with error throwback

I had an email from somebody which ended by suggesting that RiscLua would be a better tool for introduction to programming if it had error throwback to an editor. That started me thinking more about error-handling. I intend ultimately to bring out a version 5.80 of RiscLua which will incorporate a more thoughtful approach to this but in the meantime, here is how you can add throwback to version 5.70 – at least for programs that run in taskwindows – if you have a copy of the DDEUtils module.

1. In !lua.!Modules add the line

RMEnsure DDEUtils 0.0 RMLoad System:Modules.DDEUtils

2. Before the last line (lua %*0) of !lua.!Launch add the line

set LUA_INIT @lua570:prelude

3. Add a textfile called prelude to !lua.lib containing

-- RiscLua 5.70 prelude
-- GCW May 2015
--[[
By default this file is run by !RiscLua 5.70 before
any others. You can disable this behaviour by
unsetting the system variable LUA_INIT.
--]]

(getmetatable "").__call = string.format — strings as functions
local sys, dim, block in riscos
local z = “%s\0” — ascii nul terminate
local throwit
do -———- throwit -—————————-[
local Start, Send, End = 0×42587, 0×42588, 0×42589
throwit = \ (file, line, mesg)
local f = dim (z (file))
local m = dim (z (mesg))
sys (Start)
sys (Send, 0, 0, f)
sys (Send, 1, 0, f, line, 1, m)
sys (End)
— make f, m garbage-collectible
block[f] = nil
block[m] = nil
end — throwit
end -—————————————————-]
local throw
do -———— throw -——————————[
local erpat = “:%d+:%s(.+)$”
throw = \ (s)
local info = debug.getinfo (2, “Sl”)
local source, currentline in info
local file
if source:sub (1,1) == “@” then
file = source:sub (2)
else => end — if – not a filepath
local mesg = s:match (erpat)
if file and currentline  then
throwit (file, currentline, mesg or “??”)
end — if
=> s
end
end -—————————————————-]
riscos.throw = throw
riscos.taskwindow = (sys (0×43380, 0)) > 0
riscos.desktop = (sys (0×400f2, 0)) > 0

Here is a wee demo. Give it filetype Lua and run it by dragging
to the TaskW icon:

   local throw in riscos
   local function f (x, y) return x, y, x/y end
   local fmt = "%d / %d = %d"
   local function main ( ) print (fmt (f (10, 0))) end
   xpcall (main, throw)

As for throwback from wimp tasks – that is going to need a clean up of the wimp.task and wimp.tbox libraries, hence the need for a new version.

xxxx would be a better tool for introduction to programming if it had error throwback to an editor.

In the spirit of friendly rivalry, Basalt has provided THROW ERROR to BASIC for a long time. ;-)

It is also very simple to use Reporter’s *ReportError T or to write a simple error routine to use DDEUtils SWIs.

In the spirit of friendly rivalry, Basalt has provided THROW ERROR to BASIC for a long time ;-)

I can remember Joe Taylor programming error throwback for BASIC many years ago. There was some complication about line numbers – whether they should be logical or in steps of 10. This was in the years when working in the desktop was comparatively new. I think I am prepared to concede that BASIC has certain advantages over Lua for introduction to programming – there are fewer choices to be made. It provides ERL and REPORT$ and so on. Lua provides a fairly sophisticated debug library, which I had not previously dipped my toe into. One of the problems is pure Lua’s ability to catch errors – a function f when applied to arguments x may cause errors when y = f(x) is evaluated. By using instead y, err = pcall(f,x) the evaluation takes place in protected mode; if the original call succeeded then err is nil, but if it raised an error then y is nil and err is the error object – usually a string. In this way it is possible to write code so that all errors are lifted to the top level. This was designed so that Lua could be embedded in C programs in a secure way. RiscLua is not pure Lua, though. It has extra stuff for calling SWIs and so on, and it is generally impossible to be protected from the consequences of errors that may occur in that stuff.

Anyway I have begun to get throwback working with wimp programs now. I have gone for a new protocol for what handlers are. They are functions of two variables (s,f) where s is the state of the wimptask – a table – and f is a handler, and they return handlers. All nice and recursive. The nil handler causes an exit, and the central loop is

while f do f = f(s,f) end

poll = \ (self, _)
local mask, b, time in self
local event, err = sys(pollcode,mask or 0,b,time)
if event then
  => handler and handler[event] or poll
else throw(err) end -- if
end -- function

There was some complication about line numbers – whether they should be logical or in steps of 10.

It is still a problem and depends on the Throwback handling editor. The recommendation I give with THROW is to always number programs from 1 in steps of 1.

The other significant problem is with libraries – BASIC keeps no record of the file from which a library is loaded. I make some attempt to solve this with THROW, but it requires special construction of the REM> header line. Now that I have revisted this, I have some new ideas about solving that problem, but see below.

Reporter does not deal with libraries either, but I have only just realised that it provides throwback for non-wimp programs, because it is itself a wimp application. Despite Basalt’s THROW, I would now recommend Reporter for this, perhaps using the keywords REPORT ERROR EXT. ;-)

pure Lua’s ability to catch errors

Basalt does provide a method to catch errors, but I have never detected a great demand for it. ;-(

Basalt does provide a method to catch errors, but I have never detected a great demand for it. ;-(

Oh I don’t know? I have used to to great effect :@)

Reporter does not deal with libraries either

Oddly enough, the version I have been using here for some time (and is edging towards release) does – if the first line of the Basic library gives the library name relative to the main program eg…
REM > BasicLibrary

the error Reported is…
15:55:24.75 ** BasicError ** ERR=254 Division by zero ERL=140 [in "BasicLibrary"]

If the first line is the full path eg…
REM > "<Reporter$Dir>.TestProgs.Basic.BasicLibrary"

the error Reported is …
15:53:32.47 ** BasicError ** ERR=254 Division by zero ERL=140 [in "<Reporter$Dir>.TestProgs.Basic.BasicLibrary"]

Throwback works in both cases.

… provides throwback for non-wimp programs, because it is itself a wimp application.

A good tip. Calling DDEUtils from a non-wimp program and outside a taskwindow achieves nothing.

No problems with libraries in Lua, or code compiled from external files, so long as one avoids dofile which does not evaluate in protected mode. So if a file X in the current directory contains

 return function(n) return n/0 end

local throw in riscos
f = loadfile "X"
function main () print (f()(7)) end
xpcall (main, throw)

Throwback works in both cases.

I look forward to the release of the new version. I will say again that Reporter is a much simpler debugging tool than BASIC’s own, even with the enhancements that Basalt includes – THROW ERROR with libraries was added in 2003. ;-)

The examples are very similar to Basalt and would both work until a couple of years ago. Up until then Prefix was set for the program, but I had to remove this as an automatic feature, because it affected the Font SWIs. So, the first example no longer works, but it is easy to implement another way if I revist it. I otherwise recommend the usefulness of setting Prefix in the !Run file.

In Basalt there is also the option for the first line to be written as a library name and a filename, separated by @. This separation is useful elswhere

The significant problem, though, is the danger of copying a library from one place to another without changing the first line. My idea would be to use the Basalt LIBRARY function to store the actual filename along with the library code.

An overactive imagination has come up with the alternative idea of copying the library code to a scrap file before invoking Throwback. ;-)

Steve: rather than hijacking this thread further, I will contact you directly.