Floppy driver board

That’s still not GPL-compatible.

Dynamic linking is specifically disallowed in the FAQ. That carries no legal weight as it doesn’t clarify the type of linking in the text of the licence. The licence is the legal part, not the opinions.
Indeed, the OSI council have argued that simply linking to GPL code doesn’t create a “derivative work”, a concept the GPL stretches greatly.

This is the primary reason that I am anti GPL. The licence is unspecific, some additional text makes numerous claims not supported by the licence itself, and the general opinion is that “the courts will sort it out”. Bollocks to that, I’m a programmer not a lawyer and there’s no guarantee that a court in Wisconsin will reach the same conclusion as one in Ohio, never mind a halfway sane legal system like this side of the ocean.

stop discussing how to pirate

Since when has trying to find a way to make it work been piracy?

There’s this that exists, and that which exists. Can they interact?

This is piracy now?

If that’s what you think, you might want to take a long hard look at what your intentions are when making something “open source”. For me, for my part, I usually use the EUPL. It’s so damn open that, yeah, you can choose to relicence the code as GPL (v2, but this is mostly because of the GPL). The goal is that stuff be usable by others. And, yeah, this does mean that shady Chinese companies can rip it off and use it in their own products. Well, NEWSFLASH, they do this already with GPL code.
And, yet, as far as I’m aware the issue of GPL linkage is still an ambiguity as it hasn’t gone to court (or did I miss it?).

The GPL is a good idea, but it is only open by a very small ideological definition of open.

But, fair enough. Reinventing the wheel it shall be… <sigh>

Can we please stop discussing how to pirate Sarah’s software now?

+1, thanks Rob.

If that’s what you think, you might want to take a long hard look at what your intentions are when making something “open source”.

Utterly irrelevant. If you want to use my code, you need to abide by the chosen license. If you don’t wish to abide by them, don’t use my code. Trying to find ways around the license by arguing the definition of linking is at the very least bad faith, and given that IIRC ROOL was at least at one point interested in trying to work with the open source community this is probably something they don’t want to get a reputation on.

you need to abide by the chosen license

Yup, I agree, actually. Your code, your choice of licence. That’s why pulling bits out and sticking them directly into the newer ADFS was a complete non starter (and you were right to call it out).

arguing the definition of linking is at the very least bad faith

I beg to differ given that “this module connecting to that module” is apparently against the GPL…well, isn’t that how a huge part of RISC OS actually works? It is NOT Linux. There are SWI calls, vectors, service calls, and so on. Everything hooking itself into everything else in various ways.

So what is allowed and what isn’t – given, as I pointed out, that the FSF and OSI don’t agree on this and the claims that people usually point to are in the FAQ, not the licence itself – this ought to be a simple enough question…

was at least at one point interested in trying to work with the open source community

Firstly, they are very open source. Read the licences in the codebase for yourself. It’s quite clear.

Secondly, kindly refrain from assigning to ROOL the mutterings of some random twat on a forum. I do not represent them, my thoughts are my own.

I am simply reading this topic and observing that it would appear that the answer to having your code interact with some basic floppy code in ADFS to arrive at something “that just works” for people would be, simply, no, primarily because of licensing issues.
Is this the case?

I think Saran does not understand how RISC OS works and just needs to be educated.

does not understand how RISC OS works and just needs to be educated.

Dude, what the hell? You know she wrote Arculator, right?

Kind of think a person that writes an emulator to run the OS in question might have a bit of a grasp of how it works.

🤦

PS: Sarah, she’s not cling film.

@ Chris

I think Saran does not understand how RISC OS works and just needs to be educated.

Chris, I suggest you read again your comment (and eventually change it). I understand you might be annoyed by not getting things your way, but dude, I can assure you Sarah knows how RISC OS works better than you seems to have showen with some of your statements (and this is not an attack to you).

Again, I do not want to be aggressive with you, so please just drop it. I can assure you it’s NOT a technical problem here whatsoever or a problem of knowing how RISC OS works.

