AROS-Exec :: Forum

Re: A basic linked-list class [by PortablE]

Sun, 07 Oct 2018 13:19:38 -0500

PortablE::A basic linked-list class
Attaching files doesn't seem to work, so here is a copy of those modules:

cBasicList.e


/* CSH/cBasicList.e 12-11-2016 by Chris Handley

    A list implementation which is 'as simple as possible', while still supporting sub-classing, as well as removal/insertion of multiple nodes in one go.

    

    Lists are circular, and always contain a special 'empty' node after any normal nodes.

    This 'empty' node is known as the "pastEnd" node, since it is past the end of the list.

    NEVER remove this node from the list (but it can be used to mark the end of a range of nodes that should be removed).

    

    Optimisations are certainly possible, but at the expense of less readable code and/or a more complex interface.

    At which point it would no-longer be 'as simple as possible'!  (And it's unlikely your program will be noticably faster...)

    Still, this module should be a good starting point for your own list classes.

*/

/* Public methods of *cBasicList*:

    new()

    infoStart()   RETURNS   start:PTR TO cBasicNode

    infoPastEnd() RETURNS pastEnd:PTR TO cBasicNode

    create() RETURNS node:PTR TO cBasicNode

    destroy(first:PTR TO cBasicNode, pastLast=NIL:PTR TO cBasicNode)

    ->helper methods:

    isEmpty() RETURNS isEmpty:BOOL

     append(nodes:PTR TO cBasicNode)

    prepend(nodes:PTR TO cBasicNode)

*/

/* Public methods of *cBasicNode*:

    infoNext() RETURNS next:PTR TO cBasicNode

    infoPrev() RETURNS prev:PTR TO cBasicNode

    beforeInsert(nodes:PTR TO cBasicNode)

     afterInsert(nodes:PTR TO cBasicNode)

    remove(pastLast=NIL:PTR TO cBasicNode) RETURNS nodes:PTR TO cBasicNode

    ->helper methods:

    read() RETURNS data

*/



/*****************************/



CLASS cBasicList

    ->circular list

    pastEnd:PTR TO cBasicNode    ->empty node after last 'real' node in list

ENDCLASS



PROC new() OF cBasicList

    self.pastEnd := self.create()

ENDPROC



PROC end() OF cBasicList

    IF self.pastEnd THEN END self.pastEnd.next

    SUPER self.end()

ENDPROC



PROC infoStart()   OF cBasicList IS self.pastEnd.next



PROC infoPastEnd() OF cBasicList IS self.pastEnd



PROC create() OF cBasicList RETURNS node:PTR TO cBasicNode

    DEF newNode:OWNS PTR TO cBasicNode

    

    newNode := self.makeNode() ; newNode.new()

    node := newNode

    node.prev := node

    node.next := PASS newNode

ENDPROC



PROC destroy(first:PTR TO cBasicNode, pastLast=NIL:PTR TO cBasicNode) OF cBasicList

    DEF nodes:PTR TO cBasicNode

    IF nodes := first.remove(pastLast) THEN END nodes.next

ENDPROC



->helper methods

PROC isEmpty() OF cBasicList RETURNS isEmpty:BOOL IS self.pastEnd.next = self.pastEnd

PROC  append(nodes:PTR TO cBasicNode) OF cBasicList IS self.pastEnd.beforeInsert(nodes)

PROC prepend(nodes:PTR TO cBasicNode) OF cBasicList IS self.pastEnd.afterInsert(nodes)



->PROTECTED

PROC makeNode() OF cBasicList RETURNS node:OWNS PTR TO cBasicNode

    NEW node

ENDPROC



/*****************************/



CLASS cBasicNode

    next:OWNS PTR TO cBasicNode

    prev:     PTR TO cBasicNode

ENDCLASS



->PROTECTED

PROC new() OF cBasicNode IS EMPTY



