🚀 LSL Programming Language

Version 1.0.1 Stable - A simple, powerful scripting language with Python-like syntax, comprehensive error reporting, and built-in libraries.

✨ Features: Modern error handling • Rich library ecosystem • Multi-language support • IDE integration

Introduction

LSL (Light Scripting Language) is a lightweight scripting language designed for simplicity and readability. It supports basic data types, control structures, functions, classes/objects, file operations, and useful built-in functions.

Blocks are delimited explicitly with keywords like end (or elif/else for conditionals), so indentation is optional (though recommended for readability).

Data Types

Number: floating-point (e.g., 42, 3.14)
String: "hello" or 'hello' (supports escape sequences like \n, \t)
Boolean: true, false
Null: null
List: [1, "a", true]
Dictionary: {key: "value", age: 30}
Object: instances of classes

Variables and Assignment

Variables are created on first assignment (no declaration needed).

x = 10
name = "Alice"
flag = true
data = [1, 2, 3]
config = {host: "localhost", port: 8080}

Control Structures

If / Elif / Else

if x > 0:
    print "positive"
elif x < 0:
    print "negative"
else:
    print "zero"
end

While

while x < 10:
    print x
    x = x + 1
end

Do-While

do:
    print x
    x = x + 1
end
while x < 10

For (numeric)

for i in 1..10:
    print i
end

For-In (iteration)

for item in my_list:
    print item
end

Loop (repeat n times)

loop 5:
    print "hello"
end

Functions

function greet(name):
    print "Hello, " + name
    return "done"
end

call greet("Bob")  # standalone call
result = call greet("Alice")  # call for return value
print result

Functions can have parameters and return values (or null if no return).

Classes and Objects

LSL supports object-oriented programming with classes, methods, and instance variables.

Basic Class Definition

class Person:
    function __init__(name, age):
        self.name = name
        self.age = age
    end

    function greet():
        print "Hi, I'm " + self.name + " and I'm " + self.age + " years old"
    end
    
    function have_birthday():
        self.age = self.age + 1
        print "Happy birthday! Now I'm " + self.age
    end
end

# Create instances
p1 = new Person("Alice", 30)
p2 = new Person("Bob", 25)

# Call methods
p1.greet()      # Hi, I'm Alice and I'm 30 years old
p2.greet()      # Hi, I'm Bob and I'm 25 years old

# Access properties directly
print p1.name        # Alice
print p2.age         # 25

# Modify properties
p1.have_birthday()  # Happy birthday! Now I'm 31
print p1.age            # 31

Methods with Parameters

class Calculator:
    function __init__():
        self.result = 0
    end
    
    function add(x):
        self.result = self.result + x
        return self.result
    end
    
    function multiply(x):
        self.result = self.result * x
        return self.result
    end
    
    function reset():
        self.result = 0
    end
end

calc = new Calculator()
print calc.add(5)        # 5
print calc.add(3)        # 8
print calc.multiply(2)   # 16
calc.reset()
print calc.result        # 0

Key Concepts

Constructor: __init__ method is called when creating instances with new
Instance variables: Use self.variable_name to store object state
Methods: Functions defined inside classes that can access self
Method calls: Use object.method(args) syntax
Property access: Use object.property to read/write instance variables

💡 Important: Method calls can be used directly as expressions without 'call' keyword. Use object.method(args) for method calls. Use call function_name(args) for function calls.

Built-in Functions and File Operations

