####################
# ALZHEIMER SYNTAX #
####################

############
# comments #
############

# # starts a comment, end of line ends

########################
# variable declaration #
########################

var <varname> :<type>

var a :number # declare numeric variable a

var <var1>,<var2>,...<varn> :<type> # declare multiple variables of same type

var b,c,d :number # declare 3 numeric variables

# arrays are supported:
# var <v1>[<n>],<v2>[<m>] :number # creates <v1> numeric array of <n> elements
#                                 # and <v2> numeric array of <m> elements
# to use i'th element of array <array>[i]
# also every time you create array, array.size variable creates
# it stores array size (obviously)

var myAwesomeArray[100] :number # myAwesomeArray.size=100

# built-in types: 
# :number

##############
# statements #
##############

# statements are much like s-expressions
foo(a,bar(b,c)));
# if you start statement with $: it will be not checked for stack sanity
# (stack sanity check is only performed if -stackGuard command line option is enabled)
$: foo(a,bar(b,c)));
# if you want to assign the result of statement 
# you write <var>= after $: and put everything 
# else (except ;) in brackets()
$: a=(1);
d=(foo(a bar(b c))));
# there are some build-in functions:
# add(a b) or +(a b) – addition
# sub(a b) or -(a b) – subtraction
# mul(a b) or *(a b) – multiplication
# div(a b) or /(a b) – division
# more(a b) returns 1 if a > b , 0 otherwise
# moreeq(a b) returns 1 if a >= b, 0 otherwise
# less(a b) returns 1 if a < b , 0 otherwise
# lesseq(a b) returns 1 if a <= b, 0 otherwise
# eq(a b) returns 1 if a == b , 0 otherwise
# neq(a b) returns 1 if a != b, 0 otherwise

##############
# if - else  #
##############

# simplest if statement
# if <condition_statement>:
# <code>
# endif
# <condition_statement> should not start with $:
# remember that <condition_statement> shoult return a number
# also it's result will be checked for inequality with 0
# and if it is not 0, the <code> before endif will be executed
# (like in C and many other languages)
# so, the same stuff in C

# more complex if statement
# if <condition_statement>:
# <code>
# else
# <else_code>
# endif
# if <condition_statement> result is not 0, the <code> before else will be executed
# otherwise, the <else_code> before endif will be executed.

###############
# while loop  #
###############

# while <condition_statement>:
# <code>
# endwhile
# while <condition_statement> results is not 0
# <code> before endwhile will be executed
# for example:
var a :number
$: a=(10);
while more(a 0):
	$: a=(sub(a 1));# will be executed 10 times	
endwhile
# a will be 0

# break statement aborts loop execution immediatelly
# continue statement aborts current loop iteration jumping it to the next one

############
# for loop #
############
INITIALIZATION; CONDITION; AFTERT HOUGHT
# for <initialization>; <condition> ; <afterthough>;
# 	<code>
# endfor
# # basically is transformed to
# <initialization>
# while <condition>:
# 	<code>
# 	<afterthough>
# endwhile
var i;
for i=(0); less(i 3) ; i=(add(i 1));
	$: a=(add(a 1)) # will be executed 3 times
endfor


########################
# function declaration #
########################

# fun: <function>(<params>):<type>
# <code>
# end

# type is return type of the function
# some functions may not have any arguments
# so, <params> are optional
# also ,some of them do not return nothing
# so, :<type> is also optional

# return <statement> 
# aborts function execution
# and returns <statement> result
# <statement> is not necessary for 
# functions without return type

fun: foo(a b:number):number
	$: a=(add(a 1));
	$: b=(sub(b 1.5));
	return add(a b);
end
fun: bar(a b c:number):number
	$: a=(add(a c));
	$: b=(sub(b 1.5));
	return add(a b);
end

############
# imports  #
############
# import "<marasm_module1>" "<marasm_module2>" ... "<marasm_modulen>" ;
# add <marasm_module1> <marasm_module2> ... <marasm_modulen> as dependencies for your program
import "conio" "common" ;

#################
# custom types  #
#################
# type :<NewTypeName>
#	:<SomeType> <field1> <field2> ... <fieldn>
#	:<SomeOtherType> <fieldn+1> <fieldn+2> ... <fieldn+m>
#	.....................
# end
#
# create instance
# var <varname> :<NewTypeName>
# access fields
# <varname>.<fieldname>


type :Point # point on screen
	:number x y
end
type :Size # size on screen
	:number	w h
end
type :Rect # rectangle on screen
	:Point origin
	:Size size
end

var p :Point
$: p.x=(1);
$: p.y=(add(p.x 100));
# also you can use Type.size in your code as a numeric constant
a = :Point.size # a will store Point's size (2 on mvm)

###################################
# low level code (asm: statement) #
###################################
# asm: 
# <assembly_code>
# end
# each line of assembly code should terminated with ;


#############
# MORE INFO #
#############
#
# for more info see examples in tests folder in project
#