npm package: @popovmp/cinonim-parser
Description: Parser for Cinonim - a C like language.
Latest version: 1.11.0

# Cinonim Parser

## Cinonim is a C like language targeting WebAssembly

**Cinonim** aims to be compiled to WebAssembly.

## Data types
  * **int**    -> **i32**
  * **long**   -> **i64**
  * **float**  -> **f32**
  * **double** -> **f64**
  * **void**   -> **void** used as a function return type

## Line comment

```c
// This is a line comment
```

## Global variable and constant definition

Global variables and constants must be initialised with a number.

```c
int    foo = 42;
long   bar = 66L;
float  faz = 2.1F;
double daz = 3.14;
``` 

## Function declaration

```c
int sum(const int m, const int n) { return m + n; }

void foo(double bar) { ... }
```

## Local variable declaration

Local variables are declared within a function at the beginning of the function body.

```c
void foo() {
    int    bar;
    double baz;
}
``` 

## Assignment

Local and global variable assignment

```c
double foo = 1.1;

void func(int bar) {
    int baz;

    foo = 3.14
    bar = 42;
}
```

## Conditionals

**if** accepts an `int` number or expression.

```c
int books;

if (books) {
 // statements
} else {
 // statements
}
```

## Loops

The loop's conditions is `i32`. 

```c
let i;

for (i = 0; i < max; i = i + 1) {
    break;
    continue;
}

do {
    break;
    continue;
} while (i < max);

while (foo) {
    break;
    continue;
}

```

## Grammar

```ebnf
module           = {global-variable | global-constant | function-def};
global-variable  = numeric-type, alphanum, "=", numeric, ";";
global-constant  = "const", numeric-type, alphanum, "=", numeric, ";";
function-def     = data-type, alphanum, "(", (parameter, {",", parameter})?, ")", "{", function-body, "}";
data-type        = "void" | numeric-type ;
numeric-type     = "int"  | "long" | "float" | "double" ;
alphanum         = [a-z A-Z]+ [a-z A-Z 0-9]* ;
numeric          = "-"? [0-9]+ ("." [0-9]+)? ;
parameter        = numeric-type, alphanum;
function-body    = local-variable*, statement* ;
local-variable   = numeric-type, alphanum, ";" ;
return           = "return", expression?, ";" ;
function-call    = alphanum, "(", (expression, (",", expression)* )?, ")" ;
if               = "if", "(", expression, ")", "{", statement*, "}", ("{", "else", statement* "}")? ;
for              = "for", "(", asignment?, ";", expression?, ";", asignment?, ")", "{", loop-body?, "}" ;
do               = "do", "{", loop-body?, "}",  "while", "(", expression, ")", ";" ;
while            = "while", "(", expression, ")", "{", loop-body?, "}" ;
loop-body        = {statement | break | continue} ;
break            = "break", numeric?, ";" ;
continue         = "continue", numeric?, ";" ;
statement        = assignment, ";" | do | while | if | function-call, ";" | statement ;
assignment       = alphanum, "=", expression ;
expression       = {grouping | numeric | variable-lookup | function-call | operato | expression};
grouping         = "(", expression, ")" ;
variable-lookup  = alphanum	;
operator         =  "+" | "-" | "*" | "/" | "%" | "||" | "&&" | "==" | "!="  | ">" | "<" | "<=" | ">=" | "!";
keyword          = "break" | "continue" | "const"  | "do"   | "double" | "else" | "float" | "if" | "int" |
                   "long"  | "loop"     | "return" | "void" | "while";
```

## AST structure

```
module
    +-- [*] globalVar {val: varName, dataType: varDataType}
    |           \-- [1] number
    |
    +-- [*] globalConst {val: varName, dataType: varDataType}
    |           +-- [1] number
    |
    \-- [*] function {value: funcName, dataType: funcDataType}
                +-- [1] funcParams
                |           \-- [*] localVar | localConst
                |
                \-- [1] funcBody
                            +-- [*] localVar {val: varName, dataType: varDataType}
                            +-- [*] FORM 

FORM =
    | asignment
    | localSet
    | globalSet
    | do
    | while
    | break
    | continue
    | funcCall
    | if
    | return

globalSet {value: varName, dataType: varDataType}
    \-- [1] expression

localSet {value: varName, dataType: varDataType}
    \-- [1] expression

break    {value: ?index}

continue {value: ?index}

funcCall {value: funcName, dataType: funcDataType}
    \-- [*] expression

if
    +-- [1] condition: i32
    |           \-- [1] expression: i32
    +-- [1] then
    |           \-- [*] FORM
    \-- [?] else
                \-- [*] FORM

for
    +-- [1] statement
    |           \-- [*] localSet | globalSet
    +-- [1] condition: i32
    |           \-- [?] expression: i32
    +-- [1] statement
    |           \-- [*] asignment
    +-- [1] loopBody
                \-- [*] FORM

do
    +-- [1] loopBody
    |           \-- [*] FORM
    \-- [1] condition: i32
                \-- [1] expression: i32

while
    +-- [1] condition: i32
    |           \-- [1] expression: i32
    \-- [1] loopBody
                \-- [*] FORM

return {value: funcName, dataType: funcDataType}
    \-- [1] expression

expression
    | [1] number
    | [1] expression
    | [1] funcCall
    |           \-- [*] expression
    | [1] localGet
    | [1] globalGet
```