Τρίτη, 19 Σεπτεμβρίου 2017

Variadic Functions in M2000 plus calling mechanism in M2000.

Because M2000 functions and modules read arguments using a Read command (or more as we can see later), we can make Variadic Functions (accepts a variable number of arguments).


Function Sum {
      n=stack.size
      total=0
      If n=0 then Error "I want one parameter at least"
      for i=1 to n {
            read k
            total+=k
      }
      =total
}

Print Sum(1,2,3,4), sum(10,20)

In functions there is no Return command. Return done at the end of function's code, or by using Exit, or Break, or Error, or when an Error occur.  So char "=" at the left position means "assign value to function". Here we have no "variable" with name as Function. We have an accumulator for this function, so we can store only values.
Type of function can be one number/object or string/object, but we know if we can store string if name has $ as last character. So Sum can't return a string value.

Simple functions are not first class in M2000, but lambda functions are.
We can pass a function by reference (add these lines to previous example):

Module CheckReference (&S()) {
      Print S(1,2,3,4), S(10,20)
}

CheckReference &Sum()

Also notice that Modules get stack from parent, so if we want to pass dynamic number of arguments, we have to include a guard as last argument, or a count indicator at first argument.


Lets see another example. Modules can't passed by reference (later we can see what is a reference for a function). But modules have a decoration mechanism, which pass a module in a module, and that "External" module is locked for changes. So a Module Sum {} inside CheckDecoration can't change external Sum. Another aspect for Modules and Functions, is that variable scope is local to modules and functions, unless we make some globals. Local variables shadow globals with same name. All variables, local and global, erased when module or function terminate execution.

Module Sum {
      Read n \\ here we need a count indicator
      total=0
      If n=0 then Error "I want one parameter at least"
      for i=1 to n {
            read k
            total+=k
      }
      \\ modules can return values in stack
      Push total
}

Sum 4, 1,2,3,4
\\ Number read the top value, if not exist or if not a numeric type then we get an error
Print Number ,
Sum 2, 10,20
Print Number

Module CheckDecoration {
      Sum 4, 1,2,3,4
      Print Number ,
      Sum 2, 10,20
      Print Number
}

CheckDecoration ; Sum



Now lets look another example, where we have a module in a group (object for M2000). We do the decoration of zeta, using a Alfa.Beta module, and when this module called "knows" that is a member of Alfa, so can read B and change it. So it seams that decoration can be used for reference module, if module is part of a group.



Group Alfa {
      B=100
      Module Beta {
            Print .B
            .B++
      }
}

Alfa.Beta
Module zeta {
      module something {
            \\ nothing
      }
      something
}

zeta ; something as Alfa.Beta
Print Alfa.B \\ 102
zeta   \\ do nothing



So now we have to look what is a reference to function. Interpreter do something easy, just take code (source code) of function and wrap it in {}, and export a string.  A reference in M2000 is a string (a weak reference), and for a function is the source, plus the weak reference if function is a member of object (group).
Look this example. We call a function like a module. Which means that we pass parent stack to function. So when we call Beta argument "hello" take place to stack and this stack passed to Call a$. Insert a Print a$ before or after call to see the source of Function AnyName

Function AnyName {
      Print "Function AnyName", letter$
}
\\ we can call a function as a module
Call AnyName("hello")

Module Beta {
      Read a$
      Call a$
}

Beta &AnyName(), "hello"

Module Beta {
      Read &M()
      Call M()
}

Beta &AnyName(), "hello"



We can use the source of a function, through function() (or function$() for string return value). So we can write anonymous functions (not a lambda type)

Print Function("{read X,Y:=X**Y+100}", 10,2)

Function AnyName (x,y) {
      =x*100-4*y+20
}
\\ any identifier with & as first char, is a string with value the actual name of variable
a$=&AnyName()
Print Function(&AnyName(), 10,2)
Print Function(a$, 10,2)

 So anyone can say that a function can live in a string. But only as code. It is easy to use strings as functions, so before lambda functions enter the M2000 language, was the only way to simulate, but without closures.

Now here is the lambda function (we can assign one in a variable):

A=lambda (x) -> {
      =lambda x -> {
            =x
            x++
      }
}
M=A(10)
Print M(), M() ' 10  11
\\ store to N
N=M
Print M(), M() ' 12  13
\\ restore from N
M=N
Print M(), M() ' 12 13
\\ N is a lambda too
Print N(), N() ' 12  13
As we see, A is a lambda function which return a function. So M=A(10) make a function with a closure, the x. And x is mutable, so we can change it with x++. Look at lambda definition, after lambda and before -> (or before parameter list if defined, but we can include a Read command inside body of function), we put X without value (we can put some other variables, with values if we want, as "static" to object, lambda is an object)
Interpreter works fast with lambda definitions. Make an object with a list of closures, as copy of them, and a function definition (as a string). There are two interfaces, one which lambda has no parenthesis, so then we get a copy, and the other, with parenthesis and then we use the function.If we have to use the function, Interpreter first produce a function with an auto name, then make variables (here X) as part of that name, so it is local to to function, then execute function (passing any arguments), in a new stack, and after the exit, all variables collected to object. So new value for X lives in object, and not in list of "current" variables. Object N and M has each a X variable.
Look examples here Using Lambda functions to get data
and here Use of Lambda functions in M2000 Interpreter

So until now we have see Functions and Modules that can be passed to Modules, functions by reference, and modules as decorations, and Lambda functions which can take closures of any type of variables, including lambda too and are first citizens, they can copied to variables, or returned from functions.
Also we can see that variables in a module and function can be local or be group variables, if module or function is a member of group. Also there are global variables. Global variables and group variables have the same assign symbol <=. Group variables outside a member of group use assign symbol =.


Global X=100
Print X \\100
Group M {
      X=10
      Module A {
            Print X
      }
      Module B {
            Print .X, X
            X<=30
            .X<=20
            X=500 \\ this is a local X with value 500, and now shadow the global one
            Print .X, X
            .A   \\ we can call module A because B and A are members of M
      }
}

Print M.X \\ 10
M.B    \\ 10   100
             \\ 20  500
             \\ 30    module M.A found X as global
Print X \\ now global is 30


When two modules are members in a group, can look each other using This and a dot before the name, or a dot only. So .A is This.A and .X<=20 is This.X<=20.
Because X is public member (by default all members of a group are public), we can alter using M.X=100  and this is an assign from external code (not in Group).
But what happen if two modules are not member of a Group, but member of a module, or a function? Then we can't call each other, or here from K we can't call Z.

Module K {
      \\ error. Interpreter can't find Z
     Z
}
Module Z {
      Print "I am Z"
}
K  \\ error

When Event-driven programing included to M2000 then a new call "invented", the Call Local. When we call a function (as a module, but with new stack), with Call Local then this function take the namespace of calling module. So we call a local part of module as a subroutine, and we can see everything "parent" module see.


Function K {
     Z
}
Module Z {
      Print "I am Z"
}
Call Local K()
Call Local "K()"
A$="K()"
Call Local A$
As we can see, we can call K() like is the parent module (or function).