PROC end() OF cBasicNode

    DEF node:OWNS PTR TO cBasicNode, next:OWNS PTR TO cBasicNode

    

    ->destroy later nodes, without using the stack

    self.prev.next := NIL

    next := PASS self.next

    WHILE next

        node := PASS next

        next := PASS node.next

        END node

    ENDWHILE

    

    SUPER self.end()

ENDPROC



PROC infoNext() OF cBasicNode IS self.next



PROC infoPrev() OF cBasicNode IS self.prev



->insert the supplied node(s) before us

PROC beforeInsert(nodes:PTR TO cBasicNode) OF cBasicNode

    DEF firstNodes:OWNS PTR TO cBasicNode, lastNodes:PTR TO cBasicNode, beforeInsert:PTR TO cBasicNode, afterInsert:OWNS PTR TO cBasicNode

    

    IF nodes = NIL THEN RETURN

    

    lastNodes  := nodes.prev

    firstNodes := PASS lastNodes.next    ->nodes

    beforeInsert := self.prev

    afterInsert  := PASS beforeInsert.next    ->self

    

    firstNodes.prev  := beforeInsert

    afterInsert.prev := lastNodes

    beforeInsert.next := PASS firstNodes

    lastNodes.next    := PASS afterInsert

ENDPROC



->insert the supplied node(s) after us

->NOTE: Inserting after the pastEnd node will put the nodes at the START of the list!

PROC afterInsert(nodes:PTR TO cBasicNode) OF cBasicNode

    DEF firstNodes:OWNS PTR TO cBasicNode, lastNodes:PTR TO cBasicNode, beforeInsert:PTR TO cBasicNode, afterInsert:OWNS PTR TO cBasicNode

    

    IF nodes = NIL THEN RETURN

    

    lastNodes  := nodes.prev

    firstNodes := PASS lastNodes.next    ->nodes

    beforeInsert := self

    afterInsert  := PASS self.next

    

    firstNodes.prev  := beforeInsert

    afterInsert.prev := lastNodes

    beforeInsert.next := PASS firstNodes

    lastNodes.next    := PASS afterInsert

ENDPROC



->remove the current node from the list, or a range of nodes if "pastLast" is supplied

->NOTE: It will return NIL for an empty range (i.e. when "pastLast" is the same as the current node).

PROC remove(pastLast=NIL:PTR TO cBasicNode) OF cBasicNode RETURNS nodes:PTR TO cBasicNode

    DEF firstNodes:OWNS PTR TO cBasicNode, lastNodes:PTR TO cBasicNode, beforeRemove:PTR TO cBasicNode, afterRemove:OWNS PTR TO cBasicNode

    

    IF self = pastLast THEN RETURN NIL

    

    nodes := self

    

    firstNodes := PASS self.prev.next    ->self

    lastNodes  := IF pastLast THEN pastLast.prev ELSE self

    beforeRemove := firstNodes.prev

    afterRemove  := PASS lastNodes.next

    

    firstNodes.prev  := lastNodes

    afterRemove.prev := beforeRemove

    beforeRemove.next := PASS afterRemove

    lastNodes.next    := PASS firstNodes

ENDPROC



->helper methods

PROC read() OF cBasicNode RETURNS data IS 0



/*****************************/

cBasicList_STRING.e


/* CSH/cBasicList_STRING.e 12-11-2016

    A sub-class of cBasicList for STRINGs.

*/

/* Public methods of *cBasicList_STRING*:

    new()

    infoStart()   RETURNS   start:PTR TO cBasicNode_STRING

    infoPastEnd() RETURNS pastEnd:PTR TO cBasicNode_STRING

    create(string=NILS:OWNS STRING) RETURNS node:PTR TO cBasicNode_STRING

    destroy(first:PTR TO cBasicNode, pastLast=NIL:PTR TO cBasicNode)

    ->helper methods:

    isEmpty() RETURNS isEmpty:BOOL

     append(nodes:PTR TO cBasicNode)

    prepend(nodes:PTR TO cBasicNode)

*/