Function	Description	Example
`print expr`	Outputs value	`print "hello"`
`input "prompt"`	Read user input with prompt	`name = input "Enter name: "`
`len(obj)`	Length of string/list/dict	`len("abc")`
`substring(str, start, len)`	Substring	`substring("hello", 1, 3)`
`replace(str, old, new)`	Replace all occurrences	`replace("aabb", "a", "c")`
`trim(str)`	Remove leading/trailing whitespace	`trim(" hi ")`
`split(str, sep)`	Split string	`split("a,b,c", ",")`
`readfile "path"`	Read entire file as string	`content = readfile "data.txt"`
`writefile "path", data`	Write data to file	`writefile "out.txt", "hello"`
`appendfile "path", data`	Append to file	`appendfile "log.txt", "event"`
`createdir "path"`	Create directory	`createdir "newfolder"`
`listdir "path"`	Returns list of entries	`files = listdir "."`
`deletedir "path"`	Delete directory	`deletedir "temp"`
`exists path`	File/directory exists?	`if exists "file.txt": ...`

Input/Output Examples

# Interactive input
name = input "What's your name? "
age = input "How old are you? "

print "Hello, " + name + "!"
print "You are " + age + " years old."

# Simple calculator
print "Simple Calculator"
num1 = input "Enter first number: "
num2 = input "Enter second number: "
result = num(num1) + num(num2)
print "Result: " + result

Modules

use "mymodule.lsl" as my

result = my.my_function(42)

Loads another LSL file and makes its functions available under the given prefix.

📚 Libraries

LSL includes built-in libraries that extend functionality with additional functions. Use them with the use command.

🔢 Math Library

Load with: use math

Function	Description	Example
`sin(x)`	Sine (degrees)	`sin(90)`
`cos(x)`	Cosine (degrees)	`cos(0)`
`tan(x)`	Tangent (degrees)	`tan(45)`
`sqrt(x)`	Square root	`sqrt(16)`
`pow(x, y)`	Power function	`pow(2, 3)`
`log(x)`	Natural logarithm	`log(10)`
`exp(x)`	Exponential function	`exp(1)`
`factorial(x)`	Factorial	`factorial(5)`

use math
print sin(90)        # 1
print sqrt(25)       # 5
print pow(2, 4)      # 16
print factorial(6)   # 720

🔤 String Library

Load with: use string

Function	Description	Example
`contains(text, substr)`	Check if text contains substring	`contains("hello", "ell")`
`startswith(text, prefix)`	Check if text starts with prefix	`startswith("hello", "he")`
`endswith(text, suffix)`	Check if text ends with suffix	`endswith("hello", "lo")`
`to_upper(text)`	Convert to uppercase	`to_upper("hello")`
`to_lower(text)`	Convert to lowercase	`to_lower("HELLO")`

use string
print contains("hello world", "world")  # true
print startswith("hello", "he")          # true
print endswith("hello", "lo")            # true
print to_upper("hello world")            # HELLO WORLD

📋 List Library

Load with: use list

Advanced list manipulation functions (coming soon).

🚀 Advanced Library

Load with: use advanced

Advanced programming functions like map, filter, reduce (coming soon).

🛠️ Error Reporting

LSL provides comprehensive error reporting with precise line numbers and detailed error messages.

Error Types

Syntax Errors: Invalid syntax, missing keywords, unclosed blocks
Runtime Errors: Type mismatches, invalid operations, file errors

Error Examples

# Syntax Error examples
print "unclosed string    # [Syntax Error at line 1: Unclosed string literal]
unknown_command          # [Syntax Error at line 2: Unknown command: unknown_command]
bad_function()           # [Syntax Error at line 3: Function calls must use 'call' keyword]

# Runtime Error examples  
use math
print sqrt(-1)           # [Runtime Error at line 6: sqrt() expects a non-negative number]

💡 Pro Tip: All errors include line numbers for quick debugging. The IDE highlights error lines automatically.

Full Example

function factorial(n):
    if n <= 1:
        return 1
    else:
        return n * call factorial(n - 1)  # recursive call
    end
end

result = call factorial(6)  # call for return value
print "Factorial of 6 is: " + result

🎯 Practical Examples

Number Guessing Game

use math

# Number guessing game
secret = call num(call sqrt(random() * 100))  # Random number 1-10
attempts = 0
max_attempts = 5

