This post will introduce ADL (*Acronymic Demonstrational Language*), a language I designed to demonstrate how to write a parser.

## Statements

ADL has 5 different types of statements:

- if-statement
- while-loop
- for-loop
- assignment
- function call

An if-statement looks like this:

**if** *expression* **then**
*statements*
**end if**

An if-statement can also have an else-clause:

**if** *expression* **then**
*statements*
**else**
*statements*
**end if**

A while-loop looks like this:

**while** *expression* **do**
*statements*
**end while**

A for-loop looks like this:

**for** *variable* **:=** *expression* **to** *expression* **do**
*statements*
**end for**

A for-loop can also have a by-clause that defines the number to add to the variable on each iteration:

**for** *variable* **:=** *expression* **to** *expression* **by** *expression* **do**
*statements*
**end for**

An assignment looks like this:

*variable* **:=** *expression*

A function call looks like this:

*function***()**

It can also have one or more arguments separated by commas:

*function***(***expression***,** *expression***,** *expression***)**

## Expressions

Expressions in ADL consist of variables, constants, function calls, unary expressions, binary expressions and groups.

Variable names start with a letter, followed by zero or more letters or numbers.

ADL has 2 types of constants: strings and integer numbers. A string is a sequence of characters, enclosed between 2 quotes. An integer is a sequence of 1 or more digits.

Unary expressions are expressions with an operator that has only 1 operand:

- positive operator:
**+***expression* - negative operator:
**-***expression* - logical NOT-operator:
**not***expression*

Binary expressions are expressions with an operator that has 2 operands:

- logical AND-operator:
*expression***and***expression* - logical OR-operator:
*expression***or***expression* - comparison:
*expression comparator expression*(*comparator*is one of the following:**==**,**<>**,**<**,**>**,**<=**,**>=**) - addition:
*expression***+***expression* - subtraction:
*expression***-***expression* - multiplication:
*expression*******expression* - division:
*expression***/***expression*

A group is an expression between parentheses: **(** *expression* **)**

## Precedence

When an expression is built from multiple operators, the expression is evaluated in the following order:

- Grouping:
`( )`

- Unary expression:
`+ - not`

- Multiplicative expression:
`* /`

- Additive expression:
`+ -`

- Comparison:
`== <> < > <= >=`

- Logical OR:
`or`

- Logical AND:
`and`