RiscLua 7

But I challenge him to dream up a datatype in C that cannot be expressed using tables in Lua, and furthermore in a way that makes no reference to particular addresses in memory.

You mean Lua stores its data without a reference to a particular address in memory? Now that would be a most impressive technology :-)

If I were Rick, I would dream up a datatype that must match a particular memory layout because it accesses a hardware API that needs it in that particular way.

It is pointer-arithmetic that I would ascribe to Cthulhu.

No need to use pointer arithmetic in C for even the most complex data types. Anyway, pointer arithmetic is overrated as the “root of all evil” for many common programming errors. Try dangling pointers, off-by-one, invalid cast, failed malloc and “no or wrong free” for a start.

It is a shame that Netscape lacks

NetScape?
There hasn’t been such a thing since early 2008. Ten years ago. An eternity on the Internet.

But I challenge him to dream up a datatype in C that cannot be expressed using tables in Lua,

No idea what a Lua table is.

and furthermore in a way that makes no reference to particular addresses in memory.

Pretty much every variable beyond the most basic data types is associated with an address in some manner. You might just not realise it.

DIM x% 11
x%!0 = 7
x%!4 = 44
x%!8 = 9

What’s ‘x%’? Oh, that’s right. It’s a variable pointing to a bit of memory, with the ! syntax meaning “write a word at address plus offset”.

C is a bit like that too, although moreso (as strings are actually arrays of bytes).

I would imagine that Lua is also similar, otherwise it would fail the moment that you need to pass a pointer to something (which happens a lot in the RISC OS API).

It is pointer-arithmetic that I would ascribe to Cthulhu.

Absolutely. I won’t argue that.

However, if you take an address (you can’t get around them – parameters to a SWI? return from memory claims?) and assign it to a struct, you can then access it as elements of a structure. All the pointer magic happens behind the scenes. Don’t try to do it yourself. You’ll fail. Pointer maths is hard and extremely liable to blowing up (given what you’re dealing with). So this[count].that[element] = TRUE; is a lot safer than trying to work out where that is offset from ‘this’.

Netscape?

Sorry, NetSurf. Senior moment.

You mean Lua stores its data without a reference to a particular address in memory?

No. Of course it does, internally. But the Lua programmer has no way of referencing it. There are two aspects to Lua: the Lua-programmer’s and the C-programmer’s. From the C perspective Lua is just a C library to be linked with sources of some host application, so that the application is extended with an interpreter for Lua scripts. From the Lua perspective, the Lua language gives no way of referencing the hardware platform. No peeking or poking or references to anything OS- or machine-dependent.

I would imagine that Lua is also similar, otherwise it would fail the moment that you need to pass a pointer to something (which happens a lot in the RISC OS API).

Lua is not similar.

No idea what a Lua table is.

That is where your problem lies. A table is a pointer
to an address of a structure in the heap. There is no way programmatically to find out what the address actually is. It can be moved by the garbage-collector after all. The programmer has no business asking what it is :). Lua is very hot on hiding information. As you say yourself the pointer magic happens behind the scenes .

Because Lua is designed to be embedded it cannot presume the existence of error-handlers or this or that resource, apart from the IO that ANSI C presumes. It cannot know about directories, for example, because ANSI C does not. Every now and then there are clamours for Posix compliance, but to give in to them would narrow Lua’s universality. To be sure, Lua distributions for Unix usually offer Posix operations, just as RiscLua offers SYS calls, but these are not part of the Lua core but extras provided by separate libraries.

This emphasis on security and machine-independence in Lua made it hard to marry with the many insecurities and compromises that are found everywhere in RISC OS. The earliest versions of RiscLua tried to mitigate these: for example, there were expensive bound-checks on peeking and poking buffers in memory. That policy failed because RISC OS has insufficient typing; the PRMs do not always tell you what type of value is in a particular register when an SWI returns: a Boolean, a number, a memory address, an offset, … ? In the end I swallowed my pride and made the same kludge that BASIC makes – confuse numbers with addresses.

The only mutable datatype in Lua is the table. How tables are represented in memory is very interesting, quite cunning, and again not something the programmer should be concerned with. Tables themselves can be values, or keys, in other tables, and in themselves. How about t = { [t] = t }? This defines a table with a single key, itself, and whose value at that key, t[t], is itself again. The diagrams one draws to illustrate this sort of thing are pretty much the same as those for the data-structures in C defined by pointer-references. My challenge was really just the assertion that you do not have to have explicit memory-addresses and pointers in order to define complex datatypes.