print "I'm thinking of a number between 1 and 10!"
print "You have " + max_attempts + " attempts."

while attempts < max_attempts:
    guess = input "Enter your guess: "
    guess_num = call num(guess)
    attempts = attempts + 1
    
    if guess_num == secret:
        print "🎉 Congratulations! You got it in " + attempts + " attempts!"
        break
    elif guess_num < secret:
        print "Too low! Try again."
    else:
        print "Too high! Try again."
    end
    
    if attempts == max_attempts:
        print "Game over! The number was " + secret
    end
end

To-Do List Manager

class TodoManager:
    function __init__():
        self.todos = []
    end
    
    function add(task):
        self.todos = self.todos + [task]
        print "Added: " + task
    end
    
    function list():
        if len(self.todos) == 0:
            print "No tasks yet!"
        else:
            print "Your tasks:"
            for i in 1..len(self.todos):
                print i + ". " + self.todos[i-1]
            end
        end
    end
    
    function remove(index):
        if index > 0 and index <= len(self.todos):
            removed = self.todos[index-1]
            # Remove item by creating new list without it
            new_todos = []
            for i in 1..len(self.todos):
                if i != index:
                    new_todos = new_todos + [self.todos[i-1]]
                end
            end
            self.todos = new_todos
            print "Removed: " + removed
        else:
            print "Invalid task number!"
        end
    end
end

# Usage
todo = new TodoManager()
todo.add("Learn LSL programming")
todo.add("Build a project")
todo.list()
todo.remove(1)
todo.list()

File Processor

class FileProcessor:
    function __init__(filename):
        self.filename = filename
        self.content = ""
    end
    
    function read():
        if exists self.filename:
            self.content = readfile self.filename
            print "Read " + len(self.content) + " characters from " + self.filename
            return true
        else:
            print "File not found: " + self.filename
            return false
        end
    end
    
    function count_words():
        words = call split(self.content, " ")
        return len(words)
    end
    
    function count_lines():
        lines = call split(self.content, "\n")
        return len(lines)
    end
    
    function word_frequency():
        words = call split(self.content, " ")
        freq = {}
        for word in words:
            word = call to_lower(call trim(word))
            if word != "":
                if freq[word]:
                    freq[word] = freq[word] + 1
                else:
                    freq[word] = 1
                end
            end
        end
        return freq
    end
end

# Usage
processor = new FileProcessor("sample.txt")
if processor.read():
    print "Words: " + processor.count_words()
    print "Lines: " + processor.count_lines()
    freq = processor.word_frequency()
    print "Unique words: " + len(freq)
end

This guide covers the current AST-based implementation. The language is still evolving.

🚀 Programovací jazyk LSL

Verze 1.0.1 Stable - Jednoduchý, výkonný skriptovací jazyk s pythonovskou syntaxí, komplexním error reportingem a vestavěnými knihovnami.

✨ Funkce: Moderní error handling • Bohatý ekosystém knihoven • Podpora více jazyků • Integrace s IDE

Úvod

LSL (Light Scripting Language) je lehký skriptovací jazyk navržený pro jednoduchost a čitelnost. Podporuje základní datové typy, řídicí struktury, funkce, třídy/objekty, práci se soubory a užitečné vestavěné funkce.

Bloky jsou ohraničeny explicitně klíčovými slovy jako end (nebo elif/else u podmínek), takže odsazení je volitelné (doporučuje se ale pro přehlednost).

Datové typy

Číslo: desetinné (např. 42, 3.14)
Řetězec: "ahoj" nebo 'ahoj' (podpora escape sekvencí jako \n, \t)
Boolean: true, false
Null: null
Seznam: [1, "a", true]
Slovník: {klíč: "hodnota", věk: 30}
Objekt: instance tříd

Proměnné a přiřazení

Proměnné vznikají při prvním přiřazení (není potřeba deklarace).

