96 lines
2.8 KiB
Plaintext
96 lines
2.8 KiB
Plaintext
\\ M2000 use inference to state the type of a new variable, at run time
|
|
\\ We can use literals of a numeric type
|
|
\\ @ for Decimal
|
|
\\ # for Currency
|
|
\\ ~ for Single
|
|
\\ & for Long (32bit)
|
|
\\ % for Integer (16bit)
|
|
\\ Double and Boolean have no symboles
|
|
Module TopA {
|
|
Module Alfa {
|
|
Print A=10000, Type$(A)="Double"
|
|
\\ A is local, we use =
|
|
A=10@
|
|
Print A=10, Type$(A)
|
|
\\ Or we can state the type before
|
|
Def Currency K, Z=500, M
|
|
K=1000
|
|
\\ Currency Currency Currency
|
|
Print Type$(K), Type$(Z), Type$(M)
|
|
Def Double K1, K2 as Integer=10, K3=1
|
|
\\ double integer double
|
|
Print Type$(K1), Type$(K2), Type$(K3)
|
|
Mb=1=1
|
|
\\ We get a boolean
|
|
Print Type$(Mb)
|
|
Def boolean Mb1=True
|
|
Print Type$(Mb1)
|
|
\\ True and False are Double -1 and 0 not Boolean
|
|
Mb3=True
|
|
Print Type$(Mb3)="Double"
|
|
\\ For strings we have to use $ (like in old Basic)
|
|
A$="This is a String"
|
|
Global G1 as boolean = True
|
|
\\ To change a global variable we have to use <=
|
|
G1<=1=0
|
|
\\ If we do this: G1=1=0 we make a local variable, and shadow global
|
|
\\ In a For Object {} we can make temporary variables
|
|
For This {
|
|
Local G1=122.1212
|
|
Print G1, Type$(G1)="Double"
|
|
}
|
|
Print G1, Type$(G1)="Boolean"
|
|
}
|
|
\\ shadow A for this module only
|
|
A=100
|
|
\\ Now we call Alfa
|
|
Alfa
|
|
Print (A=100)=True
|
|
}
|
|
Global A=10000
|
|
TopA
|
|
Print A=10000
|
|
Module CheckStatic {
|
|
\\ clear static variables and variables (for this module)
|
|
Clear
|
|
Module K {
|
|
\\ if no A exist created with value 100@
|
|
\\ Static variables can't be referenced
|
|
Static A=100@
|
|
Print A, Type$(A)="Decimal"
|
|
A++
|
|
}
|
|
For i=1 to 10 : K : Next i
|
|
Print A=10000
|
|
}
|
|
CheckStatic
|
|
Print A=10000
|
|
|
|
\\ reference and use of stack of values
|
|
C=100&
|
|
Module ChangeC {
|
|
\\ we leave arguments in stack of values
|
|
Module HereChangeC (&f) {
|
|
\\ interpreter execute a Read &f
|
|
f++
|
|
}
|
|
\\ now we call HereChangeC passing current stack of values
|
|
HereChangeC
|
|
}
|
|
\\ Calling a module done without checking for what parameters a module take
|
|
ChangeC &C
|
|
Print C, Type$(C)="Long"
|
|
K=10010001001@
|
|
ChangeC &K
|
|
Print K, Type$(K)="Decimal"
|
|
Module TypeRef (&x as Double) {
|
|
Print x
|
|
x++
|
|
}
|
|
D=100
|
|
TypeRef &D
|
|
Try ok {
|
|
TypeRef &K
|
|
}
|
|
If Error or Not Ok then Print Error$ ' we get wrong data type
|