fussl syntax definition

example.fussl

     public locked A = {

        public init = function() {
            // dies ist der konstruktor
        };

        public methodA = function(p1, p2) {
            while(p1<=p2) {
                p1++;
            }
            return p1 + " | " + this.doof + " | " + this.methodB() + " | " + classA.doof;
        };

        private locked methodB = function() {
            return "can`t touch me!";
        };

        public doof = "Bernd";
    };

    public locked unchangeable = true || false;

    objectA = new classA;
    objectA.doof = "Hugo";
    some.debug.lib.print(objectA.methodA(2, 4)) // 4 | Hugo  | can`t touch this | Bernd
    some.debug.lib.print(classA.methodA(2, 4))  // 4 | Bernd | can`t touch this | Bernd

    // folgendes sollte Fehler erzeugen
    classA.methodB();       // methodB is private
    unchangeable = true;    // unchangeable ist locked


    createObject = function(value) {
        return {
            public y = 0;
            public locked x = value;
            public init = function(z) {
              this.y = z + x;
            }
        }
    }

    blubb = new (createObject(12))(30);
    blubb.y == 42;


    x = {
      z = a * b;
      return z;
    };

// mit dieser Definition..
    hui = function(a, b) x;  // na? verwundert?
// ist diese...
    hui(6, 7);          // 42
// gleichbedeutend mit diesem..
    a = 6; b = 7;
    run x;              // 42

fussl.syntax

Name: 
    FSSL - F**king Slow Scripting Language

    ""everything is an object""

Ziele: 
  - alles ist ein Objekt (bzw ein "Context")
  - (absolutes|totales|uneingeschränktes) operator overloading
  - Syntax im Grunde C-Artig (JavaScript-Like) 
  - "gewohnte" Usage ('kein Ruby!') 

Keywords:
    - "run": führt einen angegebenen Kontext aus
             Beim auführen einer Funktion werden im Grunde lediglich die Argumente Initialisiert und daraufhin der Context (=Funktionskörper) ausgeführt
    - "new": klont das Objekt, führt wenn vorhanden die init-Funktion aus und gibt eine Referenz auf das neue Objekt zurück


Überlegungen:
 - ein Präprozessor schein Sinnvoll um einige Keywords durch atomaren code zu ersetzten (new => clone & init, functioncall => vars & run
 - true, false & null sind ebenfalls Objekte.
 - was bedeutet "locked" für Objekte. Wichtig! Denn alles ist ein Objekt!
    '-> sind alle properties des Objektes ebenfalls gelockt?
    '-> wäre doof das das Objekt damit mehr oder weniger nutzlos wäre?
    '-> die Referenz ist nichtmehr änderbar. Ein überschreiben des Objektes ist damit nicht möglich. 
    '-> wenn alle public methoden "locked" sind ist ein ändern des Verhaltens der Methode 
        nur noch durch die Erweiterung der Klasse möglich
 - wenn eine Klasse auch "nur" ein Objekt ist, es also keine eigentlichen "Instanzen" gibt. 
   Wie funktioniert dann ein extends?
    '-> bla = class extends arr => der Kontext von arr wird nach bla kopiert und dann mit der Definition von bla erweitert. 
 - Probleme wird es mit dem Mappen von "this" geben, da jeder neuer Block in { } ein neuer Kontext ist. 

Syntax: 

NAME:
    (A-Za-z)(A-Za-z0-9_)*

VISIBILITY: 
    "public"
    "private"
    "protected"

DEC_NUMBER:
    (1-9)(0-9)*[ "." (0-9)* ]

OKT_NUMBER:
    0(0-7)* [ "." (0-7)* ]

HEX_NUMBER
    "0x"(0-9A-Fa-f)* [ "." (0-9A-Fa-f)* ]

STRING: 
    "\"" .* "\""

CONTEXT: 
    "{" STATEMENT*  "}"

FUNCTION_DEFINITION:
    "function(" [ NAME [ "," NAME ]* ] ")" CONTEXT

PROPERTY_DEFINITION:
    [ VISIBILITY ][ "locked" ] NAME [ "=" ( OPERATION | VALUE ) ] ";"

VARIABLE:
    NAME [ "." NAME ]*    

FUNCTION_CALL:
    ( FUNCTION_DEFINITION | VARIABLE ) "(" [ NAME [ "," NAME ]* ] ")"

VALUE: 
    VARIABLE
    NUMBER
    STRING
    FUNCTION_CALL
    FUNCTION_DEFINITION
    CONTEXT

OPERATION: 
    (OPERATION | VALUE) OPERATOR (OPERATION | VALUE)
    "new" (VARIABLE | "(" FUNCTION_CALL ")" )[ "(" [ NAME [ "," NAME ]* ] ")" ]
    ("clone"|"delete"|"unset"|"lock"|"run") VARIABLE
    
LOOP:
    "while(" CONDITION ")" CONTEXT 
    "for(" OPERATION ";" CONDITION ";" OPERATION ")" CONTEXT
    "do" CONTEXT "while(" CONDITION ");"

IF: 
    "if(" CONDITION "){" STATEMENT* "}" [ "else" ( IF | "{" STATEMENT* "}" )]*

STATEMENT:
    [VARIABLE ASSIGN_OPERATOR]* OPERATION ";"
    LOOP
    IF
    "return " OPERATION ";"


CONDITION:  
    OPERATION COMPERATOR OPERATION
    ( CONDITION | VALUE ) LOGIC_OPERATOR ( CONDITION | VALUE )

OPERATOR: 
    MATH_OPERATOR
    LOGIC_OPERATOR
    COMPERATOR

ASSIGN_OPERATOR:
    [MATH_OPERATOR]=

MATH_OPERATOR:
    "+"
    "-"
    "*"
    "/"
    "%"
 
LOGIC_OPERATOR:
    "&&"
    "||"
   
COMPERATOR:
    "<=" 
    ">="
    "=="
    "!="

Operator overloading wäre noch nice glaube ich. Der Ruby Ansatz hat da einen gewissen Charme. Dort ist jeder Aufruf eines Operators gleichzeitig ein Methodenaufruf. Also a + b ist das selbe wie a.+(b)

Unterschied zwischen clone und new => new ruft den konstruktor (.init)