Besides, if you think you know how RISC OS works, you’ve probably already thought of how to compile code that most likely will compile only under GCC, and so to make it a Module (as you’ve claimed), you’ve also thought of the implications that that requires, right?

So, I’d suggest you go off line now, and try to work on what you claim being possible and easy (because of the way you imagine how RISC OS work) and then come back to comment on here only when you have at least a partially working model and can explain how you’ve managed to make two incompatible licenses to become compatible and with profable facts.

Again Chris, don’t take this as an attack, but the way you expressed yourself on your previous comment can be perceived as extremely aggressive (and unfounded) to Sarah, which as proven time and time again to know what she is doing, so all you’ve got left to do now is prove your claims with your code.

Good luck

Somewhere in all this mud is an interesting question that really should be answered explicitly instead of being subjective rhetorical ammunition:

Do we all agree that calling a SWI (which can be implemented by any module with that number in its header) and calling a Vector (which can have any number of implementations and interceptions) cannot be described as “linking” by any reasonable definition?

Even if you intended for a task to employ module Foo, if your API is SWIs and/or Vectors then at any point one could run another module Bar and have that implement the same API, working with your task without the task even noticing anything has changed. This would appear to be the opposite of linking.

“Linking” does not mean “using”, surely?

@ Nemo

Do we all agree that calling a SWI (which can be implemented by any module with that number in its header) and calling a Vector (which can have any number of implementations and interceptions) cannot be described as “linking” by any reasonable definition?

IMHO, there are edge cases, for instance, when “passing” a block, we don’t really pass it, we pass a pointer and allow code to effectively be linked having access to eachother memory (GPL covers both static AND dynamic linking). So, if anything, such a claim could be made only for certain SWIs, but not for all of them.

Moreover, the specifics here appear even more complicated. For instance, if the GPL code is in C and gets compiled as a module using the SharedCLib, does that means the SharedCLib should be released as GPL? That indeed IS linking. And if that licensing is a problem then how one would solve it? Using UnixLib? And would it be enough to produce a fully working module? and if you manage to achieve that, how would you then put such a thing in the chain of things to still avoid causing license problems? Clearly not in the ROM image, because creating such an image is still linking.

My point Nemo is that, there is no one measure fits all and there could be even more complications which would require both a lawyer and developers to agree on the specific implications of the terminology used to define the boundaries.

TL;DR: I don’t believe RISC OS has an “architecture” that allow to overcome all software licenses limitations.

Hope I am making sense.

for instance, when “passing” a block

A block of data is equivalent to a string. But a jump table is a different matter – that would appear to be some kind of linking. However there is an important difference between “linking in” and “linking out”…

if the GPL code is in C and gets compiled as a module using the SharedCLib, does that means the SharedCLib should be released as GPL?

And the answer is no. Because it is the GPL code that is ‘choosing’ to link to the SCL, not vice versa. Though it is abstracted behind a couple of SWIs, the SCL is connected via a jump table… but it is simple to envisage a replacement ‘open source’ SCL that implements that API and provides a jump table of functions that merely call SWIs, and hence is once again air-gapped from any claim of linkage.

Put it this way, if calling a SWI is defined as linkage, then any open-source RISC OS can only run software that is compatible with the linking legalese of its arbitrarily chosen licence. Which is a ridiculous situation for an “operating system” to be in.

require both a lawyer and developers to agree on the specific implications of the terminology used to define the boundaries

That is a necessity isn’t it? Or do we just have a shouting match between different definitions of the word “linking”?

I don’t believe RISC OS has an “architecture” that allow to overcome all software licenses limitations.

If you try and define how it is possible to use an interface without being infected by the belief system of a particular implementor of that interface, you’ll rapidly reach the conclusion that every line of code in an ‘open source library’ is the interface. And that’s one of my arguments against the open source model as a panacea.

