Category:M2000 Interpreter: Difference between revisions

M2000 start as an experimental interpreted language, using a Module in Module idea (like a Procedure in Procedure) where each inner Module is closed for modification, but open for expansion, by replacing code at run time. Code executed in one pass. There is a pre-pass to determine the major type of an expression, a number or a string. Look this paradigm: We call inner Beta in two stages. Ins second stage we change inner Theta with Theta2. This is the decoration of Beta with Theta as Theta2. This is a temporary decoration because Beta after execution erase any new identifier including Theta. So each time we call Beta, statement Module Theta make this module unless a decoration stop it.

Module Theta (x){

Print "This is Theta, we get x=";x

For i=1 to 3 : Theta i : Next i

}

Beta

Module Theta2 (x) {

Print "This is Theta2, we get x=";x

}

As we can see from code, some statements are like BASIC, except the use of curly brackets {}. Check the code below. We have a Module (as a Procedure), where we define some functions and some variables, as entities. These entities defined in every call to CheckIt, and erased when execution return from CheckIt. By default every parameter in M2000 pass by value. We define two functions, Alfa() where we set type for parameter x and ExpType$() where we not set type for x, and we wish to return the name of type when we make a call. Using DEF we can define variables and functions (in one line).

\\ We can't call something out of this module

Function Alfa(X as double) {

Print ExpType$(10)

}

\\ We call it

CheckIt

\\ Now Funtion Alfa and all variables erased.

\\ We can call it again

A%=1212212.12@

Print A% ' 1212212

Print B% ' 122121213

}

So we say about Integer Variables, and no Integer Numeric Type. Like in Basic, M2000 is not case sensitive (except for labels), so A% and a% is the same. We may have A, A$ and A% as three variables, or A(), A%(), A$() as arrays or and functions. We can use name(@ ) to call function and not array if we have each with same name.

Def A(x)=x**2

\\ Make a group like a lambda

\\ A Class make a Global Function

Print Type$(P) ="Group"

}

Until now we see modules/functions/subs for procedural programming, Groups for OOP, Groups as lambda functions and lambda functions for functional programming. We can use events for groups and for COM objects, including GUI objects.

Group WithEvents Alpha {

Event "One"

Print M=111

}

Modules may have Threads, part of modules that can be executed in intervals, can be halted, or can be released, and can be erased. Each thread has own stack and may have own static variables (Modules and Functions also may have static variables), but can use modules variables and functions/modules/subs. Threads can run concurrent (thread return to task manager after execution of a statement or a block of statements) or sequential (a thread has to exit from interval to start other thread)

k=10

Thread {

}

}

Function Theta(x) {

Structure Points_single {

Print Eval(P, 0!x)=1212.12~, Eval(P, 0!y)=21.1212~

}