/* Public methods of *cBasicNode_STRING*:

    infoNext() RETURNS next:PTR TO cBasicNode_STRING

    infoPrev() RETURNS prev:PTR TO cBasicNode_STRING

    beforeInsert(nodes:PTR TO cBasicNode)

     afterInsert(nodes:PTR TO cBasicNode)

    remove(pastLast=NIL:PTR TO cBasicNode) RETURNS nodes:PTR TO cBasicNode_STRING

    ->helper methods:

    read() RETURNS data:STRING

*/

/* Public members of *cBasicNode_STRING*:

    data:OWNS STRING

*/



PUBLIC MODULE '*cBasicList'



/*****************************/



CLASS cBasicList_STRING OF cBasicList

ENDCLASS



PROC new() OF cBasicList_STRING

    SUPER self.new()

    self.pastEnd::cBasicNode_STRING.data := NEW ''

ENDPROC



PROC infoStart() OF cBasicList_STRING IS SUPER self.infoStart()::cBasicNode_STRING



PROC infoPastEnd() OF cBasicList_STRING IS self.pastEnd::cBasicNode_STRING



PROC create(string=NILS:OWNS STRING) OF cBasicList_STRING RETURNS node:PTR TO cBasicNode_STRING

    node := SUPER self.create()::cBasicNode_STRING

    node.data := PASS string

ENDPROC



->PROTECTED

PROC makeNode() OF cBasicList_STRING RETURNS node:OWNS PTR TO cBasicNode_STRING

    NEW node

ENDPROC



/*****************************/



CLASS cBasicNode_STRING OF cBasicNode PUBLIC

    data:OWNS STRING

ENDCLASS



PROC end() OF cBasicNode_STRING

    END self.data

    SUPER self.end()

ENDPROC



PROC infoNext() OF cBasicNode_STRING IS self.next::cBasicNode_STRING



PROC infoPrev() OF cBasicNode_STRING IS self.prev::cBasicNode_STRING



PROC remove(pastLast=NIL:PTR TO cBasicNode) OF cBasicNode_STRING RETURNS nodes:PTR TO cBasicNode_STRING

    nodes := SUPER self.remove(pastLast)::cBasicNode_STRING

ENDPROC



PROC read() OF cBasicNode_STRING IS self.data

cBasicList_STRING_test.e


MODULE '*cBasicList_STRING'



PROC main()

    DEF list:OWNS PTR TO cBasicList_STRING, node:PTR TO cBasicNode_STRING, floating:PTR TO cBasicNode_STRING

    

    ->build a list

    NEW list.new()

    list.append(list.create(NEW 'Hello '))

    list.append(list.create(NEW 'new '))

    list.append(list.create(NEW 'world! '))

    printList(list)        ->Hello new world! 

    

    ->do some tests

    node := list.infoStart()

    floating := node.remove()

    list.infoPastEnd().beforeInsert(floating)

    printList(list)        ->new world! Hello 

    

    node := list.infoPastEnd().infoPrev()

    floating := node.remove()

    list.infoStart().beforeInsert(floating)

    printList(list)        ->Hello new world! 

    

    node := list.infoStart()

    floating := node.remove()

    list.infoPastEnd().afterInsert(floating)

    printList(list)        ->Hello new world! 

    

    node := list.infoStart().infoNext()

    floating := node.remove()

    list.infoStart().beforeInsert(floating)

    printList(list)        ->new Hello world! 

    

    node := list.infoStart()

    floating := node.remove(list.infoPastEnd().infoPrev())

    list.infoPastEnd().beforeInsert(floating)

    printList(list)        ->world! new Hello 

    

    Print('Finished.\n')

FINALLY

    PrintException()

    

    END list

ENDPROC