In RiscLua, courtesy of the riscos library, but not in pure Lua, you can have

local dim, !, block in require "riscos"
local x = dim (12)
![x] = 7
![x + 4] = 44
![x + 8] = 9

More on tables here.

http://www.wra1th.plus.com/lua/notes/Tables.html

Knowing the numerical value of x helps not at all.

If you want to pass it to a system API, you’ll need some way of exposing the value.
This was a kludge that I found amusing in TurboPascal; a lot of APIs use addresses of stuff and Pascal bends over backwards to hide such things, so they had to add something (might have been an & prefix, like C) to get at the address.

Having said this, why are we talking about tables and whether or not Lua can do better than C with hidden pointer magic? If it’s because of my dislike of dynamic typing, you might be a little mistaken.
It’s this that I dislike:

var = "three"
print car
var = 3
print var

I just made that up, don’t bother to syntax check it. The point is, it’s a variable that’s a string, a real, and number, a date, or whatever else the just language supports. Which is which? Depends upon how you use it… But it can lead to weird bugs, like:

; param1 is the value "3" from the input parameters
; param2 is the value "4" likewise
var = param1 + param2
; what's var now?

How that behaves is language defined. Some languages (I think PHP is one) will give that expected answer ‘7’ because it will demote to a number of it makes sense in context. Other languages (VB, I think?) will blindly add the two strings to give a string result – “34”.
At least with defined types and casting¹ you, the programmer, will know what is actually happening with those values.

¹ Actually you can’t cast a string number into an integer in C, if you tried the best you’d get is the ASCII code of the first number. You need something like atoi() to explicitly change the string (array) to integer.

The other way of avoiding problems about whether "4"+"7" should be “47” or 11 is to have different operators. After all, they are different operations!

Perl takes this approach, with + for addition and . for concatenation. Similarly < > <= >= != and == for numeric tests, and lt gt le ge ne eq for string tests.

It is much clearer than PHP and less likely to lead you into difficulties.

Back on topic though—what is Lua and why should I be using it on RISC OS and what for?

Lua is really nice, and I agree with Gavin that it would be much better if new RISC OS programmers started learning Wimp application development using Lua rather than BASIC, as it is a much more powerful language (if you overlook the BASIC assembler, of course). There are libraries to write Toolbox and plain Wimp applications in Lua, but not enough tutorial material yet — the main advantage of BASIC is the sheer number of articles and example applications you can study.

Lua is also very good as an embedded scripting language. Hilary uses it in House of Cards for the game definitions.

Using + for string concatenation is horrible. So is coercion between strings and numbers. Lua uses x..y by default for the concatenation of strings x and y. It should be pointed out that by using metamethods a great deal of Lua’s notation can be altered or extended by the user. This goes for all operation symbols. If you wanted to use + for concatenation of strings all you have to do in RiscLua is

*lua
Lua 5.4.0  Copyright (C) 1994-2018 Lua.org, PUC-Rio
RiscLua 7
> (getmetatable "").__add = \ (x,y) => x..y end
> print ("hello" + " " + "there")
hello there

You can decorate Lua code with type-assertions like this:

the = \ (t, x)
  local typerr = "expecting a %s but got a %s"
  local s = typerr (t, type (x))
  => assert (x, s) end
print (the ("string", 57))

57  expecting a string but got a number

I am glad to see RiscLua is being maintained and improved. I haven’t really done anything in Lua yet, but it is on my to-learn list. :-)

Steffen said

common programming errors. Try dangling pointers, off-by-one, invalid cast, failed malloc

• Assumption of success (absence of failure handling)
• Missing break;
• Sanity checking of parameters
• Undefined behaviour
• False corollary
• int/ptr/bool confusion

Rick complained of dynamic typing

The point is, it’s a variable that’s a string, a real, and number, a date, or whatever else the just language supports. Which is which?

And yet:

DEFFNjustLikeBasicThen(T%)
CASET%OF
WHEN1:=TRUE
WHEN2:=2
WHEN3:=PI
WHEN4:="For?"
ENDCASE

Gavin wrote

More on tables

Unfortunately you’ve broken that link, Gavin.

However, on your actual page you claim

[Tables] combine many ideas that are separate, or do not exist, in other programming languages

A straw man argument. May not exist in some other programming languages, but in others they definitely do. Tables are associate arrays and are available under various names in many languages, such as Python, Javascript, PostScript, Ruby, and even Perl.

