Neon

Neon is an experimental programming language. It has C-like syntax and is easily interoperable with C/C++.

Features

Variables

• declaring new variables: int i = 0
• writing variables: i = 5
• reading variables: i = i + 5
• variable scoping
  • variables that are defined inside of a scope are not accessible from outside that scope
  • variables that are overriden in a scope are available again after that scope

Functions

• declaring functions: fun hello(float f) int { … }
• calling functions: hello(3.14)

Data Types

• Integer (64 bit): int i = 0
• Float (64 bit): float f = 0.0
• Boolean (1 bit): bool b = true
• Array
  • one dimensional arrays of the following primitive data types are supported:
    • int[5] a
    • float[5] a
    • bool[5] a
• String string s = "Hello World!"
  • the string type is managed, which means that the length of the string is saved along the data

Linking external object files

It is possible to link an object file with a program written in Neon. This makes it possible to call functions that are contained in the externally linked object file.

Control flow

If statements

• if statements work just like in C
• if/else statements work just like in C
• TODO if/else-if/…/else

For loops

• for loops work just like in C
• e.g. for int i = 0; i < 5; i = i + 1 { … }

Imports

• other Neon-files can be imported with the import keyword
• the imported file is specified with a relative path to the current source file
• e.g. import "examples/functions.ne"

Standard Library

• consists of two parts:
  • functions written in Neon
    • provides definitions to interface with existing c functions
    • for example maths functions
    • still WIP
  • functions written in C
    • provides functions that do not exist in available C libraries
    • for example conversion functions between the primitive data types

Complex Types

• complex types are types that are built up from other types
• for now only primitive types (int, float, bool, string) are allowed inside complex types
• can be declared like so:

type MyType {
   int i
}

TODO / Ideas

• complex types
  • arrays (multidimensional)
  • compound types (structs)
• think about interface definitions
  • how to create them
  • how to implement them
  • how to match types that implement the same interface
  • maybe a mixture between Go and Java?
• add comments (# or //)
  • single line
  • multi line
• importing files
  • place imported functions in a different namespace (the generated function names), so that they don't collide with locally defined functions
  • generate function in every module that contains all 'script' code
  • generate function call to that function in place of the import statement
• allow functions to be placed anywhere
  • in global scope
  • in function scope
  • deeply nested in multiple functions, etc.
  • make sure scoping of variables is done right.
  • basically every function is a lambda
• use musl as the runtime library to create smaller binaries
• add reflection capabilities
  • inspect objects at runtime
  • get information about types

Building LLVM to use with Neon

cmake -G Ninja -D CMAKE_INSTALL_PREFIX=C:/llvm -D LLVM_TARGETS_TO_BUILD="X86;AArch64" ..
cmake --build . --target install