x = 10
jmeno = "Alice"
priznak = true
data = [1, 2, 3]
konfig = {host: "localhost", port: 8080}

Řídicí struktury

If / Elif / Else

if x > 0:
    print "kladné"
elif x < 0:
    print "záporné"
else:
    print "nula"
end

While

while x < 10:
    print x
    x = x + 1
end

Do-While

do:
    print x
    x = x + 1
end
while x < 10

For (numeric)

for i in 1..10:
    print i
end

For-In (iterace)

for polozka in muj_seznam:
    print polozka
end

Loop (opakování n-krát)

loop 5:
    print "ahoj"
end

Funkce

function pozdrav(jmeno):
    print "Ahoj, " + jmeno
    return "hotovo"
end

call pozdrav("Bob")  # samostatne volani
result = call pozdrav("Alice")  # call pro navratovou hodnotu
print result

Funkce mohou mit parametry a vracet hodnoty (nebo null, pokud neni return).

Třídy a objekty

LSL podporuje objektové programování s třídami, metodami a instancními proměnnými.

Základní definice třídy

class Osoba:
    function __init__(jmeno, vek):
        self.jmeno = jmeno
        self.vek = vek
    end

    function pozdrav():
        print "Ahoj, já jsem " + self.jmeno + " a je mi " + self.vek + " let"
    end
    
    function oslava_narozenin():
        self.vek = self.vek + 1
        print "Vše nejlepší k narozeninám! Teď je mi " + self.vek
    end
end

# Vytvoř instance
osoba1 = new Osoba("Alice", 30)
osoba2 = new Osoba("Bob", 25)

# Zavolej metody
osoba1.pozdrav()      # Ahoj, já jsem Alice a je mi 30 let
osoba2.pozdrav()      # Ahoj, já jsem Bob a je mi 25 let

# Přístup k vlastnostem přímo
print osoba1.jmeno        # Alice
print osoba2.vek         # 25

# Modifikuj vlastnosti
osoba1.oslava_narozenin()  # Vše nejlepší k narozeninám! Teď je mi 31
print osoba1.vek            # 31

Metody s parametry

class Kalkulacka:
    function __init__():
        self.vysledek = 0
    end
    
    function pridej(x):
        self.vysledek = self.vysledek + x
        return self.vysledek
    end
    
    function vynasob(x):
        self.vysledek = self.vysledek * x
        return self.vysledek
    end
    
    function reset():
        self.vysledek = 0
    end
end

kalk = new Kalkulacka()
print kalk.pridej(5)        # 5
print kalk.pridej(3)        # 8
print kalk.vynasob(2)       # 16
kalk.reset()
print kalk.vysledek        # 0

Klíčové koncepty

Konstruktor: Metoda __init__ je volána při vytváření instancí s new
Instanční proměnné: Použijte self.nazev_promenne pro uložení stavu objektu
Metody: Funkce definované uvnitř tříd, které mohou přistupovat k self
Volání metod: Použijte syntaxi objekt.metoda(args)
Přístup k vlastnostem: Použijte objekt.vlastnost pro čtení/zápis instančních proměnných

💡 Důležité: Volání metod mohou být použita přímo jako výrazy bez 'call' keywordu. Použijte objekt.metoda(args) pro volání metod. Použijte call nazev_funkce(args) pro volání funkcí.

Vestavěné funkce a operace se soubory