PROC printList(list:PTR TO cBasicList_STRING)

    DEF pastEnd, node:PTR TO cBasicNode_STRING

    

    pastEnd := list.infoPastEnd()

    node := list.infoStart()

    WHILE node <> pastEnd

        Print(node.data)    ->or Print(node.read())

        node := node.infoNext()

    ENDWHILE

    Print('\n')

ENDPROC

About the undocument PASS & NULL keywords, and the barely documented OWNS ! [by PortablE]

Sun, 07 Oct 2018 12:56:43 -0500

PortablE::About the undocument PASS & NULL keywords, and the barely documented OWNS !
(Originally posted on 15-11-2016 to amigacoding.de)

If you are interested in understanding the code of my recently-posted cBasicList.e module, or possibly some of my other modules in PEmodules:CSH, then it may help to understand the "OWNS", "PASS" & "NULL" keywords. "OWNS" only get's a brief mention in the Standard Functionality guide, while "PASS" & "NULL" have been completely UNdocumented until now...

If you see "OWNS" as part of a variable's (or object member's) type, you can safely ignore it, because that is what PortablE currently does! However, it is a hint that variable has ownership (i.e. deallocation responsibility) for that particular pointer (or array or e-string or e-list). If it's part of a local variable, then usually that variable should be ENDed when the procedure finishes. If it's part of an object member, then that member should be ENDed as part of the object's end() method.

If you see "OWNS" as part of a parameter or return variable, then it's a hint that ownership (i.e. deallocation responsibility) is being passed into or out of that procedure.

What about "PASS"? You cannot ignore this, because it actually does something! Here is an example:
Quote:

DEF var1:OWNS PTR TO example, var2:OWNS PTR TO example
var2 := PASS var1

What this does is to pass ownership from var1 to var2. "PASS" does this by evaluating to the original value of "var1" after it has assigned NIL to var1. This ensures that the pointer is only ever owned by one variable (var1 or var2), and so you cannot get into a situation where your program tries to destroy the same object twice. Most of the time you can imagine the above code as equivalent to this:
Quote:

DEF var1:OWNS PTR TO example, var2:OWNS PTR TO example
var2 := var1
var1 := NIL

HOWEVER, this simple story is not quite accurate, and so here's what actually happens:
Quote:

DEF var1:OWNS PTR TO example, var2:OWNS PTR TO example, temp:PTR TO example
temp := var1
var1 := NIL
var2 := temp

When would this make a difference? If you tried to be clever & do something like this:
Quote:

var1.member := PASS var1

You MIGHT imagine that var1 get's stored in it's own member, before it get's NILed... but in actual fact it will lead to a crash, because var1 get's NILed before the assignment occurs, so the code would end-up trying to assign to the member of a NIL pointer! I should probably make PortablE detect & warn about these kinds of situations, at least once "PASS" becomes a properly documented part of the language.

The "NULL" keyword is somewhat similar to "OWNS" in that it is used as part of a variables type, but is currently ignored by PortablE! It is only used with procedure parameters (or possibly return variables). When you see it used with a procedure parameter, it is an indication that parameter is allowed to be NIL. i.e. The procedure will function just fine if you pass it NIL or NILA (as appropriate). For example:
Quote:

PROC example(param1:NULL PTR TO cBasicNode)

Re: Alternative forum for PortablE [by PortablE]

Fri, 22 Jun 2018 18:15:38 -0500

PortablE::Alternative forum for PortablE
Sadly it looks like that forum is down at the moment, due to GDPR lawsuit fears, but it may return:
http://eab.abime.net/showthread.php?p=1246647&styleid=4

Re: Open serial device, error passing parameter [by asrael22]

Sun, 15 Jan 2017 09:03:09 -0500

PortablE::Open serial device, error passing parameter
OK, I got it.
There is a struct 'iostd' in 'ioextser' which is defined in exec/io and contains the fields 'command', 'actual', etc.

Thanks,
Manfred

Re: HOW TO GET A QUICK REPLY to your question [by asrael22]