SWIs and Vectors can’t be considered “linking”, or everything that runs on RISC OS is subject to the RISC OS licence. That’s untenable.

And the answer is no.

it’s not that simple, all cases I am aware of with “linking” with GPL code have resulted in settlements, so I wouldn’t be so sure, just my 0.5p here.

There are more information on Linking exceptions here: https://en.wikipedia.org/wiki/GPL_linking_exception

There is another issue on RISC OS, nothing is trully a “separate” process on RO, and that is something that makes it weaker in cases regading licenses instead of stronger (in reference to who believes RISC OS has some kind of “magic architecture” that solves every license problems).

As a matter of fact, it’s technically possible to consider everything on RISC OS as a single executable. Yes some SWI and the vectors do isolate and produce an API that could be considered not linked, but direct access to each other sides is indeed a blurry line and I would not be so sure of the outcome of detailed analysis of it “dependance” can be seen in different ways in such a peculiar environment.

Sure one could claim that there isn’t a direct dependecy, like a jump table would create (and jump tables have been mentioned in this thread as a solution, which they are NOT to such a problem).

Put it this way, if calling a SWI is defined as linkage, then

Calling an SWI that do not requires “dependance” on memory portions of process A is definitely not a linking, however calling SWIs like a CallBack IS a linking, you’re passing the address of your own code that will be jumped to, I mean if this is not dynamic linking then nothing is.

That is a necessity isn’t it?

Indeed, which is why I don’t thing a thread on here is the best place to define the case in all its aspects.

If you try and define how it is possible…

I am sorry Nemo, but when it comes down to licenses I don’t try to do such type of reading, there are reasons why there is the linking exeption for the GPL and there are reasons why all cases I am aware of ended up in settlements, so if people here are willing to bet their own money on the thing, then, by all means, be my guest.

everything on RISC OS as a single executable

Irrelevant. It wasn’t distributed like that, and it isn’t copied in that form. Linking with a system library does not constitute a derived work. See Rosen. And in particular, code running under an operating system does not become part of that operating system simply by being executed by it.

calling SWIs liek a CallBack IS a linking, you’re passing the address of your own code that will be jumped to, I mean if this is not dynamic linking then nothing is.

But you are linking to that code. So you agree to comply with the legal requirements of that code, but your licence conditions are not magically conferred upon it.

If you don’t call that SWI, nothing is linked to your code. You can’t cause a linkage to occur and then claim some legal responsibility on what you chose to link to.

I forget who said “If you can’t explain it to a five-year-old, you don’t understand it”, but I can’t believe it’s 2023 and no one is prepared to be definitive about SWIs and Vectors not counting as “linkage”.

Since none of this has been tested in court even when olde-worlde static linking is occurring, I’m confident no one will be daft enough to threaten legal repercussions to calling a defined SWI. Can’t believe I have to say that out loud.

I mean: If you write a GPL’d open source filing system, are you claiming that closed-source applications can’t store files on that FS? The app calls OS_File; FileV gets called; FileSwitch selects YourFS by the user-supplied filename; calls your GPL code. You think that counts as “linkage”? Don’t be daft.

And if saving a file doesn’t count as linking to the FS code, then calling a SWI in a thin module veneer around GPL’d code isn’t either… because it’s the exact same mechanism.

Which is a ridiculous situation for an “operating system” to be in.

It’s ridiculous that this sort of discussion even needs to happen, all because of one poorly thought out licence trying a land grab.

That is a necessity isn’t it?

No, because pretty much every other open source licence is written with clarity, whether it be the three line “whatever” of the bsd, or the available-in-a-dozen-languages EUPL.

The only potential problem is around grants of patents, but that sort of thing was added to address the concerns of jurisdictions where that’s an issue.

SWIs and Vectors can’t be considered “linking”, or everything that runs on RISC OS is subject to the RISC OS licence. That’s untenable.