Funkce	Popis	Příklad
`print výraz`	Výpis hodnoty	`print "ahoj"`
`input "prompt"`	Čtení uživatelského vstupu s promptem	`jméno = input "Zadej jméno: "`
`len(obj)`	Délka řetězce/seznamu/slovníku	`len("abc")`
`substring(řet, start, délka)`	Podřetězec	`substring("ahoj", 1, 3)`
`replace(řet, starý, nový)`	Nahradí všechny výskyty	`replace("aabb", "a", "c")`
`trim(řet)`	Odstraní mezery na začátku/konci	`trim(" ahoj ")`
`split(řet, oddělovač)`	Rozdělí řetězec	`split("a,b,c", ",")`
`readfile "cesta"`	Načte celý soubor jako řetězec	`obsah = readfile "data.txt"`
`writefile "cesta", data`	Zapíše data do souboru	`writefile "vystup.txt", "ahoj"`
`appendfile "cesta", data`	Připíše na konec souboru	`appendfile "log.txt", "událost"`
`createdir "cesta"`	Vytvoří adresář	`createdir "nová_složka"`
`listdir "cesta"`	Vrátí seznam položek	`soubory = listdir "."`
`deletedir "cesta"`	Smaže adresář	`deletedir "dočasné"`
`exists cesta`	Existuje soubor/adresář?	`if exists "soubor.txt": ...`

Příklady vstupu/výstupu

# Interaktivní vstup
jmeno = input "Jak se jmenujes? "
vek = input "Kolik ti je let? "

print "Ahoj, " + jmeno + "!"
print "Je ti " + vek + " let."

# Jednoduchá kalkulačka
print "Jednoduchá Kalkulačka"
cislo1 = input "Zadej prvni cislo: "
cislo2 = input "Zadej druhe cislo: "
vysledek = call num(cislo1) + call num(cislo2)
print "Vysledek: " + vysledek

Moduly

use "mujmodul.lsl" as muj

vysledek = muj.moje_funkce(42)

Načte jiný LSL soubor a zpřístupní jeho funkce pod danou předponou.

📚 Knihovny

LSL obsahuje vestavěné knihovny, které rozšiřují funkčnost o další funkce. Používejte je s příkazem use.

🔢 Matematická knihovna

Načtení: use math

Funkce	Popis	Příklad
`sin(x)`	Sinus (stupně)	`sin(90)`
`cos(x)`	Kosinus (stupně)	`cos(0)`
`tan(x)`	Tangens (stupně)	`tan(45)`
`sqrt(x)`	Odmocnina	`sqrt(16)`
`pow(x, y)`	Mocnina	`pow(2, 3)`
`log(x)`	Přirozený logaritmus	`log(10)`
`exp(x)`	Exponenciální funkce	`exp(1)`
`factorial(x)`	Faktoriál	`factorial(5)`

use math
print sin(90)        # 1
print sqrt(25)       # 5
print pow(2, 4)      # 16
print factorial(6)   # 720

🔤 Textová knihovna

Načtení: use string

Funkce	Popis	Příklad
`contains(text, podřetězec)`	Zkontroluje obsah	`contains("ahoj", "ho")`
`startswith(text, prefix)`	Zkontroluje začátek	`startswith("ahoj", "a")`
`endswith(text, suffix)`	Zkontroluje konec	`endswith("ahoj", "j")`
`to_upper(text)`	Převede na velká písmena	`to_upper("ahoj")`
`to_lower(text)`	Převede na malá písmena	`to_lower("AHOJ")`

use string
print contains("ahoj světe", "světe")  # true
print startswith("ahoj", "a")          # true
print endswith("ahoj", "j")            # true
print to_upper("ahoj světe")            # AHOJ SVĚTE

📋 Knihovna pro seznamy

Načtení: use list

Pokročilé funkce pro práci se seznamy (brzy dostupné).

🚀 Pokročilá knihovna

Načtení: use advanced

Pokročilé funkce jako map, filter, reduce (brzy dostupné).

🛠️ Error Reporting

LSL poskytuje komplexní error reporting s přesnými čísly řádků a detailními chybovými hláškami.

Typy chyb

Syntax Errors: Neplatná syntaxe, chybějící klíčová slova, neuzavřené bloky
Runtime Errors: Chyby typů, neplatné operace, chyby souborů

Příklady chyb