Lua is not special here. There’s a much stronger argument that Javascript objects are unlike other associative arrays because of their prototypical inheritance, but that can be implemented using a magic key in other languages too.

Rick parted with

you can’t cast a string number into an integer in C, if you tried the best you’d get is the ASCII code of the first number

You’re guaranteed to never get that. Since “a string” in C is a char * (or in Windows programs, often a wchar_t *) then casting it to int will probably result in (an integer directly correlated with) the address of the string, dependent on your int and ptr sizes. If you used an intptr_t you’d be certain of it.

Unfortunately you’ve broken that link, Gavin.

Sorry. I think the Textile help is wrong.

Lua is not special here.

I think Lua’s tables are special in that keys and values can be any non-nil value. Also, I do not think other languages have the concept of metatables .

I have just updated the Utilities in the RiscLua 7 distribution with !Linker and !Absolua. These let you create standalone Absolute versions your Lua programs, which will run on computers that do not have the RiscLua interpreter.

Some minor changes in RiscLua 7:

1. Format strings can behave like functions, with one
   argument for each format specifier. Thus

   brace = "{%s}"
   print (brace (girdle)) --> {girdle}

2. The function obey$dir when called with no arguments
   returns the path of the directory containing the program.
3. Global variables, when first defined, must be prefixed by the word global. or else they will raise an error when used. This does not apply to variables defined in the environment of a table, unless the table is the global environment _G.

   *lua
   Lua 5.4.0  Copyright (C) 1994-2018 Lua.org, PUC-Rio
   RiscLua 7.1
   > x = true
   stdin:1: 
   attempt to write to undeclared variable x
   stack traceback:
           [C]: in function 'error'
           rlua7:prelude:15: in metamethod 'newindex'
           stdin:1: in main chunk
           [C]: in ?
   > global.x = true
   >

   This may help debugging for those not used to keeping track of the scope of their variables. You can turn this feature off by commenting out the relevant bits of the prelude, if you resent the
   nannying;)

Libraries do not have to live in rlua7:lib. If you want to use a library mylib in the same directory as your program, just start your code with

local path in package
local here, mylib = obey$dir ( ), ".mylib.?"
package.path = ("%s,%s.%s") (path, here, mylib)

There does seem to be some difference though as AppLua works fine on RiscLua 5 and 6 but it fails on version 7 (segmentation fault; stack frame out of bounds). I’ll do some more digging later on.

Anyway, good luck with the digging.

The cause of the error was in AppLua (using MessageTrans before file descriptor was set up). However the same code doesn’t crash on RiscLua 6, the call to MessageTrans returns an error. This suggests that RiscLua 7 doesn’t handle errors returned by SWIs correctly.

I am curious to know how Applua is progressing :).

It’s coming along albeit in bits and pieces, and there’s still a long way to go. Anyway, I’ve taken what I’ve got so far and put it on my website (I’ll do a proper announcement later on).

I’ve taken what I’ve got so far and put it on my website

Many thanks. I have been trying it with RiscLua 7. Perhaps I should apologize for its most recent innovation, declaration of globals.

foo = bar

global.foo = bar

for the first use of foo. So I am still in the process of doubleclicking !AppLua, looking at the error message and inserting the indicated global. prefix. Though tedious it is quite instructive; in fact it convinces me that it is an essential innovation, because it is a useful debugging tool. For example it is showing me that at line 241 of !AppLua.LuaTbox.AppLua the argument DealWith_PreInit to pcall has not yet been encountered.

I feel a bit guilty about making RiscLua a moving target, but in this case less so. RiscLua 6 used dynamic linking for C libraries, but since then GCC has moved to a newer version and I cannot get dynamic linking to work. I suspect it has something to do with the translation between Unix and RISC OS filenames. Anyway, I have reverted for the time being to static compilation for RiscLua 7. The actual code for the riscos library has not changed for decades, so I would be surprised if the handling of SWI errors is different. Can you send me relevant bits of code to test?

I much admire the work you have put in to AppLua. Following Joe’s lead with AppBasic is an interesting exercise. But, as I may have already expressed, making a translation (calque?) from BASIC to Lua makes one aware of the differences, particularly when it comes to scoping of variables. In BASIC global variables are the norm, in Lua local variables are the norm. Still, there is much to be said for getting things to work first, and then tackling changes of style later in a controlled way.