So now we can see the last calling to a local function passed by reference. Before we pass &K() to module testMe we make a second function from Lazy$(). Lazy$() used for making expressions for lazy evaluations, but can be used for making special functions. So when we call Me() then function K executed as parent module, so this is why Z can be called.

 
Function K {
     Z
}
Module Z {
      Print "I am Z"
}
Module testMe (&Me()){
     Call Me()
}
testme lazy$(&K())

Or we can make some other calls too, using Call Local:

Function K {
     Call Local Z()
}
Function Z {
      Print "I am Z"
      M
}
Module M {
      Print "I am M"
}
Module testMe (&me()){
     Call Me()
}
testme lazy$(&K())


Call Local is the way for calling a form "module's" code. When we click in Hello form event Hello.Click() fired. In M2000 we don't connect events. Any event  that has no "connection" can't fired again (if we activate again a form, then the bad list cleared, so system try to see if something defined after and then connected properly)
In the example we see that M is visible by Hello.Click (but it isn't if we use Hello.Click using a simple Call Hello.Click()).


Declare Hello Form
With Hello, "Title","Hello World", "top", 3000, "left", 2000
M=100
Function Hello.Click {
      Print "ok", M
      M++
      Refresh
}
Method Hello, "Show", 1
Declare Hello Nothing



Or we can use an external event to display all events in form (except those events with argument by reference)



Declare Hello Form Event ALFA
With Hello, "Title","Hello World", "top", 3000, "left", 2000
M=100
Function Hello.Click {
      Print "ok", M
      M++
}
Function Alfa {
      Read a$
      Print a$
      Try {
            Call Local a$
      }
      Try {Refresh}
}
Event ALFA New Lazy$(&Alfa())
Method Hello, "Show", 1
Declare Hello Nothing






Δευτέρα, 18 Σεπτεμβρίου 2017

What type of Language M2000 is?

First we have to distinguish between Dynamic vs Static typing.
Types in M2000 are most static typing. We say most static because we can alter some types to specific types.


Look this example. Start M2000.exe, write Edit A, then copy this code from browser and press Esc, then write A and look the results.


Module DynamicArguments (x ){
      Long a=x*2
      \\ check without Long
      Print a, Type$(a)
}

Module DynamicArguments1 {
      Print Envelope$( ) \\ print type of arguments as letters
      If Match("L") Then Long X
      Read X
      Print Type$(x)
      Long a=x*2
      \\ check without Long
      Print a, Type$(a)
}

a=10.4
Link a To b \\ b is reference to a \\ b can't change reference
Print Type$(a) \\ double
Print a
DynamicArguments a
DynamicArguments 2.5

\\ now we can make it something else
\\ b is a reference to a so any change of a can change b
Long a
Print Type$(a), Type$(b)
Print a
\\ all arguments passes as double, but using ! we can pass long
DynamicArguments ! a
DynamicArguments ! 2.5
\\ we get same results
DynamicArguments1 ! a
DynamicArguments1 ! 2.5

In this example, we have X in DynamicArguments module, as a weak typed argument. We can't pass a string though. Strings in M2000 are like strings in basic, need a $ at the end of variable name.

What we see here is the Long a which  make a 32bit sign integer a or if a exist then convert it to this type of integer.
In module DynamicArguments1 we test the type of argument and we can prepare X to be the same type. So we have a way to test type before assign it to a value. (we can use number from stack of values, using function StackItem() with no parameter - by default is 1 here).
For modules, the module code is responsible to drop values from stack (functions called in expressions have new stack, so if we leave something, then this lost at return). Stack for values used for returning values (any number) from modules, with any way we can think for safe passing (maybe a starting value as a count number, for values after that)


About conversion to Integer. There are two ways, but one way used for stored a number to a variable, if variable is a Long (32 bit) or an integer (by using % in the name, which is a double inside). Round function with 0 decimals works like this: 5.5 became 6, 5.1 became 5 and -5.5 became -6, -5.1 became -5 (less than -5.5). Int function change 5.5 to 5 same as 5.1 and -5.5 same as -5.1 to 6.


B%=2.5*3
Print B% \\8
Print B%*2 \\  16
Print (2.5*3)*2 \\ 15
Print Int(2.5*3)*2 \\ 14
Print Round(2.5*3, 0) \\ 8
Print Int(2.5*3) \\ 7

\\ round performed for Long too
Long A
A=2.5*3
Print A \\ 8


Automatic conversion exist from string to number, only when we assign value using simple = for double type variables (by default any name without % and $ is a double variable).
As we see in this example we can check the input value and do conversion by code.
(x) in Module definition is a macro for interpreter, and using it place a Read X as first line in the module.


\\ error - no automatic convertion to number
\\ long a="1212"
\\ not error - convertion to number
a="12345"
Print a

Module testme (x){
      Print x
}
\\ error no automatic convertion to number
\\ testme "12345"
testme 12345
\\ we can change definition even  when we run this module
Module testme {
      If Match("S") then { read N$: X=N$ } Else read X
      Print X
}
\\ now work witn internal automatic convertion;
testme "12345"
testme 12345

From M2000 console execute Help Match( to find what other letters exist in M2000 for types.
So until now we see that M2000 is mostly weak type, but we can check in execution,in code, in any pass to module or function the type of variable.
Automatic Conversions exist for specific type of variables (integer and long, using round) and for double (string to number). Passing long can be done using ! before number expression.
All numeric expressions evaluated using double type as accumulator. Operators such as +=, -=, *=, /=, -!, ~, ++, -- work in same type (long or double - integer is double inside, but the result rounded to zero decimals)

A variable A maybe is a double, or a pointer to Array or Stack or Inventory, or a Group, or a COM object, or a Gui Object (are COM objects too, but internal to M2000). We can check the name of it using Type$().

So we see that M2000 passing with a dynamic way values to modules (and functions and subs), when types can be checked or not.

There is a special object named Group that may have a value, a number or a string. If we wish a string value then we have to define group with a name with a $ as last character. For those groups there is a second name, the same name without $ at the end. And this needed for access numeric values in group:
Special function Value make Alfa to return a value. If we want to take the object we have to use Group$(), which extract a copy of group. So Alfa is not just a pointer to object, is the only pointer to object, so is "the" object. Group objects may have references to them, but not pointers to them. We can use This as pointer to group inside a group, or we can make a reference to Group or a copy to Group by using This and call some external module/function (a global one perhaps).
 
Group Alfa$ {
      anynumber=100
      Value {
            ="George"
      }
}

Print Alfa$, Alfa.anynumber
\\ Groups are objects prototypes
Beta$=Group$(Alfa$)
\\ so now we have a second object
Print Beta$, Beta.anynumber

Module TakeMe (x){
      Print x$
}
TakeMe Beta
\\ works using x$ too, because interpreter read stack and then decide what to do
Module TakeMe (x$){
      Print x$
}
TakeMe Beta

Scope for variables in M2000 are local, except we explicit declare as global. A local/global variable in a module shadow a global one. Global variables can alter value from code by using <= and not =. If there is a Global Const we have to explicit declare a variable as const inside a module. If a module exist in a module then it can't see parent's variables.
There is a way for preparing a variable for a module before a module exist:

m@c=10
Module m {
      Print c
}
m
For groups a group variable is "global" to group, but not in groups inside group. Before dot we can use This. There are no class variables, all are group variables.


Group Alfa {
      m=500
      Group Beta {
            m=100
            module something {
                  print .m
            }
      }
      module Zeta {
            Print .Beta.m \\100
            Print .m \\ 500
            .Beta.Something  \\ 100
      }
}

Alfa.Zeta

Now change module Zeta with this (using This is the same as without it):

module Zeta {
      
Print This.Beta.m \\100
      Print This.m \\ 500
      
This.Beta.Something  \\ 100
}

We see the same result. From Beta (which is part of Alfa) Alfa.m isn't visible. This is normal, so we have groups without dependencies in parent groups. This in not hold with groups that are Properties. There we can Link parent variables to local variables, and the linking performed by Link command.

Group Beta {
Private:
      
m=10
Public:
      
Operator "++" {
            
.m++
      }
      
Group Prop {
            
value {
                  
link parent m to m
                  =m
            }
      }
}

Print Beta.Prop \\10
Beta++
Print Beta.Prop \\11

The above construction can be written like this:

Group Beta {
      
Operator "++" {
            
.[Prop]++
      }
      
Property Prop { Value } =10
}

Print Beta.Prop \\10
Beta++
Print Beta.Prop \\11

We can't change Prop, if only Value exist, but we can change from a module inside Beta the .[Prop] variable, because is private, but a variable. If we wish to change Prop using Beta.Prop=100 then we have to declare it in Property:


Group Beta {
      
Operator "++" {
            
.[Prop]++
      }
      
Property Prop { Value, Set } =10
}

Print Beta.Prop \\10
Beta++
Print Beta.Prop \\11
Beta.Prop=400
Beta++
Print Beta.Prop \\ 401

A set clause in Property make property writable. Prop is a group so we can define some other properties, methods or and functions:

Group Beta {
      
Operator "++" {
            
.[Prop]++
      }
      
Property Prop { Value, Set } =10
      
Group Prop {
            
Module Half {
                  
Link parent [Prop] to prop
                  
prop/=2
            }
      }
}
Beta.Prop=400
Beta.Prop.Half
Beta++
Print Beta.Prop \\ 201

Groups can be written to Arrays (and other containers, Stacks and Inventories). Beta group give a copy to A(1). If A(1) hold a Group then the next time we give a new group, replace the old one (and because there is no second pointer to Group object then the old one destroyed)

Dim A(10)
A(1)=Beta
Beta.Prop=2
Print Beta.Prop \\ 2
Print A(1).Prop \\ 201
A(1)++
A(1).Prop.Half
Print A(1).Prop \\ 101

So we see that we make groups with "types" as we wish. Groups are "Typeless" objects. But anything inside group maybe is number, or string or a container for that.
We can use weak references for using something which can't make a reference as an array item (references are for names only, one name for an array):

K$=Weak$(A(1))
\\ K$. is a weak reference
K$.++
K$.Prop.Half
\\ we can't use K$. Prop in right expression out of Eval()
Print Eval(K$.Prop)

In A(1) we have a closed group (all members are in group closed). In Beta all members are members of module too. So if we make a X as variable in Beta, and Beta exist in module A then A.Beta.X is a variable of module A too, and we can get a reference only for this.
As we see K$. is a weak pointer. (We can see what is in K$ by using Print K$). We can pass as weak reference Beta (an open Group)


K$=Weak$(Beta)
\\ K$. is a weak reference
K$.++
K$.Prop.Half
\\ we can't use K$. Prop in right expression out of Eval()
Print Eval(K$.Prop)





Κυριακή, 17 Σεπτεμβρίου 2017

Test Html5 in M2000


This program test in Windows 7. In Wine Linux html5 not supported.
File aaa.html created in temporary folder
Write this in module A, using Edit A <enter>

text aaa.html {
      <!DOCTYPE html>
      <html>
      <body>
      
      <canvas id="myCanvas" width="300" height="150" style="border:1px solid #d3d3d3;">
      Your browser does not support the HTML5 canvas tag.</canvas>
      
      <script>
      
      var c = document.getElementById("myCanvas");
      var ctx = c.getContext("2d");
      var imgData = ctx.createImageData(100, 100);
      
      var i;
      for (i = 0; i < imgData.data.length; i += 4) {
          imgData.data[i+0] = 255;
          imgData.data[i+1] = 0;
          imgData.data[i+2] = 0;
          imgData.data[i+3] = 255;
      }
     
      ctx.putImageData(imgData, 10, 10);
     
      </script>
     
      <p><strong>Note:</strong> The canvas tag is not supported in Internet
      Explorer 8 and earlier versions.</p>
      <p>Press Esc to exit Browser</p>
      Or write in M2000 console Browser ""
      </body>
      </html>
}

browser aaa.html



Then  write this in module B (Edit B <enter>)

\\ set  directory to %temp%
Dir Temporary$
\\ show files aaa
Files "aaa*"
\\ return to user dir
Dir User
 


We can open temporary$ in explorer using command:
Win Temporary$ 

Σάββατο, 16 Σεπτεμβρίου 2017

Αναθεώρηση 32 (Έκδοση 8.9)

1. Διορθώσεις στην βοήθεια. (στη βάση δεδομένων που συνοδεύει τον διερμηνευτή/περιβάλλον της Μ2000).

2. Επανήλθε η συμβατότητα στα ονόματα μεταβλητών που μοιάζουν με ονόματα αρχείων:
Let a:\b\c=1
Print a:\b\c    \\ print 1

Πέμπτη, 14 Σεπτεμβρίου 2017

Διαφορές μεταξύ ΓΛΩΣΣΑΣ (ΑΕΠΠ) και Μ2000


Μερικά παραδείγματα σε ΓΛΩΣΣΑ είναι από εδώ: http://alkisg.mysch.gr/ΓΛΩΣΣΑ/



Τύποι Δεδομένων στη ΓΛΩΣΣΑ:
Ο τύπος ΛΟΓΙΚΟΣ δεν υποστηρίζεται άμεσα. χρησιμοποιούμε τον Ακέραιο ή τον Πραγματικό. Μη μηδενική τιμή λογαριάζεται για αληθές. Υπάρχουν τα ΑΛΗΘΗΣ και ΨΕΥΔΗΣ οπότε το παρακάτω δημιουργεί πραγματικό με τιμή ΑΛΗΘΗΣ:
Μ2000:
Α=ΑΛΗΘΗΣ
Η Μ2000 έχει αρκετούς τύπους δεδομένων που δεν υποστηρίζει η ΓΛΩΣΣΑ όπως η Κατάσταση (λίστα τιμών με κλειδί), ο Σωρός Τιμών (συνδεδεμένη λίστα) , η συνάρτηση λάμδα κ.α.



Οι ακέραιες μεταβλητές στη Μ2000 έχουν το % στο τέλος και είναι εσωτερικά πραγματικές (double). Το Α%=12.5 θα γίνει 13
Υπάρχει δε και ο τύπος Μακρύς που δημιουργεί 32bit ακέραιο, και ο οποίος δεν έχει το % (ανήκει στις ειδικές μεταβλητές της Μ2000)



Στη Μ2000 το (1,2,3,4) δίνει αυτόματο πίνακα μονοδιάστατο τεσσάρων στοιχείων, ενώ το ((1,2),(3,4)) δίνει έναν αυτόματο πίνακα δυο στοιχείων όπου κάθε στοιχείο είναι πίνακας δύο στοιχείων. Οι πίνακες μπορούν να πάρουν και αλφαριθμητικά, και αντικείμενα . Αντικείμενα είναι οι πίνακες, καταστάσεις ειδών, σωρούς τιμών, λάμδα συναρτήσεις, ομάδες (αντικείμενα με μέλη οποιοδήποτε τύπο μεταβλητής, τμήματα, συναρτήσεις, τελεστές καθώς και ομάδες και ιδιότητες που είναι επίσης αντικείμενα ομάδες), γεγονότα δηλαδή συλλογές συναρτήσεων που καλούνται με μια κλήση και διαδοχικό πέρασμα τιμών (multicast)



Βάση Πινάκων:
Στη ΓΛΩΣΣΑ οι πίνακες έχουν βάση το 1, δηλαδή ένας πίνακας 50 στοιχείων έχει το πρώτο στοιχείο στη θέση 1. Στη Μ2000 αυτό μπορεί να ρυθμιστεί ως 1 ή ως 0. Εξ ορισμού είναι 0, και μπορούμε με την εντολή Βάση 1 να ορίσουμε ότι κάθε πίνακας μετά την εκτέλεση της εντολής θα είναι με βάση το 1. Μπορούμε να ορίσουμε πίνακες με τη βάση που θέλουμε, ή να αλλάξουμε τη βάση του πίνακα, χωρίς να πειράξουμε τα δεδομένα. Υπάρχει τρόπος να γνωρίζουμε τη τρέχουσα βάση κάθε πίνακα.



Αλφαριθμητικά:
Στη ΓΛΩΣΣΑ ορίζονται με απλά ή με διπλά εισαγωγικά. Στη Μ2000 με διπλά ή με αγκύλες. (με αγκύλες βάζουμε και αλλαγές γραμμών).
Οι μεταβλητές για αλφαριθμητικά έχουν απαραίτητα το $ στο τέλος.



Μέρη Προγράμματος:
Στη ΓΛΩΣΣΑ αναφέρονται τα μέρη του προγράμματος, ως τμήματα: Η επικεφαλίδα, το τμήμα δήλωσης σταθερών, το τμήμα δήλωσης μεταβλητών, το κυρίως σώμα. τα υποπρογράμματα. Τα τμήματα δηλώσεων δεν είναι υποχρεωτικά.



Στη Μ2000 η λέξη τμήμα δηλώνει μια μονάδα προγράμματος, η οποία μπορεί να έχει και άλλες εσωτερικά. Οι μεταβλητές ορίζονται με απόδοση τιμής, και σε κάποιες περιπτώσεις με δήλωση. Δεν μπορεί να χρησιμοποιηθεί σε παράσταση όνομα που δεν έχει δηλωθεί ή δεν έχει ορισθεί κατάλληλα. Πρέπει να ορίσουμε ένα τμήμα πριν το καλέσουμε.



Τα τμήματα της Μ2000 μπορούν να έχουν ρουτίνες (υπορουτίνες όπως στη ΓΛΩΣΣΑ στο τέλος του κώδικά τους). Οι συναρτήσεις στη ΓΛΩΣΣΑ γράφονται στις δηλώσεις υποπρογράμματων, ενώ στη Μ2000 είναι σαν τα τμήματα, γράφονται οπουδήποτε, και μπορούν να έχουν τμήματα., συναρτήσεις, και ρουτίνες.



Υποπρογράμματα:
Στη ΓΛΩΣΣΑ όλα τα υποπρογράμματα είναι γενικά! Δηλαδή από κάθε υποπρόγραμμα μπορούμε να καλέσουμε ένα οποιοδήποτε άλλο. Στη Μ2000 ένα τμήμα μπορεί να καλέσει ένα γενικό τμήμα ή ένα τμήμα που ορίστηκε σε αυτό, αλλά όχι τον εαυτό του. Οι ρουτίνες (υποπρογράμματα σε τμήματα) μπορούν να καλέσουν οποιαδήποτε ρουτίνα υπάρχει στο τμήμα, και τον εαυτό τους. Οι ρουτίνες στη Μ2000 γράφονται στο τέλος.



Πέρασμα Τιμών:
Στη ΓΛΩΣΣΑ ορίζουμε τύπο παραμέτρων για τα υποπρογράμματα (Στις συναρτήσεις ορίζουμε και το τύπο της επιστρεφόμενης τιμής). Στη Μ2000 οι παράμετροι μπαίνουν ως έχουν σε ένα σωρό τιμών (μια ειδική στοίβα) και την ευθύνη για το τράβηγμα των τιμών έχει το τμήμα που καλούμε. Υπάρχει τρόπος προγραμματιστικά να ελέγχουμε τον "φάκελο" τιμών στο σωρό και να πράττουμε ανάλογα.



Στη ΓΛΩΣΣΑ μια μεταβλητή αν περαστεί με το όνομά της, περνάει με αναφορά. Στη Μ2000 πρέπει να δηλώσουμε την αναφορά με & πριν το όνομα, τόσο στη κλήση όσο και στο τμήμα που καλούμε. Έτσι στη Μ2000 όταν ζητάμε αναφορά θα πρέπει να πάρουμε αναφορά και όχι έκφραση. Υπάρχει μια κατηγορία μεταβλητών στην Μ2000 που λειτουργούν με δείκτη. Αυτές οι μεταβλητές ακόμα και αν τις περάσουμε με τιμή, θα περάσουν με δείκτη, οπότε είναι σαν να τις περάσαμε με αναφορά.



Εκχώρηση τιμής:
Στη ΓΛΩΣΣΑ η εκχώρηση γίνεται με το <-, με δυο χαρακτήρες ή ένας ←(unicode). Στη Μ2000 υπάρχουν τρία σύμβολα εκχώρησης: =. <= και :=. Το = δημιουργεί τοπική μεταβλητή αν δεν υπάρχει (εκτός και αν στην γραμμή εμφανίζεται μια λέξη από τα Γενικό ή Γενική ή Γενικές). Το <= αλλάζει τιμές σε γενικές, και σε μέλη αντικειμένων (εντός τμημάτων τους). Το := χρησιμοποιείται για εκχώρηση πολλαπλών τιμών σε πίνακες (και το = μπορεί να χρησιμοποιηθεί για πολλαπλές τιμές σε πίνακες), καθώς και για τιμές σε εντολές για πολλαπλές εκχωρήσεις σε αντικείμενα.



Στη Μ2000 το Α%=-5.5 θα κάνει το Α% να έχει τιμή -6, δηλαδή θα γίνει αυτόματη μετατροπή σε ακέραιο. Στη ΓΛΩΣΣΑ αυτό δεν επιτρέπεται, ενώ επιτρέπεται να δώσουμε ακέραια τιμή σε πραγματικό (όπως και στη Μ2000).



Τυπική εμφάνιση κώδικα στη ΓΛΩΣΣΑ:
Μια εντολή ανά γραμμή. Στη Μ2000 εκτός από μια περίπτωση που μόνο μια εντολή μπορούμε να βάλουμε σε μια γραμμή (στην δομή Επίλεξε, αν δεν βάλουμε μπλοκ εντολών με αγκύλες), σε κάθε άλλη περίπτωση μπορούμε με διαχωριστική άνω και κάτω τελεία να βάζουμε εντολές (όπως στη BASIC)
Η Γλώσσα πάντα εμφανίζεται μια γραμμή εντολών σε μια γραμμή στον διορθωτή της. Στη Μ2000 μπορούμε να ορίσουμε αναδίπλωση λέξης και να έχουμε μια γραμμή εντολών που να εμφανίζεται σε πολλές γραμμές (με F1 αλλάζουμε από αναδίπλωση σε χωρίς αναδίπλωση). Μπορούμε να έχουμε αλφαριθμητικές σταθερές πολλαπλών παραγράφων, και με την αναδίπλωση μας βοηθάει να τις βλέπουμε και να τις διορθώνουμε).
Στη Μ2000 μπορούμε να βάζουμε αριθμούς γραμμων πριν από εντολές (μεχρι 5 ψηφία και μπορούν να υπάρχουν μηδενικά στην αρχή πχ το 0010 είναι το 10. Οι αριθμοί έχουν την λειτουργία των ετικετών, και μπορούν να μπουν όπως θέλουμε.


προς 10


εξοδος
0010 τύπωσε "10"




Έτοιμες Συναρτήσεις:
Η ΓΛΩΣΣΑ έχει την E() ως eX
Στη Μ2000 πρέπει να την ορίσουμε:


Κάνε εκθ(χ)= 2.71828182845905^χ
Τύπωσε Λφ(εκθ(1.24412))
Τύπωσε Λφ(2.71828182845905)



Στη ΓΛΩΣΣΑ έχουμε το ΛΟΓ() για φυσικό λογάριθμο, ενώ στη Μ2000 αυτή η συνάρτηση είναι ο δεκαδικός λογάριθμος, και ο ΛΦ() ο φυσικός λογάριθμος. Στα ημίτονα/συνημίτονα έχουμε μοίρες και στις δυο γλώσσες. Το ακέραιο μέρος Α_Μ() στη Μ2000 είναι ΑΚ(), η απόλυτη τιμή Α_Τ() είναι ΑΠΟΛ(). Η εφαπτομένη ΕΦ() είναι στη Μ2000 ως ΕΦΑΠ(), ενώ υπάρχει και το ΤΟΞ.ΕΦ() για το τόξο εφαπτομένης. Η τετραγωνική ρίζα Τ_Ρ υπάρχει ως ΡΙΖΑ(). Τέλος η Μ2000 έχει έναν μεγάλο αριθμό συναρτήσεων που σχετίζονται με δεδομένα, με ώρα, με χρόνο, με συγκρίσεις, καθώς επίσης και συναρτήσεις για αλφαριθμητικά που λείπουν από την ΓΛΩΣΣΑ.



Η εντολή ΓΡΑΨΕ στη ΓΛΩΣΣΑ:
Η αντίστοιχη στη Μ2000 είναι η ΤΥΠΩΣΕ (ενώ υπάρχει η ΓΡΑΨΕ για αρχεία). Υπάρχουν πολλές διαφορές γιατί στην ΤΥΠΩΣΕ η Μ2000 λογαριάζει στήλες και τρόπο στοίχισης σε αυτές, και μπορούν να μεταβληθούν. Ο δρομέας χαρακτήρων μπορεί να τοποθετηθεί όπου θέλουμε με συντεταγμένες γραμμή και στήλη. Οι πίνακες και άλλες δομές εμφανίζουν άμεσα τις τιμές τους με την Τύπωσε:

Πίνακας Α(4)
Α(0):=1,2,3,4
Τύπωσε Α()



Η εντολή ΔΙΑΒΑΣΕ στη ΓΛΩΣΣΑ:
Η ΔΙΑΒΑΣΕ εισάγει τιμές σε μεταβλητές που πληκτρολογούμε. Στη Μ2000 αυτό το κάνει η εντολή ΕΙΣΑΓΩΓΗ ενώ η ΔΙΑΒΑΣΕ διαβάζει από το σωρό τιμών. Επίσης η εντολή ΕΙΣΑΓΩΓΗ με αριθμό αρχείου (μεταβλητή με # στην αρχή) διαβάζει τιμές από αρχείο που έχει γραφτεί με την ΓΡΑΨΕ, ενώ η ΕΙΣΑΓΩΓΗ ΓΡΑΜΜΗΣ διαβάζει από αρχείο ολόκληρη γραμμή που έχει τυπωθεί με την ΤΥΠΩΣΕ και με αριθμό αρχείου. Η ΓΛΩΣΣΑ δεν υποστηρίζει αρχεία, αλλά μπορούν έμμεσα να χρησιμοποιηθεί τουλάχιστον ένα αρχείο εισαγωγής τιμών σε περιβάλλον διερμηνευτή.



Ανάπτυξη Δομών Ροής/Προγράμματος:
Στη ΓΛΩΣΣΑ υπάρχουν δυο λέξεις (αναγνωριστικά) τουλάχιστον που ενσωματώνουν κώδικα, μια λέξη αρχής και μια λέξη τέλους. Στην Μ2000 κώδικας ενσωματώνεται σε αγκύλες { } εκτός:
Η ΓΙΑ ή οποία έχει δυο τρόπους, έναν με αγκύλες και έναν χωρίς, και η Αν Τότε ή Αν Αλλιώς όταν δεν χρησιμοποιούμε άλλο μέρος (πχ Αλλιώς.Αν ή Τότε πριν την Αλλιώς). Ειδικά στην Αν μετά την Τότε (αν δεν υπάρχει η Αλλιώς μετά) μπορούμε σε μια γραμμή να βάλουμε εντολές με διαχωριστική άνω και κάτω τελεία μέχρι το τέλος της παραγράφου.



Η εντολή ΑΝ στη ΓΛΩΣΣΑ:
Στις συγκρίσεις η Μ2000 χρησιμοποιεί και το == για αριθμητικές εκφράσεις, με περιορισμό στην ακρίβεια κατά τη σύγκριση.
Η ΑΝ έχει ακόμα τέσσερα αναγνωριστικά, την ΤΟΤΕ, την ΑΛΛΙΩΣ_ΑΝ, την ΑΛΛΙΩΣ και την ΤΕΛΟΣ_ΑΝ
Ομοίως στη Μ2000 η ΑΝ έχει την ΤΟΤΕ, την ΑΛΛΙΩΣ.ΑΝ την ΑΛΛΙΩΣ αλλά δεν έχει κάποια "τέλος αν" γιατί τελειώνει στο τέλος της παραγράφου (ή γραμμής) ή αν ξεκινάει μπλοκ σε αγκύλες στο τέλος του μπλοκ.
Πχ στη Μ2000
Αν Χ>5 Τότε {
εντολες.....
}
Αν Χ=10 Τότε Εντολη1 : Εντολη2:............ ΕντολήΝ
Δείτε εδώ με την Αλλιώς στη θέση της Τότε δηλαδή εκτελείται όταν το Ζ δεν θα είναι ίσο με 100
Αν Ζ=100 Αλλιώς Εντολή1: Εντολη2:......ΕντολήΝ



Και εδώ με όλα τα καλά:
Αν Χ>10 Τότε { εντολές...
} Αλλιώς.Αν Χ<-20 Τότε { εντολές...
} Αλλιώς.Αν Χ<-10 Τότε { εντολές...
} Αλλιώς { εντολές...
}



Η εντολή ΕΠΙΛΕΞΕ στη ΓΛΩΣΣΑ:Εδώ έχουμε τα αναγνωριστικά ΠΕΡΙΠΤΩΣΗ, ΠΕΡΙΠΤΩΣΗ_ΑΛΛΙΩΣ. ΤΕΛΟΣ ΕΠΙΛΟΓΩΝ
η διάρθρωση είναι ως εξής:
ΕΠΙΛΕΞΕ έκφραση
ΠΕΡΙΠΤΩΣΗ τύπος_εκφρασης [, τ τύπος_εκφρασης]
εντολή
ΠΕΡΙΠΤΩΣΗ_ΑΛΛΙΩΣ.
εντολή
ΤΕΛΟΣ_ΕΠΙΛΟΓΩΝ



Στη Μ2000 είναι περίπου ίδιο:
ΕΠΙΛΕΞΕ ΜΕ έκφραση
Με τύπος_εκφρασης [, τ τύπος_εκφρασης]
μια εντολή ή ενα μπλοκ εντολών με αγκύλες
ΑΛΛΙΩΣ
μια εντολή ή ενα μπλοκ εντολών με αγκύλες
ΤΕΛΟΣ ΕΠΙΛΟΓΗΣ



στο τύπο_εκφρασης και στις δυο γλώσσες υπάρχουν τρία είδη:
1. έκφραση
2. μισή έκφραση σύγκρισης πχ. >100 (στη Μ2000 μπορούμε να βάλουμε μια ΚΑΙ ή μια Η και μια άλλη έκφραση στη συνέχεια, πράγμα που δεν γίνεται στην ΓΛΩΣΣΑ)
3. διάστημα τιμών όπου στη ΓΛΩΣΣΑ δηλώνεται με δυο τελείες ενώ στην Μ2000 με την ΕΩΣ



Η Με εκτός δομής Επίλεξε έχει άλλη λειτουργία στη Μ2000 (σχετίζεται με ιδιότητες αντικειμένων)



Η εντολή ΓΙΑ στη ΓΛΩΣΣΑ:
Εδώ υπάρχουν διαφοροποιήσεις, και σε αναγνωριστικά και σε λειτουργία.
ΓΙΑ π ΑΠΟ 10 ΜΕΧΡΙ 1 ΜΕ_ΒΗΜΑ -0.5
ΓΡΑΨΕ π
ΤΕΛΟΣ_ΕΠΑΝΑΛΗΨΗΣ



Το ΜΕ_ΒΗΜΑ μπορεί να γραφεί χωρίς την κάτω παύλα, και είναι προαιρετικό (οπότε νοείται ως ένα).



Στη Μ2000 το αναγνωριστκό ΑΠΟ είναι η πύλη XOR ( όπως το ΚΑΙ είναι τη πύλη AND) και χρησιμοποιείται σε λογικές εκφράσεις. (ΚΑΙ, Η, ΑΠΟ), όταν βρίσκεται σε αριθμητικές εκφράσεις. Επίσης υπάρχει και εντολή ΑΠΟ: Από Έκφραση Προς Ετικέτα1, .... και Από Έκφραση Διαμέσου Ετικέτα1, Ετικέτα2, .....




Το πρόσημο του βήματος καθορίζεται από τα όρια, και αν αυτά είναι ισοδύναμα τότε λαμβάνεται το πρόσημο του βήματος για να υπολογιστή η επόμενη τιμή, μετά την εκτέλεση των εντολών. Στη Μ2000 θα εκτελεστεί μια φορά τουλάχιστον ο κώδικας, ακόμα και αν το βήμα είναι μηδενικό. Με μηδενικό βήμα η μεταβλητή θα έχει την τιμή αρχής

ΓΙΑ π=10 ΕΩΣ 1 ΑΝΑ 0.5
      ΤΥΠΩΣΕ π
ΕΠΟΜΕΝΟ π
ή το πιο γρήγορο:
ΓΙΑ π=10 ΕΩΣ 1 ΑΝΑ 0.5 {
      ΤΥΠΩΣΕ π
}



Αν το βήμα δεν δοθεί τότε θεωρείται ως 1 (πάντα το θετικό). Στη ΓΛΩΣΣΑ μπορεί θα πάρει αρχική τιμή ο μετρητής όπως και να έχει, ακόμα και να δεν εκτελεστούν οι εντολές εντός της ΓΙΑ. Στη Μ2000 και ο μετρητής θα πάρει την αρχική τιμή και δεν υπάρχει περίπτωση να μην εκτελεστεί μια φορά η ΓΙΑ, γιατί ο έλεγχος γίνεται στο τέλος κάθε εκτέλεσης και όχι στην αρχή.
Επιπλέον μια διαφοροποίηση σε σχέση με την ΓΛΩΣΣΑ είναι η έξοδος από μπλοκ με αγκύλες με την ΕΞΟΔΟΣ και η έξοδος από το ΓΙΑ ...ΕΠΟΜΕΝΟ με την ΕΞΟΔΟΣ ΓΙΑ, όπως επίσης και η έξοδος με ΠΡΟΣ (GOTO) από μπλοκ με αγκύλες (τερματίζει και την μέτρηση χωρίς αλλαγή του μετρητή, από την τελευταία)



Υπάρχει στη Μ2000 μια άλλη δομή Για όπου παίρνει ονόματα αντικειμένων και ακολουθεί μπλοκ εντολών που σχετίζονται με αυτά τα ονόματα.

Ομάδα Αλφα {
      Χ=10, Ψ=30
}
Για Αλφα {
      Τύπωσε .Χ,
}



Στη Μ2000 αν χρησιμοποιήσουμε ακέραιο για μετρητή θα έχουμε πρώτα μετατροπή σε ακέραιο τα όρια και το βήμα:

για ι%=0.2 εως 10.3 ανά .6 {
      Τύπωσε ι%
}

θα τυπώσει από το 0 έως το 10
Επίσης στη Μ2000 αν πειράξουμε το μετρητή στο μπλοκ δεν υπάρχουν επιπτώσεις, γιατί αυτό που διαβάζουμε είναι το αντίγραφο του κανονικού μετρητή και ενημερώνεται στο τέλος του μπλοκΟ μ
Το παρακάτω θα τρέξει στη Μ2000

Για χ=1 έως 3 {
      ν=χ
      Για χ=5 εως 2 {
            Τύπωσε χ, ν
      }    
}

όπως και αυτό:

Για χ=1 έως 3
      ν=χ
      Για χ=5 εως 2
            Τύπωσε χ, ν
      Επόμενο χ
Επόμενο χ

Ο μόνος τρόπος να αλλάξει ο μετρητής ενώ τερματίσουμε το μπλοκ σε νούμερο που θέλουμε και δεν βγαίνει με την μέτρηση, είναι με την χρήση της ΠΡΟΣ, όπου εδώ λέμε ότι αν το ι=5 τότε κάνουμε το ι=100 (που γίνεται) και κάνουμε άμεση έξοδο με την προς ααα ή με απλή εντολή Έξοδος. (με την Προς κατευθύνουμε τη ροή εκεί που θέλουμε)



Για ι=1 εως 10 {
      αν ι=5 τότε ι=100 : προς ααα
}



ααα:
Τύπωσε ι



ή

Για ι=1 εως 10 {
      αν ι=5 τότε ι=100 : έξοδος
}
Τύπωσε ι



Η ΓΛΩΣΣΑ δεν έχει την ΠΡΟΣ (GOTO). Η Μ2000 υποστηρίζει και ρουτίνες με κλήση ετικετών με την ΔΙΑΜΕΣΟΥ ή GOSUB (εντολές της BASIC). Οι ετικέτες στην Μ2000 είναι ονόματα με το διαχωρισιτκό άνω και κάτω τελεία. Στη κλήση δεν βάζουμε το διαχωριστικό στο όνομα. Όπως στο παράδειγμα το Προς γίνεται προς ααα και παρακάτω υπάρχει το ααα: Μετά από μια ετικέτα στην ίδια γραμμή μπορούμε να βάλουμε μόνο σημειώσεις με ' ή με \
Εντολή Όσο στη ΓΛΩΣΣΑ
Χρησιμοποιεί τα ΕΠΑΝΑΛΑΒΕ και ΤΕΛΟΣ ΕΠΑΝΑΛΗΨΗΣ. Στο παράδειγμα βλέπουμε το DIV, το οποίο έχει παραμείνει με την αγγλική ονομασία. Στην Μ2000 είναι το ΔΙΑ και εφαρμόζεται οπουδήποτε, δηλαδή και σε πραγματικούς. Το Mod είναι το Υπόλοιπο ή Υπολ (στη Μ2000 μπορούμε να βάζουμε τόνους στις εντολές, και κατά την εκτέλεση ο διερμηνευτής τους αφαιρεί, δουλεύοντας με κεφαλαία)



ΟΣΟ α >= 2 ΕΠΑΝΑΛΑΒΕ
α <- α DIV 2
ι <- ι + 1
ΤΕΛΟΣ_ΕΠΑΝΑΛΗΨΗΣ




Η αντίστοιχη στη Μ2000 είναι η Ενώ

Ενώ α>=2 {
εντολές
}

Η ενώ δουλεύει και με ένα αντικείμενο που λέγεται επαναλήπτης. Η μεταβλητή Α είναι δείκτης σε Πίνακα. Η ΚΑΘΕ() παράγει ένα αντικείμενο επαναλήπτη που συνδέεται με ένα αντικείμενο και κρατάει δικό του δρομέα. Υπάρχουν δυο τρόποι να δώσουμε αρχή και τέλος, με λέξεις ή με αριθμούς όπου το -1 είναι το τέλος, και το 1 η αρχή. Τα Γ^ και Β^ είναι οι μετρητές. Μπορούμε να αλλάξουμε τα Γ και Β μέσα στις ΕΝΩ {} με νέα ΚΑΘΕ(). Εκτός από δείκτη σε πίνακα η ΚΑΘΕ() δουλεύει με Κατάσταση (λίστα με κλειδί και τιμή) και Σωρό (συνδεδεμένη λίστα τιμών)

Α=(10, 15, 20)
Β=ΚΑΘΕ(Α ΤΕΛΟΣ ΕΩΣ ΑΡΧΗ)
Γ=ΚΑΘΕ(Α, 1, 3)
ΕΝΩ Γ {
      ΕΝΩ Β {
          ΤΥΠΩΣΕ ΠΙΝΑΚΑΣ(Γ), ΠΙΝΑΚΑΣ(Β)
      }
}



Πώς γίνεται και η αριθμητική έκφραση στη Ενώ μπορεί να γυρίσει αντικείμενο; Στη Μ2000 όλες οι παραστάσεις μπορούν να γυρίζουν αντικείμενο. Όταν δεν επιστρέφουν αντικείμενο τότε αυτό είναι "ΤΙΠΟΤΑ" και ο διερμηνευτής δίνει τον αριθμό ή το αλφαριθμητικό και όχι το "ΤΙΠΟΤΑ".
Στη Μ2000 δεν μπορούμε να πειράξουμε δείκτες σε αντικείμενα, αλλά μπορούμε να αλλάξουμε ένα δείκτη με έναν άλλο δείκτη. Εκτός από ειδικά αντικείμενα, όσα είδαμε εδώ όπως ο δείκτης σε πίνακας, σε Κατάσταση και σε Σωρό, δεν μπορούν να πάρουν "τίποτα" αλλά μπορούν να πάρουν νέο πίνακα, κατάσταση, σωρό και ο παλιός να "εξαφανιστεί" αν δεν υπάρχει άλλος δείκτης να τον "κρατάει" εν ζωή.
Τα βασικά αντικείμενα, οι Ομάδες, δεν έχουν πολλαπλούς δείκτες, δηλαδή δεν γίνεται να κρατηθεί μια ομάδα αν χαθεί ο δείκτης σε αυτήν, διότι ποτέ δεν υπάρχει δεύτερος. Έτσι στις ομάδες δεν γίνεται να έχουμε κυκλικές αναφορές! Όλα αυτά περί ομάδων και αντικειμένων δεν έχουν καμία αντιστοιχία με τη ΓΛΩΣΣΑ του σχολείου. Δεν υποστηρίζει αντικείμενα!




Η εντολή ΑΡΧΗ_ΕΠΑΝΑΛΗΨΗΣ στη ΓΛΩΣΣΑ
Για να έχουμε επανάληψη ενός αριθμού εντολών με έλεγχο συνθήκες στο τέλος, χρειάζεται να γραφτεί το ΑΡΧΗ_ΕΠΑΝΑΛΗΨΗΣ ώστε να μαρκάρει την αρχή, και στο τέλος των εντολών που ενδέχεται να εκτελεστούν ξανά θα έχουμε την ΜΕΧΡΙΣ_ΟΤΟΥ με την συνθήκη προς έλεγχο. 


ΑΡΧΗ_ΕΠΑΝΑΛΗΨΗΣ
ΓΡΑΨΕ 'Δώσε βαθμό:  '
ΔΙΑΒΑΣΕ βαθμός
ΜΕΧΡΙΣ_ΟΤΟΥ βαθμός >= 0 



Η Μ2000 έχει την εντολή ΕΠΑΝΑΛΑΒΕ (ή ΕΠΑΝΕΛΑΒΕ) με ένα μπλοκ και μια από τις δυο συνέχειες: Μέχρι συνθήκη ή Πάντα:

ΕΠΑΝΑΛΑΒΕ {
εντολές....
} ΜΕΧΡΙ συνθήκη

ή χωρίς συνθήκη
ΕΠΑΝΑΛΑΒΕ {
εντολές....
} ΠΑΝΤΑ



Η δεύτερη γράφεται και έτσι:

{
εντολές...
Κυκλικά
}

Η εντολή Κυκλικά σηκώνει μια "σημαία" μέσα στο μπλοκ και όταν το μπλοκ φθάσει στο τέλος του τότε κοιτάει την σημαία και ανάλογα συνεχίζει εκτός μπλοκ ή εκτελεί το μπλοκ πάλι.
Ο διερμηνευτής ξεχωρίζει πάντα ποιο μπλοκ με αγκύλες είναι σταθερά αλφαριθμητική και ποιο είναι εντολές. (και ο χρωματιστής του διορθωτή). Αυτό συμβαίνει γιατί είναι γνωστό που ακριβώς μπαίνουν τα μπλοκ εντολών, σε ποιες εντολές δηλαδή. Μπορούμε όμως να ξεκινήσουμε ένα μπλοκ οπουδήποτε θα ξεκινούσαμε με μια εντολή. Οι εντολές για τα μπλοκ (οποιοδήποτε ακόμα και αυτό του ΓΙΑ), είναι η ΚΥΚΛΙΚΑ,. η ΞΕΚΙΝΑ (κάνει άμεση εκκίνηση ξανά του μπλοκ, η ΣΥΝΕΧΙΣΕ η οποία αν έχει σηκωθεί σημαία κάνει ότι η ΞΕΚΙΝΑ ενώ αν όχι κάνει ότι η ΕΞΟΔΟΣ, και η ΕΞΟΔΟΣ η οποία κάνει άμεση έξοδο από το μπλοκ. Υπάρχει και η ΔΙΕΚΟΨΕ που σπάει πολλά μπλοκ μαζί. Οι εντολές ΣΥΝΕΧΙΣΕ και ΔΙΕΚΟΨΕ έχουν άλλη σημασία στην ΕΠΙΛΕΞΕ ΜΕ όπου μπορούμε με την ΔΙΕΚΟΨΕ να κάνουμε εκτέλεση όλων των εντολών ΜΕ που ακολουθούν, μέχρι το τέλος ή να βρεθεί η ΣΥΝΕΧΙΣΕ και να το σταματήσει!





Χ=10
Κ=50 \\ με Κ=20 το οκ2 δεν θα εμφανιστεί
ΕΠΙΛΕΞΕ ΜΕ Χ
ΜΕ 10
{
      ΤΥΠΩΣΕ "ΘΑ ΕΜΦΑΝΙΣΩ ΤΑ οκ1 ΚΑΙ οκ2"
      ΔΙΕΚΟΨΕ
}
ΜΕ 100
{
      ΤΥΠΩΣΕ "οκ1"
      ΑΝ Κ=20 ΤΟΤΕ ΣΥΝΕΧΙΣΕ
}
ΜΕ 200
      ΤΥΠΩΣΕ "οκ2"
ΑΛΛΙΩΣ
      ΤΥΠΩΣΕ "οκ3"
ΤΕΛΟΣ ΕΠΙΛΟΓΗΣ




Η εντολή ΚΑΛΕΣΕ στη ΓΛΩΣΣΑ
Στη ΓΛΩΣΣΑ για να καλέσουμε ένα υποπρόγραμμα πρέπει να χρησιμοποιήσουμε την ΚΑΛΕΣΕ


ΠΡΟΓΡΑΜΜΑ ΗΕντολήΚάλεσε
!Επιδεικνύει απλά τη χρήση της εντολής.
ΑΡΧΗ
ΚΑΛΕΣΕ ΓράψεΌνομα('My name is Bond. James Bond.')
ΤΕΛΟΣ_ΠΡΟΓΡΑΜΜΑΤΟΣ


ΔΙΑΔΙΚΑΣΙΑ ΓράψεΌνομα(όνομα)
ΜΕΤΑΒΛΗΤΕΣ
ΧΑΡΑΚΤΗΡΕΣ: όνομα
ΑΡΧΗ
ΓΡΑΨΕ όνομα
ΤΕΛΟΣ_ΔΙΑΔΙΚΑΣΙΑΣ 
 
Σε Μ2000, υπάρχει η ΚΑΛΕΣΕ και καλεί με έναν δεύτερο τρόπο την ΑΛΦΑ. Ο κανονικός είναι χωρίς την ΚΑΛΕΣΕ. Για να καταλάβουμε τη διαφορά αρκεί να βάλουμε στην ΡΟΥΤΙΝΑ, μετά την ΤΥΠΩΣΕ Α$ την εντολή ΛΙΣΤΑ η οποία δείχνει τα ονόματα των μεταβλητών.
Δείτε επίσης ότι η Ρουτίνα μπορεί να κληθεί με την ΔΙΑΜΕΣΟΥ, και πως η Α$ στην ρουτίνα είναι τοπική μεταβλητή. Μπορούμε να έχουμε όσα τμήματα θέλουμε και σε κάθε τμήμα να έχουμε τμήματα και ρουτίνες, και συναρτήσεις. Οι ρουτίνες είναι μέρη τμημάτων και συναρτήσεων και βλέπουν τις μεταβλητές τους. Έτσι αυτό που γίνεται και στη ΓΛΩΣΣΑ μπορεί να γίνει σε τμήμα της Μ2000. Στο τμήμα ΑΛΦΑ έχουμε το (Α$) το οποίο θα γίνει ΔΙΑΒΑΣΕ Α$ όταν θα γραφτεί στη λίστα τμημάτων από τον διερμηνευτή.

ΤΜΗΜΑ ΑΛΦΑ (Α$) {
      ΔΙΑΜΕΣΟΥ ΓράψεΌνομα(Α$)
      ΓράψεΌνομα("My name is Bond. James Bond.")
      ΤΥΠΩΣΕ Α$+"-"+Α$
      ΡΟΥΤΙΝΑ ΓράψεΌνομα(Α$)
            ΤΥΠΩΣΕ Α$
      ΤΕΛΟΣ ΡΟΥΤΙΝΑΣ
}



ΑΛΦΑ "ΟΚ1"
ΚΑΛΕΣΕ ΑΛΦΑ, "ΟΚ2"




Δείτε σε συνάρτηση πως ορίζουμε προαιρετικό όρισμα:
Το ** όπως και το ^ δίνει την ύψωση σε δύναμη
Συνάρτηση Αλφα {
      Διάβασε Χ
      Υ=2
      Διάβασε ? Υ
      =Χ**Υ
}
Τύπωσε Αλφα(4), Αλφα(4, 3) \\ 16  64




Το ίδιο πρόγραμμα με ρουτίνα στη συνάρτηση:
Συνάρτηση Αλφα {
      Διάβασε Χ
      Υ=2
      Διάβασε ? Υ
      ΚάνεΚάτι()
      Ρουτίνα ΚάνεΚάτι()
            =Χ**Υ
      Τέλος Ρουτίνας
}
Τύπωσε Αλφα(4), Αλφα(4, 3) \\ 16  64