# Příklady syntax chyb
print "neuzavreny retezec    # [Syntax Error at line 1: Unclosed string literal]
neznamy_prikaz             # [Syntax Error at line 2: Unknown command: neznamy_prikaz]
spatna_funkce()            # [Syntax Error at line 3: Function calls must use 'call' keyword]

# Příklady runtime chyb
use math
print sqrt(-1)              # [Runtime Error at line 6: sqrt() expects a non-negative number]

💡 Tip: Všechny chyby obsahují čísla řádků pro rychlé ladění. IDE automaticky zvýrazňuje chybové řádky.

Kompletní příklad

function faktorial(n):
    if n <= 1:
        return 1
    else:
        return n * call faktorial(n - 1)  # rekurzivní volání
    end
end

vysledek = call faktorial(6)  # call pro návratovou hodnotu
print "Faktorial 6 je: " + vysledek

🎯 Praktické příklady

Hra hádání čísel

use math

# Hra hádání čísel
secret = call num(call sqrt(random() * 100))  # Náhodné číslo 1-10
attempts = 0
max_attempts = 5

print "Myslim si cislo mezi 1 a 10!"
print "Mas " + max_attempts + " pokusu."

while attempts < max_attempts:
    guess = input "Zadej svuj tip: "
    guess_num = call num(guess)
    attempts = attempts + 1
    
    if guess_num == secret:
        print "🎉 Gratuluji! Uhadl jsi to v " + attempts + " pokusech!"
        break
    elif guess_num < secret:
        print "Příliš nízké! Zkus znovu."
    else:
        print "Příliš vysoké! Zkus znovu."
    end
    
    if attempts == max_attempts:
        print "Konec hry! Číslo bylo " + secret
    end
end

Manager úkolů

class TodoManager:
    function __init__():
        self.todos = []
    end
    
    function add(task):
        self.todos = self.todos + [task]
        print "Přidáno: " + task
    end
    
    function list():
        if len(self.todos) == 0:
            print "Žádné úkoly ještě!"
        else:
            print "Tvé úkoly:"
            for i in 1..len(self.todos):
                print i + ". " + self.todos[i-1]
            end
        end
    end
    
    function remove(index):
        if index > 0 and index <= len(self.todos):
            removed = self.todos[index-1]
            # Odstraň položku vytvořením nového seznamu bez ní
            new_todos = []
            for i in 1..len(self.todos):
                if i != index:
                    new_todos = new_todos + [self.todos[i-1]]
                end
            end
            self.todos = new_todos
            print "Odstraněno: " + removed
        else:
            print "Neplatné číslo úkolu!"
        end
    end
end

# Použití
todo = new TodoManager()
todo.add("Naucit se LSL programovani")
todo.add("Postavit projekt")
todo.list()
todo.remove(1)
todo.list()

Procesor souborů

class FileProcessor:
    function __init__(filename):
        self.filename = filename
        self.content = ""
    end
    
    function read():
        if exists self.filename:
            self.content = readfile self.filename
            print "Přečteno " + len(self.content) + " znaků z " + self.filename
            return true
        else:
            print "Soubor nenalezen: " + self.filename
            return false
        end
    end
    
    function count_words():
        words = call split(self.content, " ")
        return len(words)
    end
    
    function count_lines():
        lines = call split(self.content, "\n")
        return len(lines)
    end
    
    function word_frequency():
        words = call split(self.content, " ")
        freq = {}
        for word in words:
            word = call to_lower(call trim(word))
            if word != "":
                if freq[word]:
                    freq[word] = freq[word] + 1
                else:
                    freq[word] = 1
                end
            end
        end
        return freq
    end
end

# Použití
processor = new FileProcessor("sample.txt")
if processor.read():
    print "Slova: " + processor.count_words()
    print "Řádky: " + processor.count_lines()
    freq = processor.word_frequency()
    print "Unikátní slova: " + len(freq)
end

Tento průvodce pokrývá aktuální implementaci založenou na AST. Jazyk se stále vyvíjí.