documentation.txt

/-----------------------------------------------------------------------------\
|                          ______     _                                       |
|                         |___  /    | |                                      |
|                            / /  ___| |__  _ __ __ _                         |
|                           / /  / _ \ '_ \| '__/ _` |                        |
|                         ./ /__|  __/ |_) | | | (_| |                        |
|                         \_____/\___|_.__/|_|  \__,_|                        |
|                                                                             |
\-----------------------------------------------------------------------------/

SYNTAX :

Comments:
# <your comment>

Commands are separated by line breaks (\n) or semicolons (;).

Import other contents:
import <library>   # other installed library
import <code_path> # other code file to import

Types and variables:

defined variable     => <name> = <value> # variable with it's value
not defined variable => <type> <name>    # minimum size variable without value

int   => variable bits
int64 => 64 bits
float => 128 bits
list  => list
tuple => tuple
dict  => dict
str   => 32 bits utf8
stra  => 8 bits ASCII
bool  => 8 bits

int         => 42                              # int value
float       => 3.14159265                      # float value
string      => "string"                        # List of characters (string)
list        => [1, "hey", 3]                   # List of values (list)
tuple       => (1, "hey", 2)                   # Tuple, with at least one comma in the parenthesis
dictionnary => {"name" => "Lucas", "age" => 3} # Dictionary of values (dict)
booleen     => true/false                      # Boolean (bool)
None        => None                            # zero value (None)

Operators:
operators             => [=, +, -, *, /, //, ^, % (modulo)]
condensed operators   => [+=, -=, *=, /=, //=, ^=, %=]
comparative operators => [==, !=, >, <, >=, <=, in, not]
logics operators      => [and, or, xor, nand, nor, nxor]
list range            => [<start> : <end> : <step>] # interval of a list

Conditions:
condition => if (<condition>) {}
else if   => elif (<condition>) {}
else      => else {}

Loops :
conditional loop => while (<condition>) {}
loop for         => for (<variable>, <iterable>) {}

Priorities from left to right:
++++++++ "()", "[]", "{}"
+++++++  "="
++++++   "and", "or", "xor", "in", "nand", "nor", "xnor", "nin"
+++++    "<", ">", "<=", ">=", "!=", "=="
++++     "+", "-"
+++      "*", "/", "//", "%"
++       "^"
+        "." #OPP

Functions:
definie functions => def <name>(<parameters>) {}
call a function   => <name>(<parameters>)

Objects:
attributes => <object>.<attribut>
functions  => <objects>.<functions>()

Basic functions:
print(<message(s)>)           # display value(s) separated by commas
input(<message(s)>)           # displays the message and requests a value

not(<bool>)                   # invert boolean value

len(<list>)                   # length of a list
range(<start>, <end>, <step>) # list creation (range)

max(<list>)                   # maximum value of a list
min(<list>)                   # minimum value of a list

round(<value>)                # rounded to the nearest whole number
floor(<value>)                # rounded up to the nearest whole number
cell(<value>)                 # rounded down to the nearest whole number

int(<value>)                  # converts a value to an integer if possible
float(<value>)                # converts a value to a float if possible
str(<value>)                  # converts a value to a ut8 string if possible
stra(<value>)                 # converts a value to a ascii string if possible


RESTRICTIONS :

Never use variable or a function named with special caracters.
And specifically like that :

$<name>
$my_variable = 5
$stupid_variable = "hello"

Variable and functions named $<name> are use in internal for library and assembly code
If you use variable named like that you risk to modify variables in assembly code


DOCUMENTATION :

##  print(msg=str, last_chr=str)
    => display to the terminal

    input:
        msg, string, message to display
        last_chr, string,  message to be displayed after main message display
    ouput:
        None

##  exit(msg=bool)
    => exit the programme, with or not message

    input:
        msg, boolean, 1 exit with message, 0 exit without message
    ouput:
        None

##  hello_world(None)
    => print "Hello world!"

    input:
        nothing
    ouput:
        None

HOW IT WORK :

The stack:
    In generated assembly, the arguments are passed in the stack.
    Passed from left-to-right

    ex :
    function(arg1, arg2, arg3)
    =>
    push arg1
    push arg2
    push arg3
    call function

Variables:
    Each variables are do like this:

    - Anchor -----------------
    |                        |
    |  - Value ------------  |
    |  |                  |  |
    |  |                  |  |
    |  --------------------  |
    |------------------------|

    The advantage is we can change the variable value like we want.
    The "Anchor" is here to keep in memory the pointer to the value.
    The disadvantage is a value will require more memory to store a value.
    One solution is to create a specific type of variable that does not use the anchoring system,
    the value requires less memory, but can be modified as required.