You can find all the code for it my library here:
https://github.com/nophead/NopSCADlib

On Sun, 5 Apr 2020 at 14:32, Ron Wheeler via Discuss <
discuss@lists.openscad.org> wrote:

On 4/4/2020 5:41 PM, Ron Wheeler via Discuss wrote:

It isn't intended as a use case.  It's intended to demonstrate parts of
the order of execution, and that OpenSCAD doesn't execute in an order
that you would expect.

Here's another.

a = echo("assign a") 123; if (echo("compare") a == b) { echo("a and
b are equal"); } b = echo("assign b") 123;

When you run this, you'll see that the two assignments occur before the
condition and body of the "if" run.

One could debate whether this language structure is a good thing, but
it is what it is and I assume that it would be a major redesign to
change it.

On 4/4/2020 4:54 PM, Ron Wheeler via Discuss wrote:

Special variables - the ones beginning with $ - are constant too, just
with different scope.

Regular variables have scopes that follow the block structure of the
program:

a = 1;
module foo() {
    b = 2;
    if (a==b) {
        a = 4;
        c = 3;
    }
}

The scope of the first "a" is the whole file, except the body of the
"if".  The scope of "b" is the module.  The scope of "c" is the body of
the "if" block.  The scope of the "a" in the "if" block is the body of
the if block, overriding/hiding/shadowing the file-scope "a".

This scoping is pretty typical for any block-structured language.

Special variables are scoped according to the execution tree.

$a = 1;

module foo() {
    echo($a);
}

module bar() {
    $a = 2;
    foo();
}

foo();
bar();
foo($a=3);

For the first invocation of "foo", the top-level definition of $a is in
scope, so the value is 1.

For the invocation of "bar", "bar" overrides the definition of $a, and
so when it executes "foo" the value is 2.

For the final invocation of "foo", the value of $a is overridden for
that one call, and so the value is 3.

I agree that improving the messages would be helpful.  Whether or not
it's easy depends on what kind of compilation infrastructure they're
using.  The compilation infrastructure might not report anything other
than "I wasn't able to match the defined syntax".

Note that some of the most obvious missing-semicolon cases are not
actually syntax errors.

module foo()
{
    echo("foo");
}

module bar()
{
    echo("bar");
}

foo()
bar()
if (true) {
    echo("hello");
}

is syntactically completely legal.  Doesn't do what you probably expect,
but it's legal.

(The built-in modules detect this error at run time.  It would be cool
if user-defined modules could get similar detection.  It wouldn't be as
simple as "was children() called"; it would have to involve remembering
whether there are any calls to children() or $children in the module.)

JordanBrown wrote

I assume that built-in modules just know that they don't take children, so
the presence of children is suspicious.  They don't do some kind of internal
code analysis to decide whether children are OK.  This effect is easily
achieved with user-defined modules.  Just tag modules that don't use
children with "no_children($children)" as shown below:

module foo() {
no_children($children);
echo("hello world");
// no children used here
}

module no_children(count)
{
assert(count==0, str("Module ",parent_module(1),"() does not support child
modules"));
}

--
Sent from: http://forum.openscad.org/

On 4/5/2020 12:33 PM, adrianv wrote:

Yes.

Sure.  As you show, you can trivially do this check yourself.  But it
would be cool if the infrastructure did it for you, so that a newcomer
who doesn't even know what children() does will get the protection.

Someone suggested a way to solve my BOM problem with echo and a script.
I am working on that.
I am still not convinced that it is impossible to reliably describe a
"real" global variable.

The missing ";" error message problem is not that OpenSCAD can not
recognize that it is missing but does not give any indication about how
it knew that it was missing.
It seems that it knows that it found a keyword in a context where it was
not allowed.

It would be a bit of work to test that if a ";" had been inserted before
the keyword, the previous block and the current block would be legal and
suggest to the script-writer to look to see if adding the ";" would be
the right thing to do.

This is a common problem in writing scripts but this is clearly an
additional usability feature rather than a functional demand.

Ron

On 2020-04-05 3:22 p.m., Jordan Brown wrote:

--
Ron Wheeler
Artifact Software
438-345-3369
rwheeler@artifact-software.com

The parser is automatically generated by yacc, so I don't know if it is
possible to get better syntax error messages. If you load the file into the
editor and hit F5 it will position the cursor where the parser thinks the
error is.

The are no variables in OpenSCAD, global or otherwise, only named
constants, apart from in for loops.

On Mon, 6 Apr 2020 at 05:38, Ron Wheeler via Discuss <
discuss@lists.openscad.org> wrote:

On 4/5/2020 9:37 PM, Ron Wheeler wrote:

Another possibility that I think some have used is to write a program in
another language, that emits OpenSCAD as an intermediate form.

They don't exist.  There is no way to change the value of a "variable". 
Of course the language could have been designed with conventional
variables and a conventional control flow, but it wasn't.

Moreover, there is no way to get information out of a block or a module,
back to the main body of the program.  (Of course the geometry comes
out, and echo() output comes out, but neither of those is available to
the rest of the program.)

nop head says:

I'd actually argue with even that last exception.  Just as when you
enter a block a second time the "variables" can have different values,
I'd say that each iteration through a for loop has a new instance of the
variable with a new value.  That is,

for (i=[1:3]) {
    foo(i);
}

is equivalent to

group() {
    i = 1;
    foo(i);
}
group() {
    i = 2;
    foo(i);
}
group() {
    i = 3;
    foo(i);
}

Now, that's my mental model, not knowledge of the implementation, but I
think it's consistent.  (I can't think of any way that you can
distinguish the behaviors under the two models, but I prefer the model
that consistently says that you can't change the value of a  variable.)

Sometimes I think of it as a macro language, not a conventional
programming language at all.  Everything that looks like a control
structure is expanded into zero or more instances of its argument.

Most of the time I think of it as a programming language that emits
geometry, but the macro processor model is probably more accurate.

On 06.04.20 19:02, Jordan Brown wrote:

True, and there are some use cases where it makes a lot
of sense.

I think it would be still nice to have things like BOM
covered without that. I believe the way to go is what
was already mentioned in a previous post: tagging parts
of the design with meta data.

I've collected some ideas in:
https://github.com/openscad/openscad/wiki/Meta-Data-Use-Cases

This kind of annotations is widely adopted in other
languages and is used to also control external/separate
applications or generators.

ciao,
Torsten.