Sat, 14 Jan 2017 15:12:34 -0500

PortablE::HOW TO GET A QUICK REPLY to your question
New thread opened.
Thanks.

PortablE r6 beta released [by PortablE]

Wed, 27 Apr 2016 10:58:13 -0500

PortablE::PortablE r6 beta released

PortablE is a recreation of the AmigaE programming language, along with all the improvements I wanted. PortablE works on AmigaOS4, AROS, MorphOS, and even Windows to an extent! (It should also work on AmigaOS3, but compiling needs a powerful machine like WinUAE.)

This is a small update, which improves (OS4) ReAction support, makes any generated MUI/ReAction code human-readable, and fixes a few bugs..

Previous versions of PortablE were aimed at existing AmigaE users, but PortablE now aims to be attractive for new users too. Although it's still "beta", it should work well, and further incompatible changes seem unlikely.

See the main manual for everything that has changed since r5. There have been the following big changes since the last beta:
* Built-in procedures can now support unlimited parameters (although only some have been updated to use this ability).
* Improved MUI & ReAction modules to use procedures with unlimited parameters (instead of immedate tag lists). So the C/C++ code generated for GUIs is now human-readable!
* Added the NoListOptim switch, so that the code generated for Immediate Lists can be more human-readable.
* AmigaOS4: Added the 'intuition/menuclass' module, aka "AISS menus", and the example program "Examples/Amiga/OS4_ReAction/MenuClass.e".
* When a bug exception was thrown during compilation, it could give the wrong message. Now fixed.
* Fixed a few module bugs.

You can download it from here:
Aminet
OS4Depot

PortablE comes with documentation, but you can find on-line documentation, examples & the latest version of PortablE from it's homepage:
cshandley.co.uk/portable

Re: Unicode support in PortablE [by PortablE]

Sun, 28 Feb 2016 16:20:46 -0500

PortablE::Unicode support in PortablE
If possible, I'd rather not add both TTEngine AND Scintilla to PortablE, since that potentially means wasted work. However, if you think that at least one of them would likely be acceptable (?), then I'll start looking at both (maybe they will be easy enough that I feel like doing both).

BTW, the "Examples/std/GUI/Amiga/NativeGuiExample.e" example shows how to add existing MUI components to cGUI. There is a "simple" way which is quick'n'dirty (but looks a bit ugly), and there is a "native" way which requires more code initially (but is much nicer to repeatedly use). There is basic documentation here:
http://cshandley.co.uk/portable/StandardFunctionality.html#23_34
and here for the AddNativeSimple() procedure:
http://cshandley.co.uk/portable/StandardFunctionality.html#23_2

Re: Using a C++ compiled .a library [by PortablE]

Sun, 28 Feb 2016 16:06:38 -0500

PortablE::Using a C++ compiled .a library
Quote:

Well, it's a bunch of header files, ~20 or so.

That sounds like a fair bit of work, unless they are small header files? Also procedures tend to be more work than constants, objects, etc.

Without seeing them myself, it's a bit hard to guage how much work it would be. I can send you my semi-automated tool, if you wish to try to do it yourself?

Re: How to speed up compilation process [by PortablE]

Sun, 10 Jan 2016 19:07:34 -0500

PortablE::How to speed up compilation process
Quote:

if variables can be declared anywhere in the code. Can this be done in PortablE? AFAIK in standard AmigaE this is not possible?

It's not possible in AmigaE nor PortablE, but it is something I'd like to add, mainly because it could greatly simplify code that uses temporary variables.

However, it would basically be a kludge, in that the variable's scope would still be the whole procedure, no matter where it was declared. So you would not be able to declare two variables with the same name in different parts of the same procedure.

Re: MorphOS and TCP [by asrael22]

Sat, 09 Jan 2016 18:14:34 -0500

PortablE::MorphOS and TCP
All right.
I just needed some HTTP client functionality.
For now I can live with a simple cURL wrapper.

Manfred