Utter utter hogwash bordering on being outright FUD.
Not one single part of any of the licences used within RISC OS has anything to say regarding other code that it is linked with. Consequently there are various licences coexisting within RISC OS itself (bsd, Apache, CDDL) and none of them is in any way concerned about what the OS subsequently runs, no matter what OS interface is in use.

You appear to be looking at this purely from the point of view of thinking that other licences are as naff as the GPL. They aren’t. Only the GPL has this argument and ambiguity.

The problem here isn’t Sarah, or her work, it’s purely the GPL and it’s incompatibility by design coupled with vague wording, as if Stallman was maybe hoping to slip it through unnoticed?

I was not intending to upset Sarah with what I wrote earlier. I, like nemo, would really like to understand how the GPL works with a non-Linux system such as RISC OS.

Because it is the GPL code that is ‘choosing’ to link to the SCL, not vice versa.

It isn’t relevant what chooses what. The GPL licence (I don’t care what the FAQ states) says: You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License.

There’s another longer paragraph that begins These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. (my emphasis)

It then says: But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. (my emphasis)

Unless there’s been a big change in GPL v3, there is absolutely no reference to what “chooses” what. It seems quite clear, anything that contains GPL must therefore be entirely GPL.
(which does indeed imply that using the CLib stubs in a GPL program isn’t technically allowed because that isn’t GPL)

But now we’re talking things calling out to other things being assimilated by proxy, or what?

This is where the linkage question comes in, as actually the GPL (v2) itself has is no mention whatsoever of the words “static” or “dynamic”, and the only mention of “link” is a prohibition against using GPL code within a proprietary program.

It is, really, a terrible licence, to try to impose such a potentially onerous requirement, to then leave the implementation details completely vague. If one can put GPL and non GPL software on a CD-ROM, can one put GPL programs into ResourceFS? At which point does it stop, given that ResourceFS is a filing system built into a ROM image… that’s a real brain breaker, isn’t it?

If this linking thing needs to be considered (and, remember, GPL v2 doesn’t actually say anything whatsoever about static vs dynamic linking), how does it work? What is affected by it? What is and is not GPL compliant?

Clearly taking some GPL code and stuffing it into something else is a bad thing, verboten to hell and back.
The thing that I was responding to, namely this:

A jump table is dynamic linking. That’s still not GPL-compatible.

Please explain, given that GPL v2 itself does not say anything about actual linking methods how it would be against the GPL to have a bit of GPL code supplied separately be used with a non-GPL component, regardless of the specifics of this? If they are two separate things, loaded independently, how can the licence of one make any claims whatsoever over the other?

One executable, one set of source, yeah, I can understand that, no problem. But two separate things and now we’re saying that setting up, say, a jump table from one to the other is not permitted? You know, the actual licence doesn’t actually say any such thing, right?

I see plenty of opinions here, getting progressively more ridiculous (really, lawyers? really?) but nothing that is backed up by what the licence text actually says. Not the FAQ, not some random post by Stallman, but the licence text, that legal document that you are required to agree to in order to make use of the code.
Where does it clarify any of this problem?

I should point out that the only reason you’re running into “ambiguity” with the GPL is because you’re trying to find ways to circumvent it…

Not trying to circumvent, trying to understand. A lot has been said here that utterly does not appear to be backed up by the licence text.

Plus, I myself have no intention of using your code. For me it’s an academic question. What is and isn’t permitted?

Besides, it’s a bit rich to complain about circumventing anything given this page, kindly note the comments regarding the EUPL and the two-stop process for relicensing anything EUPL as GPLv3.

given this page

Just spotted their insane comments there regarding MPL, thanks.

I have, in the past, actually read the GPL (original) and GPL2¹ and I can quite honestly say that in comparison to various Acts of Parliament the GPL is as clear as mud and ambiguous as hell. Take any three legal experts and ask them to decide what it means, and I believe you will get at least 4 different results.

Let’s just content ourselves with a stance that says “for the GPL, a ten-metre pole ain’t long enough”