I just wanted to say that I use it. Most people only speak up when things go wrong. Admittedly I’m using it like a vanilla Lua because I have no idea how to use the additions for RISC OS and don’t really know where to start.

I just wanted to say that I use it.

I am very happy to hear this. Have you tried Lua scripts in StrongED? You write a Lua program that can read in the text in a StrongED window as if it were from a file named by arg [1] by (SHIFT-/CTRL-) dragging the file containing the program onto the green down-pointing arrow (the apply icon) on the smarticon-bar at the top of a StrongED window. The program’s print output replaces the contents of the window. This makes a sweet environment for the programming of short scripts in vanilla Lua.

Gavin, i haven’t tried that yet.

I kind of miss the Iconbar icon for RiscLua. I think I cobbled it back in with a previous version but haven’t done it for 7.

The Lua editing in StrongEd is very good. As for many things, it’s one of the better editors out there.

I wanted to ask, would it be possible to have some simple examples of library usage? Either in the example code, in the included docs, or even on your site.
I’m trying to work out the intended way to use the things in the riscos library.
Things like “riscos.version” works as-is, but I’ve been tinkering for a while trying to work out “riscos.sys”. I went through the libraries and found it being used in “screen”, but in a slightly different manner.

I’ll say outright, I’m not good at Lua. I find it a useful tool, but my knowledge is very limited.
Right now I’m just trying to work out how to use SWIs with it so I can prod at PiSPI.

Over the years I wrote masses of tutorial stuff for RiscLua. However, fairly recently, when I decided to clean up my website and make it conform better to validator.w3.org, I drastically reduced all that. Currently there is a link RiscLua at the top of the list on the bottom of the RiscLua webpage to some sporadic notes. I add to these now and then, so keep your eyes peeled, and do complain if I do not explain things clearly. I am very happy to do special orders .

I saw this in your notes.

It was a poor piece of naming when errors were called exceptions.

Thank you!
The whole Java subject I had to do many years ago made me rather angry. One of the reasons was we were being taught to use exceptions as a part of the program flow.
All I could see was a debugging tool which should never be invoked unless things break spectacularly.

The notes section is very useful. Thankyou. I’m reading through it now.

The whole Java subject I had to do many years ago made me rather angry. One of the reasons was we were being taught to use exceptions as a part of the program flow.

Exceptions ARE part of the program flow. But of the “error” flow and not of the “normal” flow. At the end of the day, exceptions are “just” a special kind of goto. I extensively used Java with its checked exception philosophy and Ada with its unchecked-and-for-serious-errors-only exceptions as well as various languages without exceptions. All in all, I prefer Java’s approach, because it makes the “error flow” pretty obvious for the reader of the code.

All I could see was a debugging tool which should never be invoked unless things break spectacularly.

In certain situations, Exception-for-debugging is indeed a powerful tool – “new Exception().printStackTrace()” is spectacularly useful :-)

Java has a fine distinction between “Exception”, “Error” and “RuntimeException”. It is key to a well-structured software to use the correct thing for the “exceptional situation” to be handled.

And it is hard. Coding the “happy path” is always easy – it is handling exceptional situations and arbitrary inputs (especially user input) that makes things horribly complex.

I have updated RiscLua7 on my website. The new application !rlua7 puts an icon on the iconbar. Dragging a file containing a Lua program to it runs it in a taskwindow. There is a new directory altlib_ex in the Examples directly showing how you can require different libraries from the default. In fact I am in the middle of revising the wimp libraries, but have only updated the those for tasks, menus and the iconbar so far.

The fact that global variables must now be declared with a non-nil initial value in RiscLua7

global.foo = "bar"

Exceptions ARE part of the program flow. But of the “error” flow and not of the “normal” flow.

I’m not really aware of how Java/Lua handle (error) exceptions; suffice to say that I tend to prefer a BASIC style “ON ERROR” method rather than C’s every-function-returns-a-status.

Why? Because generally, in a function, a set of specific types of error will occur and it would be useful to try to handle them in one place (I quite like VB’s ability to resume after handling an error) rather than checking for the same set of status after every single flippin’ function call. There’s a lot of code (including some I’ve written) where it doesn’t bother checking for errors. Bad form, perhaps. But without the use of goto to marshall error handling to a certain point, the C approach leads to hideous spaghetti code. So primary function calls would check for EOF or the like, rather than “everything that touches the file”.

That’s my gripe with C. No “ON ERROR LOCAL”. I suppose this might have been what C++’s throw/catch was intended to resolve?