Introduction

A general-purpose programming language LeoScript.

lb and lc as console applications

IDEA: blue print: Chapter 3 Language from the red book...

PostScript Compatibility

This project aims to achieve compatibility with the programming language
aspects of PostScript Level 3 as defined in the Red Book, excluding all
graphics-related features and printer-specific functionality.

Intentionally Omitted Features

The following operators and objects are not implemented, as they fall outside
the project’s scope:

Graphics devices and graphics output
Packed arrays (including packedarray, setpacking, currentpacking)
The globaldict and $error dictionaries
Resource operators
Virtual memory operators
The maxlength and cvrs operators

Unimplemented Features (Potential for Future Enhancement)

The following operators are not implemented due to either the potential for
improved alternatives or the pursuit of a fundamentally different approach:

Execution control: start, stop, stopped
String parsing within the interpreter:
- token operator
- cvi and cvr for strings
- exec for strings
File operators: Most file operators
Interactive operators: executive, prompt, echo
Access control architecture:
- executeonly, noaccess, readonly
- rcheck, wcheck
Interpreter parameter operators: All interpreter parameter operators
Document structuring conventions: Meta structures

Language Level

Leonardus returns a language level 4. This can be used to code scripts
for both PostScript and LeoScipt. E.g.:

languagelevel 3 gt {
  % LeoScript code:
  true __odo
} if

Forth Compatibility

IDEA: TBD...

Operator Overview

All the details are extracted from the source code into the chapter Operators.

Multi-lingual Operator Names

Conceptually, for an ISO 639-2 language code xyz, there exists a vocabulary
named translate.xyz.

By using the LeoScript directive

(translate.xyz) vocabulary

at the beginning of a script, the translations for the language code xyz are activated.

You can query the status of the translation to language xyz by using
the Linux man page system:

apropos translate.xyz

Parser Pass Details

The parser reads from the standard input stream, runs checks and normalizes
it into the leon-format on standard out. It also executes the vocabulary operator.

Details

It ignores the remainder of lines starting with %. Additionally it ignores
a shebang line.

It halts execution upon error detection.

It normalizes integer tokens by stripping leading plus signs.

It removes the opening and closing parentheses from the string.

It removes all single backslashes from the string, preserving double
backslashes (\\) and newline sequences (\n). These are the only
escape sequences recognized in the leon-format.

Plausibility Checks

There are limits set by the parser to check the plausibility of LeoScripts.

The maximum length of strings is 100,000 characters.
The maximum length of names is 1000 characters.
The maximum nesting level for vocabularies is 16.

Leon-Format Details

This is a simple line-oriented format.
Each line begins with a character code followed by a colon (:).
The code identifies the data type of the subsequent value.

The different codes and data types are:

.	Description
I	A signed integer
R	A floating-point number
B	A boolean literal
S	An unquoted string with just two escape sequences `\\` and `\n`
N	A literal name token consisting of any characters but whitespaces
X	An executable name token consisting of any characters but whitespaces
#	The value is a comment
E	An error message

Unicode

UTF-8

All strings and names can contain Unicode characters.
They are encoded using UTF-8.

Stack Object

Stack objects are used internally by the interpreter. They are used to
construct the data structures for the operand stack, the execution stack,
and the dictionary stack.

Additionally, stack objects are composite semantic objects such as arrays,
dictionaries, and strings.

Stack specific operators are:

Polymorphic operators working on stacks are: get, put, forall, type

Text representation for stacks: cvs, =, stack, __print, ==, pstack

Type agnostic operators: def, dup, cvx, cvlit, xcheck, where, known, exch,
load, roll, ...

Rational Object

Rational objects are used to store a fraction with arbitrary precision.
There is no limit check for the length of the numerator and denominator
which build the internal structure.

Specific operators for the rationals are:

cvq
reciprocal
divqr
isunitfraction

Polymorphic operators working on rationals are:

cvi, cvr
add, sub, mul, idiv
eq, ge, gt, le, lt
abs, neg

Text representation for stacks: cvs, =, stack, __print, ==, pstack

Type agnostic operators: def, dup, cvx, cvlit, xcheck, where, known, exch,
load, roll, ...

OOP in Code Snippets

The following operators extend LeoScript with OOP capabilities:

new
send
override

These operators are implemented in the vocabulary Prototype.

Inheritance

To create a new PTBO without a parent:

/Statistics <<>> new

To create a new PTBO with a parent:

/MyStats Statistics new

To override a member procedure of a parent PTBO:

Shape begin
  /area { 0.0 } def
end
 
/Circle Shape new
Circle begin
  /area { radius dup mul pi mul } bind def
end

To verify that a member procedure exists in a parent PTBO by using override:

/Rectangle Shape new
Rectangle begin
  /area override { width height mul } bind def
end

Namespace

To enter the namespace of a PTBO and define a member:

Statistics begin
  /data [] def
end

To enter the namespace of a PTBO and define a procedure:

Statistics begin
  /mean {
    0.0
    data length 0 gt
    { data { add } forall
      data length div
    } if
  } bind def
end

To enter the namespace of a PTBO and call a member procedure:

MyStats begin
  mean
end

To enter the namespace of a PTBO and call a member procedure in send semantics:

/MyStats mean send

To call a core code operator, if it has been overridden in a PTBO namespace:

systemdict /add send

Ctors, Setters

A ctor supporting chaining:

/__ctor__ {
  /imag exch def
  /real exch def
} bind def

To create an PTBO with a constructor with parameters:

0 1 /i Complex new

To use the object chaining of the new operator:

0 1 /i Complex new /phase send =

The ctor is a normal procedure:

0 0 /MyObj Rectangle new pop

3 5 MyObj /__ctor__ send

Misc

Object chaining:

z1 z2 /add send /print send

OOP semantics

__ctor__ is called if there is one.

__ctor__ can consume SOs from the operand stack, but must not store
an SO on the operand stack.

IDEA: details...

Polymorphism

Overloading

LeoScript supports the concept of polymorphism, implemented through operator
overloading. For example, the 'add' operator can handle integers, real
numbers, and rational numbers with the same semantics. Using polymorphic
operators allows the programming of procedures or algorithms built on top of
them, which also become polymorphic. A useful example here is the
implementation of 'binom'.

Generic Containers

LeoScript provides generic containers. Both arrays and dictionaries can hold
objects of any type.

Literals

There are the operators '__one' and '__zero' to program constant numeric
values.

Vocabulary

See VOCABULARY

Shebang

Leonardus supports a shebang line

#!/usr/bin/env lb

by ignoring it as first line in LeoScript files. Together with the normal
Linux executable file attibute you get the possibility to start
scripts directly. This is implemented in the Example directory scripts.

The Object Tree

The composite semantic objects can contain other composite semantic objects,
creating trees of objects. All existing semantic objects are part of one of
the three fundamental interpreter stacks: the operand stack, the execution
stack, and the dictionary stack. Loops are not allowed in these trees and
will be detected during runtime by a heuristic.

Technical Background

The loop detection is implemented as a member function
SOcomposite::treeheight(), which calculates the height of the trees and
stops the calculation if the height reaches a threshold of maxtreeheight.

Notes

Edge Cases

quit )
is a valid programm. While the parser finds the syntax error, the execution
of the quit operator prevents it from taking effect.

1 { 1
is a valid programm. The interpreter exits by ignoring the open procedure.

Infinite Loop

/X { X } def X
generates an infinite loop of the intepreter. It is very hard to identify
this kind of problems, because with an exit criterion between { and X
it was a perfectly valid script!