¹ I must be daft, that I didn’t learn from the first instance that it was written to be confusing and open-ended.

Not trying to circumvent, trying to understand.

I appreciate that Rick. But someone else (or at least the discussion took a direction that really feels like it) was trying to “circumvent”, and honestly that is not nice.

Now on the “to understand” line:

1) RISC OS license (or the most common lince in RISC OS sources, Apache 2.0) is GPL compatible, so linking GPL code with most libraries on RISC OS IS OK, but that has nothing to do with RISC OS “architecture”.

For more details (and for clarity on what “compatible” means), here there is a link to a list of licenses compatible with GPL (and why):

https://www.gnu.org/licenses/license-list.en.html#GPLCompatibleLicenses

2) The Acorn (now ROD) Shared C Library was originally distributed under copyright, which is obviously NOT compatible with GPL, but in recent years if one uses “*Help SharedCLibrary” you get the version number and build, but there is no license. However, it’s still distributed with the DDE (if one uses the one with DDE) and the DDE License says that everything included in the DDE media are copyright of ROOL and their licensors and shall be considered so.

Hence, unless someone changes the license terms in the DDE, the SharedCLibrary must be considered copyright and therefore it’s NOT compatible with the GPL License.

Therefore, GPL code should be linked using the UnixLib to run on RISC OS, not the SharedCLibrary. Unless the SharedCLibrary license has been changed.

Now, given that modules still require the SCL when written in C (or C++), that means that the first obstacle in the endevor in this thread would be SCL license, this regardless of the discussion on the SWIs.

However, if one manages to rewrite the GPL code to avoid the need to link against the SCL, and other libraries that present incompatible licenses with the GPL, then you should be OK, and again NOT because of the RISC OS “architecture”, but because RISC OS license is compatible with the GPL.

On the discussion about the SWIs being or not being a “separating” entity between the logic implemented behind a SWI and the GPL code, that, as I have mentioned, would depend on how the SWI works, so a typical SWI should be fine, a SWI that for example sets a CallBack where an address from the GPL code is shared and accessed directly between the 2 parts is indeed a link and therefore in that case the license of both the two parts decide if it’s ok or not.

It doesn’t matter who links to who, it’s not mono directional.

I am not a lawyer, so there might be blury areas in the above, and that would require legal advice. Not to mention that as many pointed out the GPL can be aggressive (and confusing) on the blury areas and therefore, I’d personally not chase the luck, but again that is my opinion, not a legal advice.

A final note:

Making Sarah’s code a module to avoid issues with the licensing IS a way to “circumvent” the license and her desire to pursue the GPL philosophy, so let’s not try to hide ouwselves behind the language. I believe we should all be friends here, so please (again) don’t get my words as an attack.

It is perfectly OK to write a software licence that prohibits the software from being used. What is clearly not enforceable is to write a licence that says that if the software is used, it confers rights over some other piece of software owned (or licensed) by someone else.

I am surprised that GPL code does not check its compatability with the operating system licence before it runs. But then I can’t think how it could do that!

So if some software that uses the GPL licence does an RMEnsure for the Shared C Library it is breaking the terms of its own licence. Silly isn’t it?

must be considered copyright and therefore it’s NOT compatible with the GPL License.

Copyright is what makes the GPL work…

where an address from the GPL code is shared and accessed directly between the 2 parts is indeed a link

Where does the licence say this?

It doesn’t. In fact, GPL v2 actually says: Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted,

Notice the last sentence.

Any talk of how things must be handled by something performing runtime “linking” (which comes in several forms) to something else is, at best, ideological obfuscation.

Static linking, I can understand, as it creates a final program that is supplied as a whole entity.
But dynamic linking? Setting up a jump table to use? That happens when running the program. The GPL specifically says that this sort of thing isn’t counted within the scope of the licence.

Seriously, ignore the FAQ. It’s not relevant, it’s not what one agrees to when using the GPL. The entire FAQ is a master class in saying many things that the licence doesn’t.

If one wants an open source licence where the source is required to be available to those who ask, there’s always the CDDL…

Silly isn’t it?

Silly is that the Linux kernel is GPL v2 only (and Linux isn’t about to change) which means that one cannot use GPL v3 code. Because of all the hoo-ha over “linking”, this is an often raised question in the context of kernel modules and the like.

Because GPL tries so hard to be incompatible with any other licence, it is not even compatible with itself unless the author specifically writes “or later versions” when referring to what version is used. That is silly.

But, then, it was never really about software being open, it was about software not being proprietary. A subtle difference, but one that causes the GPL to essentially exclude all other types of “open”, including those with many more of the desired freedoms.

It is perfectly OK to write a software licence that prohibits the software from being used.

Technically, the absence of a licence would have the same effect in most of the world.

Are there any keen hardware types who would like to recreate “William`s” PCB of USB to PIC to 1772 floppy controller?

Info on working the 1772 controller – since it was used by the BBC and Arc.

Rick reassured

Utter utter hogwash bordering on being outright FUD.

No. The fact that the current OS licence isn’t of the ‘sticky’ kind in no way invalidates the observation that if use of SWIs and Vectors were to be considered “linking” then anything that uses a SWI or Vector is subject to the licence conditions of whatever implements that SWI or Vector which may be entirely beyond the control of the author, the user, and indeed may change from moment to moment as directories are opened and applications booted.

Do you see?

You appear to be looking at this purely from the point of view of thinking that other licences are as naff as the GPL.

I’m not, and it’s not the GPL that is the problem per se, it’s the lack of definition of what the word “linking” means in RISC OS. The GPL is one manifestation of that problem, but I’m an equal-opportunities legalese botherer. There may be another along in a moment that uses the same word.

It isn’t relevant what chooses what.

Yes of course it is. The author that chooses to cause linkage to occur – call him ‘Fred’ – is subject to the licence conditions. Not the author of whatever was linked to by Fred. Claiming that legalese can be forced backwards through time to apply to someone who never agreed to that licence is not only an assault on the arrow of time, it would also be laughed out of every court in every land. And licence conditions apply to people, not code. You can’t sue code.

Sarah suggested

the only reason you’re running into “ambiguity” with the GPL is because you’re trying to find ways to circumvent it…

One: Bullshit. There’s decades of debate on this subject as you well know. It has never been tested in court AS YOU WELL KNOW. Neither Rick, nor I nor anyone serious here is trying to circumvent anything. I don’t even know what code you’re referring to because I’m talking about the definition of a word within the context of RISC OS. I couldn’t give a monkey’s about any particular example.

Two: You could have used those words to define what “linking” means. I mean, you do know what it means for RISC OS, yes? You’d hardly be mandating a licence without some understanding of what it means. I wonder if your understanding of these undefined words is the same as someone else’s understanding of these undefined words? And which of you would be right? Would it be you because you chose that licence? Does the licence therefore mean what you want it to mean, or does it have a defined meaning? In which case, please define what “linking” means with regard to SWIs and Vectors.

Explicit question: Does wrapping your “GPL” code in a thin module veneer and then publishing only that module veneer satisfy the requirements of the GPL? If not, why not? (Again, I reiterate that I don’t care about this particular lump of code, I’m talking about the meaning of words that people bandy about as if they’re magic talismans)

Paolo provided

Shared C Library was originally distributed under copyright, which is obviously NOT compatible with GPL

No, copyright is orthogonal – and it’s ironic to point out that the gnu licence list page is copyrighted – licensed under CC BY-ND 4.0 – which the page itself describes as “compatible with all versions of the GNU GPL”. So there! Everything that is written is automatically copyrighted, in that the author has the right to define how the work can be copied – that’s what copyright means. Usually that right is used to prevent unauthorised copying, but one can allow unauthorised copying without affecting ownership of the copyright.

It doesn’t matter who links to who, it’s not mono directional.

It is in terms of legal responsibility: George writes a library which is not GPL. Fred links his project to that library and releases his code as GPL. This does not require George to comply with the GPL. It does not cause the GPL to apply to George’s library. There is no debate there. Fred cannot cause George to be subject to a licence he did not agree to. Nobody can.

Making [somebody’s] code a module to avoid issues with the licensing IS a way to “circumvent” the license

It is a way to comply with the licence. Let us not redefine “complying” as “circumventing”. But as I have observed, I’m not certain that it has been defined that use of code via SWIs and Vectors (i.e. event handlers, which is what they are effectively) is definitively not “linking”. I don’t even know who I’m arguing with, because nobody seems keen to define their understanding of this one way or the other.

I would welcome a formal definition and declaration of this. Even at the cost of stating “If you don’t like the fact that SWIs and Vectors are not ‘linking’ per the terms of the GPL, then kindly take your code elsewhere”.

Rick returned

“the act of running the Program is not restricted” Notice the last sentence.

Indeed. An executable does not become part of the operating system by being executed by it. Plug-ins do not become part of the host by being plugged into it (see Rosen again). What I want to see defined is that SWIs and Vectors are not “linking”.

Otherwise we’d have the unedifying spectacle of people mandating a licence that uses words they can’t define.

Chris commented

What is clearly not enforceable is to write a licence that says that if the software is used, it confers rights over some other piece of software owned (or licensed) by someone else.

Precisely. Well said. Bravo.

if some software that uses the GPL licence does an RMEnsure for the Shared C Library it is breaking the terms of its own licence. Silly isn’t it?

Well it’s not the RMEnsure though it may be the “linking”, but we don’t know because the bloody word isn’t defined for RISC OS.

And “silly” really doesn’t cover it. It’s 2023 for heaven’s sake. If one is choosing to put these stupid words in one’s RISC OS code, one better be prepared to define what they mean.

subject to the licence conditions of whatever implements that SWI or Vector

This is only a question with the GPL, that doesn’t specify what any of this means, and indeed states at the top that it is concerned with the distribution of the program, not running it. Hence, static linking should be the only thing to concern it.

Sure, other licenses could include such language, but they don’t because it is batshit crazy and quite likely to be thrown out of any sane court. A user simply running X on Y does not (and legitimately cannot) cause Ys licence to apply to X.

It does not cause the GPL to apply to George’s library.

Technically, either that particular incarnation of George’s library must become GPL (but not any other), or it’s a GPL violation (in the same way that GPL 2 and 3 cannot interact).

Plug-ins do not become part of the host by being plugged into it

Again, the text of the GPL says nothing as this is a runtime action.
The FAQ, however, makes yet more land grabs: https://www.gnu.org/licenses/old-licenses/gpl-2.0-faq.en.html#TOCGPLPlugins

You’ll notice lots of talk about data structures and such. None of this is mentioned in any form in the actual legal document. Indeed, as I keep pointing out, the GPL itself would seem to imply that running the program is not the licence’s concern.

Also, as I keep saying, this whole thing is running on pure ideology.

but we don’t know because the bloody word isn’t defined for RISC OS.

RISC OS isn’t even relevant here, as the words are not defined period, don’t even exist in the licence (except for one mention about proprietary software) and everybody seems to be relying on the words of an alternative document that would appear to repeatedly contradict the actual licence in the midst of an ideological crusade.

one better be prepared to define what they mean.

Or simply use a licence where the meaning is clear, there’s no ambiguity, and one doesn’t need to think about going to court to see if an action is, in fact, valid.

The GPL has a lot of sway thanks to the influence of GNU/FSF. It’s a shame as it is a really horrible piece of work that leads to such questions as those being raised here.
Yes, I know, if everything is GPL then there’s no problem, but that’s akin to saying if we let Russia reclaim Ukraine then there’s no problem, it’s completely the wrong answer.