UCode is a programming language designed to be embedded into existing software such as game engines while being a low-level language with modern and high-level features.

mainly

• does not require a garbage collector like C#.
• offers more functionality than Lua.
• is easier to use than C++.
• Uses Compile time power to reduce boilerplate.

Design Principles/Pillars

• Simple is better than complex.
• Zero-overhead abstractions
  • You don't pay for what you don't use.
  • What you do use is just as efficient as what you could reasonably write by hand.
• Productive
  • Scalable compilation times
  • Reliable Tooling.
  • gradual learning curve
• Reuseable
  • multi-paradigm
  • Compile time power

QA

• Q: UCodeLang is very similar to c++ and rust why not use Rust or C++?

  A: C++ is too compilcaicated of a language and is unanalyzable after compiling(without hacking the compiler).rust memory features is not that usefull for my use cases and c++ Smart Pointer's is all i need.

• Q: Why is it written in c++.

  A: Most Game Engines and specificaly my game engine is written in c++.c++ is stil the best tool for makeing game engines.

• Q:Why not use LLVM for your backend.

  A:LLVM is too big of a dependency and writeing backends my self gives me a good excuse to learn about Computers(The Reason im makeing a game engine). Also you just output llvm assembly text.

• Q:Why significant white space?

  A:Just Seemed Interesting also just looks nicer.

• Q:UCodeLang just seems takes ideas from other languages does not do anything new.

  A:UCodeLang is not the next big thing it's just a tool made for my specific use case.It takes the best Parts from languages i like and attempts to remove excess.

• Q:What does UCode mean?

  A:The word UCode means nothing and has no history it just just a name I made up for a progaming language idea.if you realy want a meaning a meaning it when the idea was made it stand for Unsigned Code based on c/c++ unsigned keyword.

• Q:Do you like c++?

  A:I like it enough to spend a year makeing a new language useing it but not enough to make my users for my Game Engine Use it(Sorry unreal).

• Q:what next and when will be Language be done.

• A:When the repository Opens (preferably on 1/2/2023 The one year anniversary of makeing the jit project) most features would be done and dont really plan on adding more unless it Just too Good. I'll be around for an extra year to finsh up the other architectures and backends and stabitly.at that point the project will be done and i can go on working on that game engine and go to work on biger and better things.

Syntax

Here a basic run down of UCodeLang Syntax for People who already know how a programming language.

UCode uses Sugnificant Whitespace like python.

The syntax for declaring a function in UCode is as follows:

|function_name[parameter_list];//not being explicit with the return
|function_name[parameter_list] -> void;

For example, the following code declares a function named add that takes two integer parameters and returns an integer:

|add[int x, int y] -> int;

Variables are declared with a type and a name. For example, the following code declares an integer variable named x:

int x;

Member functions are just functions with a this parameter

use ULang;

$MyClass:
  |SayHello[this&]:
    Fmt::Print("Hello, World!");

|main[]:
  var object = MyClass();
  object.SayHello();

To access a static variable or function in UCode, you can use the class name and the scope resolution operator (::).

//no use of the ULang namespace;
|main[]:
  ULang::Fmt::Print("Hello");

functions can be expressed in different ways.

|add[int x, int y] => x + y;
    
|add2[int x, int y] -> int:
  ret x + y;

|add3[int x, int y]:
  ret x + y;

enums are is as follows:

$Color enum:
  Red,
  Green,
  Blue,

namespaces are is as follows:

MyNamespaces: 
  static int MyStaticValue = 10;
  thread int MythreadLocalValue =10; 
  int Value = 10;//also my threadLocalValue 

using namespaces is as follows:

use MyNamespaces;

alias is as follows:

$i64 = int64;
$u32 = uint32;

inheritance look like this

$Worker trait;//no members

$FasterWorker[Worker];//no members

Object protections look like this

$Worker;

$FasterWorker[Worker]:
  public:
    int Hp = 10;
  private:
    int Money = 10;
    int Happiness = 10;

Standard Library Compiler alias

• Optional

int? MaybeAnInt;//an optional int

• Vector

int[] Ints;//an Vector<int>

• Array

int[5] MoreInts;//an Array<int,5>

• Span

int[:] SpanOfInts;//an Span<int>

• unique_ptr

int^ UniqueInt;//an Unique_ptr<int>

• Shared_ptr

int$ SharedInt;//an Shared_ptr<int>

• unique_Array

int[^] UniqueIntsArray;//an Unique_Array<int>

• Shared_Array

int[$] SharedIntsArray;//an Shared_Array<int>

immutability

imut int ConstInt = 5;
imut ConstInt2 = 4;// or like this.    
$MyClass:
  |SayHello[umut this&]:
    Fmt::Print("Hello, World!");

references

|main[]:  
  int x = 10;
  int& r = x;

|Update_NumToChange[int& V]:
  V = 10;

Thats the basics heres. Some links Explore More:

• Standardlibrary
• Modules
• MemoryManagement
• Keywords
• traits
• generics

Geting Started Users

Despite that UCodeLang was designed to embed into applications.

You can use it by itself.

Download

You may use the Playground to try it without Downloading.

Run The following in your terminal to install on linux/MacOs.

curl https://raw.githubusercontent.com/LostbBlizzard/UCodeLang/master/install.sh | sh

Or Download the Installer on the latest release for Windows.

To test that it was installed in your command prompt try runing.

uclang help

Extension

lets also download the VsCode extension to make our lives easier.

just search up UCodeLang by Lost blizzard in your extension tab.

Hello main

after geting your extension. run

uclang new

This will ask you about the Project name and author's name.

You can put HelloMain as the ProjectName. and MySelf as the AuthorName.

Inside the new folder.You will Have this folder structure.

- HelloMain
  
  - src
    - main.uc

  - ULangModule.ucm
  
  - Build.uc

The 'src' Folder is were all your code is going to be. UCodeLang uses the .uc file extension for all source files.

main.uc is were your main funcion is.This is were your program will start executing.

Build.ucm Is your build script. this allows you to do stuff before and after you build your project. you can ignore this file or even delete it for now.

Lasly ULangModule.uc Is were you place your dependencies.

build and runing

Now lets build our Hello World Program by runing uclang build.

uclang build

And run to program by using uclang run

uclang run

You should see Hello World On your Screen.

Also See Syntax And Semantics

Also See Standardlibrary

UCodeCL command-line reference

The UCodeLang Command-line tool it serves as a Compiler,Runtime,build system and package manager for UCodeLang.

Syntax

uclang [command] <arguments>

Commands

UCodeCL command-line reference

The UCodeLang Command-line tool it serves as a Compiler,Runtime,build system and package manager for UCodeLang.

Syntax

uclang [command] <arguments>

Commands

Help Command

the list available commands is equivalent to reading the commands docs Example

uclang help

Possible output

Usage: uclang [command] [args]

new           [Path]     :Makes a new Module Project
build         [Path]     :Builds the UCode file,Module,folder
run           [Path] <FunctionName(<Args>)>    :run the UCode file,Module,folder,.ulib
test          [Path]     :Runs Tests the UCode file,Module,folder,.ulib
dump          [Path]     :Convert the UCode file,Module,folder,.ulib to Readable Text

New Command

Example

uclang new <ProjectName> <Author> <-[y/n]>

This command will make a new project in the working directory.

If not provided will ask the user for a ProjectName an Author and if thay want a .gitnore file.

The exit code is 0.

Build Command

By default uclang build will compile to UCodeVM being 32 or 64 bit if the current cpu is 32 or 64.

if path not provided it will use the working directory as its input and use a UCodeModule Project in it to Compile.

The exit is 0 if compilation succeed or 1 for compilation fail.

Example

uclang build -c89

uclang build -uvm:x86_64

Run Command

By default uclang will try to call the main funcion.

uclang run

This can be overwritten and basic arguments can be passed.

uclang run func(4)

These flags only apply if path was UCodeLang File,Module,Folder or .ulib.

The exit code is 0 if compilation succeed or 1 for compilation fail or if it panic or returns an error if the return type is an result type.

after runing the console will look like the following

returned:
void

or

returned:
1

Get Command

Example

uclang get <ProjectPath>

This command will download the project dependencies if they don't exist.

The exit code is 0 it did so successfully else its 1.

Dump Command

Example

uclang dump <path>

Its Disassembles a .ulib or a .wasm file or a project.

if path not provided it will use the working directory as its input and use a UCodeModule Project in it to Compile and dump its output.

note this is manly used for debuging.

The exit code is 0 it did so successfully else its 1.

Clean Command

Example

uclang clean <path>

Clears a Module a intermediate and output files if not provided will use the working directory.

exit code is 0 if it worked else 1.

Cleanall Command

Example

uclang cleanall <path>

Clears all modules on the system intermediate and output files if not provided will use the working directory.

exit code is 0 if it worked else 1.

Fmt Command

Example

uclang new <Path>

if path not provided it will use the working directory as its input.

Formats the UCodeLang Code in the Module or the file directly.

The exit code is 0 it did so successfully else its 1.

cpptoulangvm

Example

uclang cpptoulangvm [Cppfilepath] [UCodeLangBindingPath] [CppVMBindingPath]

Generates bindings for UCodeLang using c++ source code.

exit code is 0 if it worked else 1.

Heres our types and funcions we will like to export in our c++ file.

enum class Colors
{
    Red,
    Green,
    Blue,
}

void SomeFuncionthatTakeinColor(Colors a)
{
    //
}

The argument for the macros is the namespace inside of UCodeLang file.

namespace OurAPI
{

UCodeLangExportSymbol("YourFrameWorkNameSpace") enum class Colors
{
    Red,
    Green,
    Blue,
}


UCodeLangExportSymbol("YourFrameWorkNameSpace") void SomeFuncionthatTakeinColor(Colors a)
{
    //
}

}

next we need to add 'UCodeLangAutoLink' macros. when we add our Add_CPPCall.

UCodeLang::RunTimeLib Lib;
Lib.Init(comilerRet.OutPut);//initialize RunTimeLib useing our Compiled code.

//Adding Our PrintNumberConsole Funcion.
lib.Add_CPPCall("PrintNumberConsole", []( UCodeLang::InterpreterCPPinterface& Input)
{
	int Par0 = Input.GetParameter<int>();
    UAPI_PrintNumberConsole(Par0);
    Input.Set_Return();
},UAPI_PrintNumberConsole);

//Our UCodeLangAutoLink
UCodeLangAutoLink(Lib, OurAPI);

Lets run our UCodeLang UCodeLang command line tool.

Open your command line in your ProjectRoot.

ProjectRoot >

then run uclang and type cpptoulangvm

• Then with for c++ file path
• then output ucodelang file(.uc) path
• then c++ output were 'UCodeLangAutoLink' macros is found

ProjectRoot > ./uclang cpptoulangvm [CppPath] [UCodeLangOut] [CppVMLinkPath]

now the UCodeLangOut will have all funcion and type boilerplate and CppVMLinkPath will have all the Add_CPPCall funcions.

and if you have your API in multiple C++ files you can use cppdirtoulangvm to search inside directories.it even automatically includes the .h/.hpp files.

cppdirtoulangvm

Example

uclang cppdirtoulangvm [Cppdirpath] [UCodeLangBindingPath] [CppVMBindingPath]

Works the same as cpptoulangvm but take input of c++ directory instead of a single file.

Test Command

Example

uclang test <path>

if path not provided it will use the working directory as its input.

Runs all the test in the module.

use ULang;
[Test]
|MyTest[]: 
 Assert(1 == 1);

The exit code is 0 it did so successfully and all the test pass else its 1.

update

Updatetools Command

Example

uclang updatetools

This command will update uclang and the lsp to the newest version.

exit code is 0 if it worked else 1.

Uninstalltools Command

Example

uclang uninstalltools

This command will update uninstall uclang and the lsp. all downloaded modules may be removed.

exit code is 0 if it worked else 1.

index Command

Example

uclang index <ModulePath>

readds if it doesn't already exist the module to system moduleindex so reference as a module dependency or be used in RunMod.

The exit code is 0 it did so successfully else its 1.

Install Command

Example

uclang Install [WebLink]

downloads a Module from the Web and added it the module system index. if it succeeds you should be able to use [modrun] or use it as a dependency.

The exit code is 0 it did so successfully else its 1.

runmod Command

runs a module on the system. By default uclang will try to call the main funcion.

uclang runmod [module]

This can be overwritten and basic arguments can be passed.

uclang runmod [module] func(4)

The exit code is 0 if compilation succeed or 1 for compilation fail or if it panic or returns an error if the return type is an result type.

after runing the console will look like the following

returned:
void

or

returned:
1

addmod Command

Example

uclang addmod <WebLink> <module>

if path not provided it will use the working directory as its input.

downloads a Module from the Web and added it the module system index. then adds as a dependency to the module.

The exit code is 0 it did so successfully else its 1.

uninstallmod Command

Example

uclang uninstallmod [modulename]

Uninstall the module and it's unused dependencies.

The exit code is 0 it did so successfully else its 1.

Exit Command

exits ucodelang if opened without command line arguments.

ForImplementers

This section is about for People who are Implementing the UCodeLang in there C++ Projects such as GameEngines or Developer frameworks.

Requirements

• C++17 Compiler.
• Basic knowledge of linking and Include C++ Projects

Download

Simply Git Clone The project or download it inside your external librarys or dependency folder.

git clone https://github.com/LostbBlizzard/UCodeLang.git

Building Project

We will be using premake here but this will work with any build system.

To Build the Project we need to set up the local Project includes Directory.

• The UCodeLang/UCodeLang is is intentional.It Just how the project is Structured.

• [YourDependencyFolder] is the Directory you git clone to.

• [GitDownload] is the Directory git clone produced containing UCodeLang Repository.

includedirs
{
    "[YourDependencyFolder]/[GitDownload]/UCodeLang",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/include",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/include",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/src",
}

Next we pick what files are part of the Library.

UCodeLang mainly uses .hpp and .cpp but with some exceptions so we also have to include them.

files 
{
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.hpp",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.cpp",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.h", 
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.c",
}

We will also need to include zydis and zycore because UCodeLang needs them.

files { 
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/src/**.c",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/src/**.c",

"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/src/**.inc",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/src/**.inc",

"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/include/**.h",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/include/**.h",
}

Try building this as a Static library. It may take 2-8 minutes to fully build.

90% of the Project is the Compiler.

If your haveing any problems try asking for help on the github discussions tab.

Using it

Now the hard part is over its now time to use this library.

Now in your Main project now add these two include Directorys and make sure you link your static library.

includedirs
{
"[YourDependencyFolder]/[GitDownload]/UCodeLang",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang"
}

If every thing is done correctly. your should be able to use these segment of c++ in your project.

#include <UCodeLang/UCodeLang.hpp>

int main()
{
  const char* MyUCode = "|main[] => 1;";

  UCodeLang::Compiler myCompiler;
  auto comilerRet = myCompiler.CompileText(MyUCode);


  if (!comilerRet.IsError())
  { 
    //your ucode was Compiled
    UCodeLang::RunTimeLangState State;

    UCodeLang::RunTimeLib Lib;
    Lib.Init(comilerRet.GetValue().OutPut.value());//initialize RunTimeLib using our Compiled code.


    State.AddLib(&Lib);//Add RunTimeLib
    State.LinkLibs();//Link libraries
   
    UCodeLang::Interpreter interpreter;
    interpreter.Init(&State);

    interpreter.Call(StaticVariablesInitializeFunc);//initialize our Static Variables.
    interpreter.Call(ThreadVariablesInitializeFunc);//initialize thread local/Interpreter local Variables.

    int Value = interpreter.RCall<int>("main");//Call main
    std::cout << " Got Value " << Value;


    interpreter.Call(ThreadVariablesUnLoadFunc);//Call Thread local Variables destructors.
    interpreter.Call(StaticVariablesUnLoadFunc);//Call Static Variables destructors.
  }
  else 
  {
    //your code failed to compile
  }
}

Here the C++ reference use this find out what usefull full classes,funcion and types are in UCodeLang.

Also see the Language Reference if you alread know C++ you can learn the Whole Language in a day.

ForImplementers

This section is about for People who are Implementing the UCodeLang in there C++ Projects such as GameEngines or Developer frameworks.

Requirements

• C++17 Compiler.
• Basic knowledge of linking and Include C++ Projects

Download

Simply Git Clone The project or download it inside your external librarys or dependency folder.

git clone https://github.com/LostbBlizzard/UCodeLang.git

Building Project

We will be using premake here but this will work with any build system.

To Build the Project we need to set up the local Project includes Directory.

• The UCodeLang/UCodeLang is is intentional.It Just how the project is Structured.

• [YourDependencyFolder] is the Directory you git clone to.

• [GitDownload] is the Directory git clone produced containing UCodeLang Repository.

includedirs
{
    "[YourDependencyFolder]/[GitDownload]/UCodeLang",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/include",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/include",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/src",
}

Next we pick what files are part of the Library.

UCodeLang mainly uses .hpp and .cpp but with some exceptions so we also have to include them.

files 
{
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.hpp",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.cpp",
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.h", 
    "[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang/**.c",
}

We will also need to include zydis and zycore because UCodeLang needs them.

files { 
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/src/**.c",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/src/**.c",

"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/src/**.inc",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/src/**.inc",

"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zydis/include/**.h",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/Dependencies/zycore/include/**.h",
}

Try building this as a Static library. It may take 2-8 minutes to fully build.

90% of the Project is the Compiler.

If your haveing any problems try asking for help on the github discussions tab.

Using it

Now the hard part is over its now time to use this library.

Now in your Main project now add these two include Directorys and make sure you link your static library.

includedirs
{
"[YourDependencyFolder]/[GitDownload]/UCodeLang",
"[YourDependencyFolder]/[GitDownload]/UCodeLang/UCodeLang"
}

If every thing is done correctly. your should be able to use these segment of c++ in your project.

#include <UCodeLang/UCodeLang.hpp>

int main()
{
  const char* MyUCode = "|main[] => 1;";

  UCodeLang::Compiler myCompiler;
  auto comilerRet = myCompiler.CompileText(MyUCode);


  if (!comilerRet.IsError())
  { 
    //your ucode was Compiled
    UCodeLang::RunTimeLangState State;

    UCodeLang::RunTimeLib Lib;
    Lib.Init(comilerRet.GetValue().OutPut.value());//initialize RunTimeLib using our Compiled code.


    State.AddLib(&Lib);//Add RunTimeLib
    State.LinkLibs();//Link libraries
   
    UCodeLang::Interpreter interpreter;
    interpreter.Init(&State);

    interpreter.Call(StaticVariablesInitializeFunc);//initialize our Static Variables.
    interpreter.Call(ThreadVariablesInitializeFunc);//initialize thread local/Interpreter local Variables.

    int Value = interpreter.RCall<int>("main");//Call main
    std::cout << " Got Value " << Value;


    interpreter.Call(ThreadVariablesUnLoadFunc);//Call Thread local Variables destructors.
    interpreter.Call(StaticVariablesUnLoadFunc);//Call Static Variables destructors.
  }
  else 
  {
    //your code failed to compile
  }
}

Here the C++ reference use this find out what usefull full classes,funcion and types are in UCodeLang.

Also see the Language Reference if you alread know C++ you can learn the Whole Language in a day.

Calling C++ from UCodeLang

Its Time to Make UCodeLang do something useful. By default UCodeLang has no Input or Output other than doing stuff with memory.

So UCodeLang has no way Opening Files,Networking or most importantly calling your framework.

To Fix this We have CPPCalls and dynamic external funcions.

Lets Say we have a UCodeLang funcion that we want to make Print a Number to the Console.

|PrintNumberConsole[int number] -> void;

First we will need to tell the compiler that the funcion will have its implementation be added at runtime by using the dynamic and extern Keywords.

extern dynamic |PrintNumberConsole[int number] -> void;

Next In our C++ file. Lets make a funcion that does that.

void UAPI_PrintNumberConsole(int num)
{
    std::cout << std::tostring(num) << std::endl;
}

Then lets add that funcion to the RunTimeLib using Add_CPPCall.

UCodeLang::RunTimeLib Lib;
Lib.Init(comilerRet.OutPut);//initialize RunTimeLib useing our Compiled code.

//Adding Our PrintNumberConsole Funcion.
lib.Add_CPPCall("PrintNumberConsole", []( UCodeLang::InterpreterCPPinterface& Input)
{
	int Par0 = Input.GetParameter<int>();
    UAPI_PrintNumberConsole(Par0);
    Input.Set_Return();
},UAPI_PrintNumberConsole);

Lets me explains whats going in Add_CPPCall.

First give the funcion the a name "PrintNumberConsole".

Next we make a lambda(funcion without a name) that allow us to talk to the Interpreter that called this funcion. then we ask for for our first function of parameter of type int.

Then we call UAPI_PrintNumberConsole with our parameter.

Then we ask the Interpreter to set Set_Return to nothing.

Lastly we pass a funcion pointer of UAPI_PrintNumberConsole.So the JitInterpreter and the NativeInterpreter will be to call the funcion.

now all you have to do is to call PrintNumberConsole in your UCodeLang Source Code.

extern dynamic |PrintNumberConsole[int number] -> void;
const char* MyUCode = "|main[] => PrintNumberConsole(10 + 5);";

When you call main you should should see that 15 was printed to the console.

but this would be tedious to do for every funcion and it doesn't account for.

• Funcion overloading.
• Namespaces.
• Structs.
• Enums.
• Constructors,Destructor copy Constructors.
• Changeing APIs
• Type marshaling
• Just having Hundreds of funcions to expose.

It Would be a architectural and dependency nightmare.

If only theres a way to generate these bindings and types using our c++ source code and all we have to do just mark the funcions and types we would like expose.

We could call it cpptoulangvm.

Next Part

Automatic Binding Generation

To Solve this problem uclang or the UCodeLang command line tool is able to generate these bindings.

First step is geting the uclang command line tool. Theres two ways of geting by installing it or building from source.

For this example we will just steal it from the github releases and put it in our project root directory.

after that lets mark our c++ files with the funcions and types to export.

Heres our types and funcions we will like to export in our c++ file.

enum class Colors
{
    Red,
    Green,
    Blue,
}

void SomeFuncionthatTakeinColor(Colors a)
{
    //
}

Next add these c++ macros .The argument for the macros is the namespace inside of UCodeLang file.

namespace OurAPI
{

UCodeLangExportSymbol("YourFrameWorkNameSpace") enum class Colors
{
    Red,
    Green,
    Blue,
}


UCodeLangExportSymbol("YourFrameWorkNameSpace") void SomeFuncionthatTakeinColor(Colors a)
{
    //
}

}

These will tell uclang command line tool to generate bindings for these funcions and types.

next we need to add 'UCodeLangAutoLink' macros. when we add our Add_CPPCall.

UCodeLang::RunTimeLib Lib;
Lib.Init(comilerRet.OutPut);//initialize RunTimeLib useing our Compiled code.

//Adding Our PrintNumberConsole Funcion.
lib.Add_CPPCall("PrintNumberConsole", []( UCodeLang::InterpreterCPPinterface& Input)
{
	int Par0 = Input.GetParameter<int>();
    UAPI_PrintNumberConsole(Par0);
    Input.Set_Return();
},UAPI_PrintNumberConsole);

//Our UCodeLangAutoLink
UCodeLangAutoLink(Lib, OurAPI);

now lets run our UCodeLang UCodeLang command line tool.

Open your command line in your ProjectRoot.

ProjectRoot >

then run uclang (or uclang.exe if your on windows) and type cpptoulangvm

• Then with for c++ file path
• then output ucodelang file(.uc) path
• then c++ output were 'UCodeLangAutoLink' macros is found

ProjectRoot > ./uclang cpptoulangvm [CppPath] [UCodeLangOut] [CppVMLinkPath]

now the UCodeLangOut will have all funcion and type boilerplate and CppVMLinkPath will have all the Add_CPPCall funcions.

and if you have your API in multiple C++ files you can use cppdirtoulangvm to search inside directories.it even automatically includes the .h/.hpp files.

ProjectRoot > ./uclang cppdirtoulangvm [CppDir] [UCodeLangOut] [CppVMLinkPath]

The Next Part is about using Module System to Add the Standad Library and other Modules(like your framwork API) and also allowing for intellisense for your code editor.

Standard Library and Modules

After Automatic Binding Generation the last thing we need to is to add the Standard Library and allowing Input And Output.

Let's take the easier one out of the way.

Allowing Input And Output.

Because CPPCalls and dynamic external funcions is the only for UCodeLang to talk to c++ and by extension the outside world.

Three Classes are made to add all of CPPCalls for you so you can get to work on makeing your framework.

• IOLink

Adds CppCalls for direct access to the file system,network and other IO.

• SandBoxedIOLink

Adds CppCalls for simulateing access in memory to the file system,network and other IO allowing the developer selectively allow access to these systems.

like pretending all files don't exist and except for selected few and those are read-only.

• UtilityLink Adds CppCalls for everything else that doesn't fit in IO mostly relating to the CPU and Memory.
  • Math
  • SIMD
  • Atomic

those classes can be used like so

UCodeLang::RunTimeLib Lib;
Lib.Init(comilerRet.OutPut);//initialize RunTimeLib useing our Compiled code.
UtilityLink::Link(Lib);

SandBoxedIOLink::Link(Lib);
//IOLink::Link(Lib);
//You can only pick SandBoxedIOLink or IOLink because thay add the same funcions

Module System

To add the StandardLibrary we need to use the Module System.

Now you know the basics to get started makeing your framework.

Use the API Reference to see what other useful funcions and classes are in UCodeLang.

API Reference

The API Reference is spit into Three parts and Compiler and RunTime.

Every thing in UCodeLang in UCodeLang NameSpace

namespace UC = UCodeLang;

Compilation

Types related to compiling and its Output.

RunTime

Types related to The UCodeVM/RunTime.

Analysis

Types related to The Analyzing UCodeLang ,UCodeLang Output or its Runtime.

Core

Basic types that UCodeLang Uses stop isn't part of C++17 standard Library. | Name | Type | Description | |--- | --- | --- | Result | Generic class | A type holding a returned value or an error code. NeverNullPtr | Generic class | A pointer that should never be null. NullablePtr | Generic class | A pointer that could be null. Variant | Generic class | A wapper over std::variant give it more functions. Span | Generic class | A contiguous sequence of objects

C API

UCodeLang Has a C API for using UCodeLang in Programming Languages other than C++.

Notes

Many more classes and funcions can be found in UCodeLang but may change may change on a whim its recommended not to used those them if its not documented here.

CAPI

API Reference

The API Reference is spit into Three parts and Compiler and RunTime.

Every thing in UCodeLang in UCodeLang NameSpace

namespace UC = UCodeLang;

Compilation

Types related to compiling and its Output.

RunTime

Types related to The UCodeVM/RunTime.

Analysis

Types related to The Analyzing UCodeLang ,UCodeLang Output or its Runtime.

Core

Basic types that UCodeLang Uses stop isn't part of C++17 standard Library. | Name | Type | Description | |--- | --- | --- | Result | Generic class | A type holding a returned value or an error code. NeverNullPtr | Generic class | A pointer that should never be null. NullablePtr | Generic class | A pointer that could be null. Variant | Generic class | A wapper over std::variant give it more functions. Span | Generic class | A contiguous sequence of objects

C API

UCodeLang Has a C API for using UCodeLang in Programming Languages other than C++.

Notes

Many more classes and funcions can be found in UCodeLang but may change may change on a whim its recommended not to used those them if its not documented here.

Reference/Compiler

Definition

HeaderFile: UCodeLang/Compliation/Compiler.hpp

Is Included In UCodeLang.hpp: Yes

The UCodeLang Compiler.

class Compiler;

Example

#include <UCodeLang/UCodeLang.hpp>

void main()
{
  const char* MyUCode = "|main[] => 1;";

  UCodeLang::Compiler myCompiler;
  auto comilerRet = myCompiler.CompileText(MyUCode);


  if (!comilerRet.IsError())
  { 
    //your ucode was Compiled
  }
  else
  {
    //your cide fail to compile
  }
}

Methods

Types

CompilerPathData

struct CompilerPathData
{
    Path FileDir;
    Path IntDir;
    Path OutFile;
}

ExternalFiles

struct ExternalFiles
{
	Vector<Path> Files;
};

CompliationSuccess

struct CompliationSuccess
{
	NeverNullPtr<UClib> OutPut;
	Optional<BytesPtr> OutFile;
}

CompilerRet

using CompilerRet = Result<CompliationSuccess,NeverNullPtr<CompliationErrors>>;

Notes

Reference/ModuleFile

Definition

HeaderFile: UCodeLang/Compliation/ModuleFile.hpp

Is Included In UCodeLang.hpp: No

The UCodeLang Compiler Module System.

class ModuleFile;

Example

[!IMPORTANT] This Is section Is incomplete

Methods

Static Funcions

Fields

Static Members

Types

Notes

Reference/UClib

Definition

HeaderFile: UCodeLang/LangCore/UClib.hpp

Is Included In UCodeLang.hpp: Yes

The UCodeLang Compiler Output.

class UClib;

Example

[!IMPORTANT] This Is section Is incomplete

Methods

Static Funcions

Reference/UCodeBackEnd

Definition

HeaderFile: UCodeLang/Compliation/Back/UCodeBackEnd/UCodeBackEnd.hpp

Is Included In UCodeLang.hpp: No

The BackEnd for the UCodeInterpreter or Jit Interpreter.

class UCodeBackEnd;

Example

#include "UCodeLang.hpp"
#include "UCodeLang/Compliation/Back/UCodeBackEnd/UCodeBackEnd.hpp"

void main()
{
    UCodeLang::Compiler _Compiler;
	_Compiler.Set_BackEnd(UCodeLang::UCodeBackEnd::MakeObject);
	//You set the backend to target the Interpreter or jit-Interpreter
}

MemberFuncions

Static Members

Notes

Like All BackEnds UCodeBackEnd is not meant to be directly but instead used from the Compiler.

Reference/C11Backend

Definition

HeaderFile: UCodeLang/Compliation/Back/C89/C89Backend.hpp

Is Included In UCodeLang.hpp: No

The BackEnd to output C11 Code.

class C11Backend;

Example

#include "UCodeLang.hpp"
#include "UCodeLang/Compliation/Back/C11/C11Backend.hpp"

void main()
{
    UCodeLang::Compiler _Compiler;
    _Compiler.Set_BackEnd(UCodeLang::C11Backend::MakeObject);
    //You set the backend to output C11 Code.
}

MemberFuncions

Static Members

Notes

Like All BackEnds UCodeBackEnd is not meant to be directly but instead used from the Compiler.

Reference/C89Backend

Definition

HeaderFile: UCodeLang/Compliation/Back/WebAssembly/WasmBackEnd.hpp

Is Included In UCodeLang.hpp: No

The BackEnd to output a WebAssembly Module.

class BackEndObject;

Example

#include "UCodeLang.hpp"
#include "UCodeLang/Compliation/Back/WebAssembly/WasmBackEnd.hpp"

void main()
{
    UCodeLang::Compiler _Compiler;
	_Compiler.Set_BackEnd(UCodeLang::WasmBackEnd::MakeObject);
	//You set the backend to output a Wasm.
}

MemberFuncions

Static Members

Notes

Like All BackEnds UCodeBackEnd is not meant to be directly but instead used from the Compiler.

API Reference

The API Reference is spit into Three parts and Compiler and RunTime.

Every thing in UCodeLang in UCodeLang NameSpace

namespace UC = UCodeLang;

Compilation

Types related to compiling and its Output.

RunTime

Types related to The UCodeVM/RunTime.

Analysis

Types related to The Analyzing UCodeLang ,UCodeLang Output or its Runtime.

Core

Basic types that UCodeLang Uses stop isn't part of C++17 standard Library. | Name | Type | Description | |--- | --- | --- | Result | Generic class | A type holding a returned value or an error code. NeverNullPtr | Generic class | A pointer that should never be null. NullablePtr | Generic class | A pointer that could be null. Variant | Generic class | A wapper over std::variant give it more functions. Span | Generic class | A contiguous sequence of objects

C API

UCodeLang Has a C API for using UCodeLang in Programming Languages other than C++.

Notes

Many more classes and funcions can be found in UCodeLang but may change may change on a whim its recommended not to used those them if its not documented here.

Reference/AnyInterpreter

Definition

HeaderFile: UCodeLang/Compliation/ModuleFile.hpp

Is Included In UCodeLang.hpp: No

The UCodeLang Compiler Module System.

class AnyInterpreter;

Example

Methods

Static Funcions

Fields

Static Members

Types

Notes

API Reference

The API Reference is spit into Three parts and Compiler and RunTime.

Every thing in UCodeLang in UCodeLang NameSpace

namespace UC = UCodeLang;

Compilation

Types related to compiling and its Output.

RunTime

Types related to The UCodeVM/RunTime.

Analysis

Types related to The Analyzing UCodeLang ,UCodeLang Output or its Runtime.

Core

Basic types that UCodeLang Uses stop isn't part of C++17 standard Library. | Name | Type | Description | |--- | --- | --- | Result | Generic class | A type holding a returned value or an error code. NeverNullPtr | Generic class | A pointer that should never be null. NullablePtr | Generic class | A pointer that could be null. Variant | Generic class | A wapper over std::variant give it more functions. Span | Generic class | A contiguous sequence of objects

C API

UCodeLang Has a C API for using UCodeLang in Programming Languages other than C++.

Notes

Many more classes and funcions can be found in UCodeLang but may change may change on a whim its recommended not to used those them if its not documented here.

API Reference

The API Reference is spit into Three parts and Compiler and RunTime.

Every thing in UCodeLang in UCodeLang NameSpace

namespace UC = UCodeLang;

Compilation

Types related to compiling and its Output.

RunTime

Types related to The UCodeVM/RunTime.

Analysis

Types related to The Analyzing UCodeLang ,UCodeLang Output or its Runtime.

Core

Basic types that UCodeLang Uses stop isn't part of C++17 standard Library. | Name | Type | Description | |--- | --- | --- | Result | Generic class | A type holding a returned value or an error code. NeverNullPtr | Generic class | A pointer that should never be null. NullablePtr | Generic class | A pointer that could be null. Variant | Generic class | A wapper over std::variant give it more functions. Span | Generic class | A contiguous sequence of objects

C API

UCodeLang Has a C API for using UCodeLang in Programming Languages other than C++.

Notes

Many more classes and funcions can be found in UCodeLang but may change may change on a whim its recommended not to used those them if its not documented here.

Syntax And Semantics

• Syntax

• Keywords

• Memory Management

• Inheritance

• Casting

• Conditional Compliation

• Traits

• Generic

• Function

• Constructors And Destructors

• namespaces

• alias

• Address

• Anonymous Object Constructer

• Access Modifiers

• Lambda

Syntax

Here a basic run down of UCodeLang Syntax for People who already know how a programming language.

UCode uses Sugnificant Whitespace like python.

The syntax for declaring a function in UCode is as follows:

|function_name[parameter_list];//not being explicit with the return
|function_name[parameter_list] -> void;

For example, the following code declares a function named add that takes two integer parameters and returns an integer:

|add[int x, int y] -> int;

Variables are declared with a type and a name. For example, the following code declares an integer variable named x:

int x;

Member functions are just functions with a this parameter

use ULang;

$MyClass:
  |SayHello[this&]:
    Fmt::Print("Hello, World!");

|main[]:
  var object = MyClass();
  object.SayHello();

To access a static variable or function in UCode, you can use the class name and the scope resolution operator (::).

//no use of the ULang namespace;
|main[]:
  ULang::Fmt::Print("Hello");

functions can be expressed in different ways.

|add[int x, int y] => x + y;
    
|add2[int x, int y] -> int:
  ret x + y;

|add3[int x, int y]:
  ret x + y;

enums are is as follows:

$Color enum:
  Red,
  Green,
  Blue,

namespaces are is as follows:

MyNamespaces: 
  static int MyStaticValue = 10;
  thread int MythreadLocalValue =10; 
  int Value = 10;//also my threadLocalValue 

using namespaces is as follows:

use MyNamespaces;

alias is as follows:

$i64 = int64;
$u32 = uint32;

inheritance look like this

$Worker trait;//no members

$FasterWorker[Worker];//no members

Object protections look like this

$Worker;

$FasterWorker[Worker]:
  public:
    int Hp = 10;
  private:
    int Money = 10;
    int Happiness = 10;

Standard Library Compiler alias

• Optional

int? MaybeAnInt;//an optional int

• Vector

int[] Ints;//an Vector<int>

• Array

int[5] MoreInts;//an Array<int,5>

• Span

int[:] SpanOfInts;//an Span<int>

• unique_ptr

int^ UniqueInt;//an Unique_ptr<int>

• Shared_ptr

int$ SharedInt;//an Shared_ptr<int>

• unique_Array

int[^] UniqueIntsArray;//an Unique_Array<int>

• Shared_Array

int[$] SharedIntsArray;//an Shared_Array<int>

immutability

imut int ConstInt = 5;
imut ConstInt2 = 4;// or like this.    
$MyClass:
  |SayHello[umut this&]:
    Fmt::Print("Hello, World!");

references

|main[]:  
  int x = 10;
  int& r = x;

|Update_NumToChange[int& V]:
  V = 10;

Thats the basics heres. Some links Explore More:

• Standardlibrary
• Modules
• MemoryManagement
• Keywords
• traits
• generics

MemoryManagement

[!IMPORTANT] This Is section Is incomplete.

UCode like C++ requires the programmer to manually allocate and deallocate memory useing the new and drop keywords.

like so:

int& MyMemory = unsafe new int();// allocate 4 bytes

unsafe drop(MyMemory);// deallocate 4 bytes

you can also allocate an array.

int[&] MyMemory = unsafe new int[5];// allocate 20 bytes

unsafe drop(MyMemory);// deallocate 20 bytes

because not deallocate memory can cause your Progarm to run out memory. You can use Smart Pointers in the Standardlibrary.Unique_ptr and Shared_ptr are both Smart Pointers and can deallocate memory when its not used.

Class(concept)

Classes are a data type that defines a custom structure with fields and methods. Classes work similarly to structs in C, but with some differences. For example:

Classes can inherit from other classes using the ‘[Type]’ operator. Classes can have constructors and destructors using the new and drop keywords.

    $Person;//a class with no members.

    $Worker[Person]://inherit from person
    String name;
    int age;


    //constructors
    |new[this&,string name,int age]:
     this.name = name;
     this.age = age;

    //destructors
    |drop[this&]:
     Console::Log("Done Working for the Day.");

Classes can have access modifiers for their fields and methods using the public, private.

    $Worker[Person]:
     private:
      String name;
     public:
      int age;

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

Address/pointers

[!IMPORTANT] This Is section Is wrong and out of date.

The syntax for addressing is &Value, where Value is the expression that needs to be pointed to. For example:

-&x obtains a pointer to the variable x

-&a[i] obtains a pointer to the i-th element of the array a

-&f() obtains a pointer to the return value of the function f

References can be used like normal variables, except they cannot be nullified.

The syntax for creating references is Type& Name = Value, where Type is the type of the value, Name is the name of the reference, and Value is the expression that needs to be referred to. For example:

int& r = x creates an int reference named r that refers to x.

char& c = s[0] creates a char reference named c that refers to the first character of the string.

float& f = g() creates a float reference named f that refers to the return value of the function.

Here is an example of how addressing and references are used in UCode:

    int x = 10;

    int& r = x; //Creates an int reference named r that refers to x
    Console::Log(r); //Prints 10

    r = 30; //Modifies the value at r
    Console::Log(r); //Prints 30

Reassigning references

References can be reassigned by using an Address assignment statement. This changes what value the reference points to. For example:

    int v = 10; //Assigns 10 to v

    int& r = v; //Creates an int reference named r that refers to v
    
    Console::Log(r); //Prints 10

    int w = 5; //Assigns 5 to w
    
    r &= w; //Reassigns r to refer to w
    
    Console::Log(r); //Prints 5

Reassigning references should be done with caution, as it may cause unexpected behavior or errors if done incorrectly. For example:

    r &= bitcast<int&>(0); //Reassigns r to refer to a null pointer.
    
    Console::Log(r); //Prints garbage or causes an error

Reassigning references to nullptr or invalid memory addresses is not intended by UCode’s standard, as references are always assumed to be pointing to something valid.

If you need a nullable reference type, you can use Type? instead of Type&. Type? maps to optional, which is a wrapper type that can hold either a valid value or nothing (null). For example:

    int? n = []; //Creates an optional int named n

    Console::Log(n); //Prints nothing if null.

    n = 10; //Assigns 10 to n
    
    Console::Log(n); //Prints 10

    n = []; //Assigns null (nothing) back again 
    
    Console::Log(n); //Prints nothing

Casting

Casting is a way of converting a value from one type to another. Casting can be used to change the representation or interpretation of a value, such as converting a float to an int or an int to a pointer. Casting can also be used to perform explicit conversions that are not allowed implicitly, such as converting an int64 to an int8 or an uint16 to an int16.

The syntax for casting is Value -> Type, where Value is the expression that needs to be converted and Type is the desired type. For example:

3.14 -> int converts the float 3.14 to the int 3 65 -> char converts the int 65 to the char ‘A’ x -> uint8 converts the variable x to an uint8 Casting can have different effects depending on the types involved. For example:

Casting between numeric types can cause truncation, rounding, or overflow if the value does not fit in the target type. Casting between pointer types can change the address or size of the pointed object. Casting between signed and unsigned types can change the sign bit or the value range of the integer. Here is an example of how casting is used in UCode:

    float x = 1.23; //Assigns 1.23 to x
    int y = x -> int; //Casts x to int and assigns it to y
    Fmt::Print(y); //Prints 1

    char c = 'a'; //Assigns 'a' to c
    int z = c -> int; //Casts c to int and assigns it to z
    Fmt::Print(z); //Prints 97

    uintptr u = (uintptr) (x -> int&) -> uintptr; //Casts the address of x to uintptr and assigns it to u
    Fmt::Print(u);

Lambda

a lambda expression is an anonymous function that can contain either an expression or a sequence of statements.

a lambda looks like this

|[x,y,z] => [expression]

or like this

|[x,y,z] : [statement/statements]

an example of shown below

var MyLambdaObject = |[x,y] => x * y;//expression
    
var MyLambdaObject2 = |[x,y]:
    var Tep = x * y;
    ret Tep;
    ;//Starements

lambdas also have a short-form syntax. shown below

var MyLambdaObject = [x,y] => x * y;//expression

Lambda Capturing

Lambda will automatically Capture varables by value from the outer scope.

int a = 10;
int b = 10;
var LambdaObject = |[] => a * b;
//both a and b are captured by value.

a = 0;

var Value = LambdaObject();
//the Value will be 100 and not 0 because its captured by value on were it was declared.

Sometimes it is needed to capture by reference to do this you can explicitly say it captured by reference.

int a = 10;
int b = 10;


//b is captured by value
//a is captured reference.
var LambdaObject = |[](&a) => a * b;
    

a = 0;

var Value = LambdaObject();
//the Value will be 0 because its captured by reference.

also note you can put expressions in the capture list.

int a = 10;
int b = 10;

var LambdaObject = |[](&a) => a * b;

var LambdaObject2 = |[](int& a = a) => a * b;
                                
//both mean the same thing.
    

int a = 10;//outer scope 'a'
int b = 10;

var LambdaObject2 = |[](int& a = a) => a * b;
                                 ^ this 'a' is for capture

var LambdaObject2 = |[](int& a = a) => a * b;
                                     ^ is referring to the outer scope.
                                     

Note it is not possible to explicitly assigned the captures varable in the short-form syntax.

[!IMPORTANT]

Explicitly assigned Lambda Capturing has no implementation on the compiler yet.

Lambda inside Lambdas is not tested yet.

Constructors And Destructors

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

Traits

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

Parameter Packs

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

Conditional compilation

conditional compilation In UCode is allows a way of including or omitting selected lines of source code depending on constant expressions.

unlike languages like C UCode uses constant expressions to determine what to include and what to remove useing special keywords.

the special keywords are:

• $if
• $else
• $for
• Obj.$Varable/Obj.$Func()

The eval keyword is used to make constant expressions.

$if and $else

the special variant of the if keyword allows forces the check comparison do be an constant expression and does not generate symbols in the if block until evaluated.also the newly added symbols are in the same scope as the if.

for example:

    eval bool Mode = true; //constant expression varable 
  
    |Main[]:
     $if Mode:
      int A = 1;
     $else if true://constant else if
      int A = 2;
     $else:
      int A = 3;

     Console::Log(A);
   

after evaluating the code gets simplified into.

    |Main[]:
     int A = 1;
     Console::Log(A);

also works in file scope and namespace scope.

    eval bool Mode = true; //constant expression varable

    $if Mode:
     $CoolInt = uint32;
    $else
     $CoolInt = uint64;

after evaluating the code gets simplified into.

 
    $CoolInt = uint64;

$for

the special variant of the for keyword will unwap the list to their own scopes and is mostly used with parameter packs but can work with any object with constant expression for loop overload implementation.

note the list must also be a constant expression.

    |Func<X:...>[ParameterPack X]:
     $for [Item : X]:
      var ItemT = typeof(Item);
      bind(ItemT) Buffer = Item;
 
    |main[]:
     Func<int,uint32,uint64>(0,1,2);

after evaluating the code gets simplified into.

 
    |Func<int,uint32,int64>[int X1,uint32 X2,int64 X3]:

     |
      var ItemT = typeof(X1);
      bind(ItemT) Buffer = X1;
     |

     |
      var ItemT = typeof(X2);
      bind(ItemT) Buffer = X2;
     |

     |
      var ItemT = typeof(X3);
      bind(ItemT) Buffer = X3;
     |

Obj.$Varable/Obj.$Func()

The special variant of the object member access allows to use Varable instead of a constant literal.

for example:

    eval char[\] MemberName = "X";
    $Vec2:
     int X;
     int Y;
  
    |Main[]:
     Vec2 Vec = Vec2();
     Vec.$MemberName = 1;
   

after evaluating the code gets simplified into.

    $Vec2:
     int X;
     int Y;
  
    |Main[]:
     Vec.X = 1;
   

this alows for simpler serialization and Deserialization and gives more tools for reduceing boilerplate.

-Note the special object member access must be a static char Array constant expression.

-Also using this allows for accessing operator overloading Funcions pointers or Funcions with keywords in them like new or drop.

for example:

    
    $Vec2:
     int X;
     int Y;
     |+[this&,this& Other] -> Vec2;

    eval char[\] MemberName = "+";
    $ItemFuncPointer = [Vec2&,Vec2&] -> Vec2;

    |Main[]:
     Vec2 Vec = Vec2();
     Vec2 OtherVec = Vec2();
     ItemFuncPointer Pointer = Vec2::$MemberName;

     //Calls Vec2::+[Vec2&,Vec2& Other] -> Vec2;
     Vec2 Value = Pointer(Vec,OtherVec);
     
   

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

NameSpaces

A allows scope to the Class,types,funcions in a scope to organize code.

A NameSpace can be use like so.

    MyNameSpace:
     $VeryColorClass:
      int X;
      int Y;

The Class can be accessed by useing '::'.

    MyNameSpace:
     $VeryColorClass:
      int X;
      int Y;

    |main[]:
     MyNameSpace::VeryColorClass Myclass = [];

NameSpace's can be also be Scoped like so.

    MyNameSpace::EvenCoolorNameSpace:
     $VeryColorClass:
      int X;
      int Y;

NameSpaces can only be used at the File or NameSpace Scope.

Name convention

Pascal case is a naming convention that is preferred by UCode’s standard for naming types, functions, and constants. Pascal case means that every word in the name starts with a capital letter and there are no separators between words. For example:

SomeType is a type name in Pascal case DoSomething is a function name in Pascal case PI is a constant name in Pascal case Pascal case makes the names easy to read and distinguish from other naming conventions. It also helps to avoid conflicts with keywords or built-in types that are usually lowercase. For example:

int is a keyword and a built-in type Int is a user-defined type in Pascal case Pascal case should be used consistently throughout the code to maintain clarity and readability. Here is an example of how Pascal case is used in UCode:

    //A user-defined type that represents a point
    $Point: 
     int X;
     int Y;


      //A function that takes two points and returns their distance
      $Distance[Point p1, Point p2]:
        return Math::Sqrt(
      (p1.X - p2.X)+(p1.X - p2.X) 
    + (p1.Y - p2.Y)+ (p1.Y - p2.Y)
    );


    //A constant that holds the value of pi
    umut float PI = 3.14159;

    //Creating two points and printing their distance



    Point origin = [0, 0]; //Assigns 0 to both X and Y fields
    Point target = [3, 4]; 
    //Assigns 3 to X and 4 to Y fields

    Console::Log(Distance(origin, target)); //Prints 5

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Array(Standardlibrary/Containers)

Not to be confused with AddressArray and NativeArrays.

The Array Type is a fixed-size collection of data items stored in contiguous memory with added safety features unlike NativeArrays.

The Array type Can be used like so.

int[10] Items;
Array<int,(10)> Items2;

Both being equivalent.

All the values in the array are stored on the stack as the size of the array is known at compile time.

Arrays mainly are used if you know how many elements you will need at compile time as thay are faster then Vectors in most cases.

int[] Items;
Items.Resize(3);//The Size Known at Compile Time.

Items[0] = 10;
Items[1] = 20;
Items[2] = Items[1];

Useing an array;

int[3] Items;

Items[0] = 10;
Items[1] = 20;
Items[2] = Items[1];

Member functions

Inherited traits

Notes

The array type will always be the size of it elements it will use the generic constant expression to get the size.

Vector<T>(Standardlibrary/Containers)

Not to be confused with Vec2 and Vec3.

The Vector Type is dynamically resizeable collection of data items stored in contiguous memory.

The Vector type Can be used like so.

int[] Items;
Vector<int> Items2;

Both being equivalent.

Vector are dynamic so your able to add elements at runtime.

int[] Items;
Items.Push(5);
Items.Push(10);
Items.Push(30);


Fmt::Print(Items[0]); \\ 5
Fmt::Print(Items[1]); \\ 10
Fmt::Print(Items[2]); \\ 30


Fmt::Print(Items.Size()); \\ 3

Vector can also be can be initialized with starting elements.

int[] Items = [10,20,30];

Fmt::Print(Items[0]); \\ 5
Fmt::Print(Items[1]); \\ 10
Fmt::Print(Items[2]); \\ 30

Fmt::Print(Items.Size()); \\ 3

Member functions

Inherited traits

Notes

String_t(Standardlibrary/Containers)

Not to be confused with StringSpan. The String Type is used represent sequences of characters.

The String type Can be used like so.

String_t<char> mystr = "Hello World";

UCodeLang has many different char types which explains why the type is generic.

String_t<char> mystr = "Hello World";
String_t<uft8> mystr = "Hello World";
String_t<uft16> mystr = "Hello World";
String_t<uft32> mystr = "Hello World";

Most of type the you will be useing the alies String,String8,String16,String32. Instead of directly instantiating the type.

String mystr = "Hello World";
String8 mystr = "Hello World";
String16 mystr = "Hello World";
String32 mystr = "Hello World";

like most other languages you can concatenate strings togeter.

String mystr = "Hello";
mystr += " World";

Fmt::Print(mystr);

Member Aliases

$StrSpan = StringSpan_t<T>;

Member functions

Inherited traits

Notes

Be aware that string literals like "hello" are StringSpans

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

String(Standardlibrary/Alias)

A String that contains ASCII characters.

$String = String_t<char>;

See String_t<T> for Member funcions and examples.

StringSpan(Standardlibrary/Type)

A Type Reference to a String that contains ASCII characters.

$StringSpan = String_t<char>;

See StringSpan<T> for Member funcions and examples.

String8(Standardlibrary/Alias)

A String that contains uft8 characters.

$String8 = String_t<utf8>;

See String_t for Member funcions and examples.

String8Span(Standardlibrary/Type)

A Type Reference to a String that contains uft8 characters.

$String16Span = String_t<uft8>;

See StringSpan<T> for Member funcions and examples.

String16(Standardlibrary/Alias)

A String that contains uft16 characters.

$String16 = String_t<utf8>;

See String_t<T> for Member funcions and examples.

String16Span(Standardlibrary/Type)

A Type Reference to a String that contains uft16 characters.

$String16Span = String_t<uft16>;

See StringSpan<T> for Member funcions and examples.

String32(Standardlibrary/Alias)

A String that contains uft32 characters.

$String32 = String_t<utf32>;

See String_t<T> for Member funcions and examples.

String32Span(Standardlibrary/Type)

A Type Reference to a String that contains uft32 characters.

$String16Span = String_t<uft32>;

See StringSpan<T> for Member funcions and examples.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

StringBuffer_t(Standardlibrary/ReferenceTypes)

Span(Standardlibrary/Type/Generic)

[!IMPORTANT] This Is section Is incomplete.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Math(Standardlibrary/Math)

Provides funcions for trigonometric, logarithmic, and other common mathematical functions.

|main[]:
 
 Fmt::Print(Math::PI);//~3.14 
 
 Fmt::Print(Math::Abs(-1.5));//1.5

 Fmt::Print(Math::Min(4.2,8.5));//4.2

Member functions

Notes

This Class is base on the C# Math Class

Vec2(Standardlibrary/Math)

A Vec2 that uses the float type.

$Vec2 = Vec2_t<float>;

See Vec2_t<T> for Member funcions and examples.

Vec3(Standardlibrary/Math)

A Vec3 that uses the float type.

$Vec3 = Vec3_t<float>;

See Vec3i_t<T> for Member funcions and examples.

Vec2i(Standardlibrary/Math)

A Vec2i that uses the int type.

$Vec2i = Vec2i_t<int>;

See Vec2i_t<T> for Member funcions and examples.

Vec3i(Standardlibrary/Math)

A Vec3i that uses the int type.

$Vec3i = Vec3i_t<int>;

See Vec3i_t<T> for Member funcions and examples.

Vec2_t(Standardlibrary/Math)

Not to be confused with Vector.

Vec2_t is the base type of a mathematical vector with an x and y value.

Vec2_t<float> pos = [5,4];
pos += [10,5];
Fmt::Print(pos);// [X:15,Y:9]

Vec2_t is mostly used for position,size and rotation others things that need an x and y value.

Fields functions

$Vec2_t<T>:
 T X;
 T Y;

Member functions

Vec3_t(Standardlibrary/Math)

Not to be confused with Vector.

Vec2i_t is the base type of a mathematical vector with an x and y value.

Vec3_t<float> pos = [5,4,0];
pos += [10,5,3];
Fmt::Print(pos);// [X:15,Y:9,Z:3]

Vec2i_t is mostly used for position,size and rotation others things that need an x and y value.

Fields functions

$Vec3_t<T>:
 T X;
 T Y;
 T Z;

Member functions

Vec2i_t(Standardlibrary/Math)

Not to be confused with Vector.

Vec2i_t is the base type of a mathematical vector with an x and y value.

Vec2i_t<int> pos = [5,4];
pos += [10,5];
Fmt::Print(pos);// [X:15,Y:9]

Vec2i_t is mostly used for position,size and rotation others things that need an x and y value.

Fields functions

$Vec2i_t<T>:
 T X;
 T Y;

Member functions

Vec3i_t(Standardlibrary/Math)

Not to be confused with Vector.

Vec3i_t is the base type of a mathematical vector with an x and y value.

Vec3i_t<float> pos = [5,4,0];
pos += [10,5,3];
Fmt::Print(pos);// [X:15,Y:9,Z:3]

Vec3i_t is mostly used for position,size and rotation others things that need an x and y value.

Fields functions

$Vec3i_t<T>:
 T X;
 T Y;
 T Z;

Member functions

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Optional<T>(Standardlibrary/ErrorHandleing)

Optional is a type that is part of the standard library. that can hold either a value of type T or nothing (Null).

The Optional type Can be used like so.

int? MayBeNull = Null;
Optional<int> MayBeNull2 = Null;

Both being equivalent.

The Optional is an enum and here its implementation.

$Optional<T>:
 Opt(T opt),
 Null

The Optional type allows you to have

• Optional struct fields
• Optional function arguments
• Nullable pointers
• default values

|divide[float numerator,float denominator] -> float?:
  if denominator == 0:
    ret Null;
  else:
    ret Opt(numerator / denominator);

|main[]:
  var result = divide(2.0, 3.0);
 
  match result:
    Opt(out x):Fmt::Print("Result: {x}"),
    Null:Fmt::Print("Cannot divide by 0"),

Question Mark Operator,

The question mark operator, ? allows for easier use of the optional type.

It lets.

|AddLastNumbers[int[]& stack] -> int?:
    var a = stack.Pop();
    var b = stack.Pop();

    if Opt(a,out vala) && Opt(b,out valb):
      ret Opt(vala + valb);

    ret Null;

To become.

|AddLastNumbers[int[]& stack] -> int?:
  ret Opt((?stack.Pop()) + (?stack.Pop()))

When starting an expression with ? UCodeLang will check if its Null and will do an early return if it is.

makeing your life easier.

Notes

All Examples is taken from Rust as UCodeLang was directly inspired by the Rust Programming Language.

Result<T>(Standardlibrary/ErrorHandleing)

Result is a type that is part of the standard library. that can hold either a value of type T or an error(Null).

The Result type Can be used like so.

$MyErrorType;
int!MyErrorType MayHaveError = Null;
Result<int,Result> MayHaveError = Null;

Both being equivalent.

The Result is an enum and here its implementation.

$Result<T,E>:
 Val(T val),
 Err(E err),

The Result type allows you to returning Error in a safe way and predictable.

Question Mark Operator,

The question mark operator, ? allows for easier use of the result type.

It lets.

|test[] -> Empty!OpenFileError:
 var fileop = File::Open("somefile.txt");
 if Val(fileop,out openedfile):
   openedfile.Write("Hello");
   ret Val(Empty());
 else if Err(fileop,out err):
   ret err; 

To become.

|test[] -> Empty!OpenFileError:
  var tep = (?File::Open("somefile.txt")).Write("Hello");
  ret Emtpy()

When starting an expression with ? UCodeLang will check if its an Error and will do an early return if it is.

makeing your life easier.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Unique_ptr<T>(Standardlibrary/Memory)

A Unique_ptr is class that owns an object and free of that object when the unique_ptr goes out of scope.

int^ obj = unq int(10);
Unique_ptr<int> obj = Unique_ptr<int>::Make(10);

Both being equivalent.

Member functions

Shared_ptr(Standardlibrary/Memory)

A Shared_ptr is class that can share ownership of an object.useing reference counting to free the resource.

int$ obj = shr int(10);
Shared_ptr<int> obj = Shared_ptr<int>::Make(10);

Both being equivalent.

Member functions

LowLevel(Standardlibrary/Memory)

LowLevel is Class that Provides Low Level memory operations and functions like in languages like C or C++.

unsafe:
  VoidPtr p = LowLevel::Malloc(4);

  int& nump = bitcast<int&>(p);
  nump = 10;

  LowLevel::Free(p);

Member functions

Notes

currently in the compiler it is unable to see these funcion like Malloc,Free Realloc to those specific IR instructions.meaning the compilers unable to optimize it as it just see the function as external calls.

Some Descrptions here are from en.cppreference.com

Ptr(Standardlibrary/Memory)

Ptr is Class that give the same pointer semantics like in C like languages avoiding automatic dereferencing and makes reassigning trivial.

int num = 10;

Ptr<int> val = ptr(num);

val.Write(20);

Fmt::Print(num); // 20

int num2 = 4;
val = ptr(num2);

Fmt::Print(val.Get()); // 4 

External functions

Member functions

Notes

Ptr will always the size of a pointer.

Ptr(Standardlibrary/VoidPtr)

A type that represents a void pointer like in c or c++.

$VoidPtr = Ptr<Empty>;
$Ptr<void> = VoidPtr;//generic specialization

See Ptr<T> for Member funcions and examples.

Ptr(Standardlibrary/VoidPtr)

A type that represents a void pointer like in c or c++.

$VoidPtr = Ptr<Empty>;
$Ptr<void> = VoidPtr;//generic specialization

See Ptr<T> for Member funcions and examples.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

File(Standardlibrary/IO/File)

The File Type allows for opening files,reading and writing files.

var file = ?File::Open("my.txt");

File Open functions

File Read String functions

File Read Bytes functions

File Write String functions

File Write Bytes functions

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Atomic(Standardlibrary/Threading)

AtomicShared_ptr(Standardlibrary/Threading)

Thread(Standardlibrary/Threading)

Standardlibrary Types

The Standard library is intended to be the list of usefull types and funcions that most GameDevs May need.

All of the Standardlibrary is Under The ULang Namespace.

use ULang;

All of the Standardlibrary Part of StandardLibarary Module By UCodeLang.

import UCodeLang::StandardLibarary[0:0:0];

Containers

Alias Types

ReferenceTypes

Math Types

Error Handleing

Memory

Input/Output System

Input/Output File

Input/Output Networking

Input/Output Serialization

Miscellaneous

Notes

Under the hood the Standardlibrary uses NStandardlibrary API module to do operating system calls.

Empty(Standardlibrary/Miscellaneous)

Empty is a type that an empty type.it's mainly used as a placeholder or when the type is not important.

$Empty;

Any(Standardlibrary/Miscellaneous)

Buffer_t(Standardlibrary/Miscellaneous)

StringBuffer_t(Standardlibrary/Miscellaneous)

Range_t

RangeFrom_t

RangeTo_t

RangeFull_t

RangeInclusive_t

RangeToInclusive_t

Range_t

RangeFrom_t

RangeTo_t

RangeFull_t

RangeInclusive_t

RangeToInclusive_t

Range_t

RangeFrom_t

RangeTo_t

RangeFull_t

RangeInclusive_t

RangeToInclusive_t

Range_t

RangeFrom_t

RangeTo_t

RangeFull_t

RangeInclusive_t

RangeToInclusive_t

Range_t

RangeFrom_t

RangeTo_t

RangeFull_t

RangeInclusive_t

RangeToInclusive_t

Range_t

RangeFrom_t

RangeTo_t

RangeFull_t

RangeInclusive_t

RangeToInclusive_t

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

bool

bool is used to represent a true or false value.

bool boolT = true;
bool boolF = false;

The bool type is the type used in if statements,while,for and do.

if true:
 Fmt::Print("Im True");

while true:
 Fmt::Print("I Loop forever");

char

The char keyword is used to represent an ASCII character and be used like so.

char MyLetter = 'A';

The type char can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf8

The char keyword is used to represent an utf8 character and be used like so.

utf8 MyLetter = 'A';

The type can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf16

The char keyword is used to represent an utf16 character and be used like so.

utf16 MyLetter = 'A';

The type can be cast to and from an uint16 to get the raw number value.

utf32

The char keyword is used to represent an utf32 character and be used like so.

utf32 MyLetter = 'A';

The type can be cast to and from an uint32 to get the raw number value.

char

The char keyword is used to represent an ASCII character and be used like so.

char MyLetter = 'A';

The type char can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf8

The char keyword is used to represent an utf8 character and be used like so.

utf8 MyLetter = 'A';

The type can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf16

The char keyword is used to represent an utf16 character and be used like so.

utf16 MyLetter = 'A';

The type can be cast to and from an uint16 to get the raw number value.

utf32

The char keyword is used to represent an utf32 character and be used like so.

utf32 MyLetter = 'A';

The type can be cast to and from an uint32 to get the raw number value.

char

The char keyword is used to represent an ASCII character and be used like so.

char MyLetter = 'A';

The type char can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf8

The char keyword is used to represent an utf8 character and be used like so.

utf8 MyLetter = 'A';

The type can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf16

The char keyword is used to represent an utf16 character and be used like so.

utf16 MyLetter = 'A';

The type can be cast to and from an uint16 to get the raw number value.

utf32

The char keyword is used to represent an utf32 character and be used like so.

utf32 MyLetter = 'A';

The type can be cast to and from an uint32 to get the raw number value.

char

The char keyword is used to represent an ASCII character and be used like so.

char MyLetter = 'A';

The type char can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf8

The char keyword is used to represent an utf8 character and be used like so.

utf8 MyLetter = 'A';

The type can be cast to and from an uint8 to get the raw number value.

uint8 MyLetter = 'A' -> uint8;//65
byte MyLetter2 = 'A' -> byte;//65

utf16

The char keyword is used to represent an utf16 character and be used like so.

utf16 MyLetter = 'A';

The type can be cast to and from an uint16 to get the raw number value.

utf32

The char keyword is used to represent an utf32 character and be used like so.

utf32 MyLetter = 'A';

The type can be cast to and from an uint32 to get the raw number value.

float

floats types are used for floating-point values. Floating-point numbers are used for decimal values.

float A = 0.5;
float32 B = 0.5;

float32

The float32 keyword maps to float.

float32 can be casted to int32 and float64 and vice versa.

float64

float64 is the same as float but gives you 15 decimal digits precision but uses more space in memory.

float

floats types are used for floating-point values. Floating-point numbers are used for decimal values.

float A = 0.5;
float32 B = 0.5;

float32

The float32 keyword maps to float.

float32 can be casted to int32 and float64 and vice versa.

float64

float64 is the same as float but gives you 15 decimal digits precision but uses more space in memory.

float

floats types are used for floating-point values. Floating-point numbers are used for decimal values.

float A = 0.5;
float32 B = 0.5;

float32

The float32 keyword maps to float.

float32 can be casted to int32 and float64 and vice versa.

float64

float64 is the same as float but gives you 15 decimal digits precision but uses more space in memory.

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

This(KeyWord)

The 'this' is a keyword that refers to the this parameter.

It is a address that points to the object of the class of which the member function is called.

$Item:
   int Hp;
     
   |DoDamage[this&]:
    this.Hp = 10;
   
    Hp = 10;//does the same as above

    int V = this.Hp;
    
    int V2 = this.Hp;//does the same as above

The this keyword can also be used to be an alias current class type.

$BigTree:
  int Hp;
  |AddBoth[umut this&,umut this& Other] -> BigTree:
     ret [this.Hp + Other.Hp];

becomes

  $BigTree:
    int Hp;
    |AddBoth[umut BigTree,umut BigTree& Other] -> Item:
     ret [this.Hp + Other.Hp];

reflection types(keywords)

Reflection types are the showed below all are keywords that can not be used at runtime.

• typeinfo : has Data about types
• classinfo : has Data about Classes
• enuminfo : has Data about Enums
• aliasinfo : has Data about alias
• traitinfo : has Data about traits

Note all functions and members are implemented internally by the compiler.

typeinfo

Can be accessed by useing type or typeof keywords.

it can be used also be used as a type by useing the bind keyword.

It has has the following functions.

$typeinfo:
     
  //Get the Name of the type.
  |Name[this&] -> char[\];

  //Get the Full Name of the type.
  |FullName[this&] -> char[\];
   
  //Get the TypeID
  |TypeID[this&] -> uintptr;
      
  //if it's an Address. Ex:T&
  |IsAddress[this&] -> bool;

  //if it's an AddressArray.  Ex:T[&]
  |IsAddressArray[this&] -> bool;

  //if it's an immutable.  Ex: umut T
  |IsImmutable[this&] -> bool;

  //if it's an Dynamic.  Ex: dynamic<T>
  |IsDynamic[this&] -> bool;

  //if it's an Moved.  Ex: moved T
    |IsMoved[this&] -> bool;

    // try get the Class info.
    |GetClassInfo[this&,out classinfo Info] -> bool;

    // try get the Enum info.
    |GetEnumInfo[this&,out enuminfo Info] -> bool;
  

classinfo

It has has the following functions.

    

    $classinfo:
     $fieldinfo:
      
      //Get the Name of Field.
      |Name[this&] -> umut char[&];
      
      //Get the type of Field.
      |GetType[this&] -> typeinfo;
      
      //Get the byte offset.
      |Offset[this&] -> uintptr;

    //Get the Fields of the Class.
    |Fields[this&] -> fieldinfo[\];

enuminfo

It has has the following functions.

    

    $enuminfo:
     $fieldinfo:
      
      //Get the Name of EnumField.
      |Name[this&] -> char[/];
      
      //Get the Value of the EnumField.
      //The Type is the Enum basetype.
      |Value[this&] -> var;
      
      //Gets the type of the Variant if it is one.
      |TryGetVariant[this&,out typeinfo info] -> bool;
     $variantinfo:


    //Get the Base Type of the enum.
    |BaseType[this&] -> typeinfo;

    //Get the Fields of the enum.
    |Fields[this&] -> fieldinfo[\];


    //Gets the type of the Union of the Variant if it is one.
    |TryGetVariantUnion[this&,out variantinfo info] -> bool;

var(Keyword)

In UCode, the auto keyword is used to specify that the variable’s data type will automatically be deducted from its initializer.

The compiler decides the data type for a variable by looking at its initialization.

    var num = 10;//The data type is int32

    var Str = "Hello World";//The data type is umut char[&]

This can also be done partially.

    int A = 10;
    var& B = A;//type will be come int&

lastly be used as function return.

    |Func[] -> var:
     ret 10;

    //Func will be int32
 

note the compiler will the first return statement it finds as the function return.

    |Func[] -> var:
     if true:
      ret true;
     else:
      ret 0;

    //Func return type will be bool can and throw an error because int32 cant be implicitly convertible as bool.
 

note the compiler prefers returning by Value and not by address.

the two Funcs may look the same but have very different results.may cause subtle bugs if not observant.

    |Func[] -> var:
     static V;
     ret V;
 

    |Func[] -> var&:
     static V;
     ret V;
 

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

int(Type)

uintptr

intptr

byte

uint8

uint16

uint32

uint64

int8

int16

int32

int64

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

Enum(KeyWord)

Enums are a data type that assigns symbolic names to a set of constant expression values. For example:

$PrimaryColors enum:
  Red,
  Green,
  Blue,

The base type of an enum is an byte by default, unless specified otherwise:

$PrimaryColors[int] enum:
  Red,
  Green,
  Blue,

The value of each enum field is determined by the default value of the base type and the ‘++’ operator is use if the not specifyed.:

$PrimaryColors[int] enum:
  Red ,//the default value of int is 0. 
  Green,//Red + 1 = 1
  Blue,//Green + 1 = 2

You can also specify the value of an enum field with any other constant expression:

$PrimaryColors_t = int;

$PrimaryColors[PrimaryColors_t] enum:
    Red = 5,//5
    Green = 5 / 10,//2
    Blue = 10 * (Green -> PrimaryColors_t),//20

Enum Variant

Enum Variants are Keys to maped Data.

$FireData;
$IceData;
$PowerUp enum:
  None,
  Fire[FireData],
  Ice[IceData],
  Damage[int Dmg],
  Speed[int MaxSpeed,int acceleration],

Then Can be used like this.

|main[]:
  PowerUp nonePower =  PowerUp::None;
  PowerUp speedPower = PowerUp::Speed(5,5);
                                       //^set values
    
  if PowerUp::Speed(speedPower,out Speed,out acceleration):
    int NewMaxSpeed =Speed; 

You must the pass the enum with out values to get the value to get the stored value in the Enum.

note it's not possible to get the stored enum without a conditional statement such as a if,else if,while,do,match.

Enum specification

Enum Variants are compiled down to classes and Unions showed below in its IR representation.

$FireData;
$IceData;
$PowerUp enum:
  None,
  Fire[FireData],
  Ice[IceData],
  Damage[int Dmg],
  Speed[int MaxSpeed,int acceleration],
    

//As IR form
    
$FireData;
$IceData; $PowerUp_Speed_type:
  int MaxSpeed;
  int acceleration;

$PowerUp_union union:
    //none has no type associated so its uneeded.
    FireData Item_1;//Fire
    
    IceData Item_2;//Ice
    
    int Item_3;// Damage
  
    PowerUp_Speed_type Item_4;// Speed

$PowerUpClass:
  uint8 EnumKey;
  PowerUp_union union;

Enum Variants Destructors are a list if chans.

checking its Key With the field Key and calling its Destructor.the same idea applies to copy Constructors, move Constructors, copy assignments, and move assignments.

dynamic

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

new(keyword)

new calls a request for memory allocation and returns the Address

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

drop(keyword)

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

unsafe

bitcast<T>(keyword)

Converts a ptr into an other pointer or an uintptr.

|main[]:
  int& NullPtr = bitcast<int&>(0);
  
  uintptr PtrAsNumber = unsafe bitcast<uintptr>(NullPtr);

[!IMPORTANT] This Is section Is incomplete

This can cause undefined Behavior.

shr(keyword)

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

unq

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

thread

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

thread

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

eval(KeyWord)

The eval KeyWord works the same as constexpr KeyWord in c++.It tells the compiler evaluate the value of the function or variable at compile time.with no cost at runtime as there no IR Made for it.unlike static variables.

 eval int SomeValue = 5;
 eval Item = SomeValue * 10;

|main[this&]:
 int Value = 50;

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

compiler(Keyword)

Is a type that refers to systematic analysis part of the compiler. systematic analysis is are were symbols and types are checked.

it is used the make new symbols,type,funcions. and can used to read compiler data and Settings.

bool onwindows = compiler::IsBackendWindows();

Methods

[!IMPORTANT]

GetFlagValue and HasFlag is not implemented in the compiler right now.

invalid(keyword)

the invalid keyword is the compile time variant of the Panic keyword

the invalid keyword will cause an Error at compile time when the compiler evaluates the statement.

for example:

|main[] -> void:
  invalid("Error cant find the main implementation.");

the compiler will output the Error:

on line (Invaild keyword line number) invalid: "Error cant find the main implementation."

also works with vaild keyword as it makes an error.

invalid can take in the parameters

• Span<char> or StringView //constant expression a span of chars.

• String //constant expression string

• 0 parameters will out put the Error instead "Reached Invaild Statemet"

type/typeof/bind(keyword)

the type keyword allows for

• obtaining type info
• comparing types
• binding types

obtaining type info

to obtain type info can be done by

|main[] -> void:
 BoolType B = type(bool);
 var TypeInfo = typeof(B);

Note typeof is for expressions and will not will never execute the code at runtime.

Use cases can be found on type info.

comparing types

Comparing types can be done below

|main[] -> void:
 var AreTheSameType = type(bool == int);

when comparing types it will return a constant expression Boolean.

here's the list of valid operators.

• == : will will directly compare the two types and will return true if exactly the same and false otherwise.

• != will will directly compare the two types and will return false if exactly the same and true otherwise.

• ~= will will approximately compared the types works the same as == but will be also true if the following is true.

  -if right side is the base type left of Ex: type(int ~= uint_t) is true. including traits.

binding types

using the bind keyword allows to convert type info to a type declaration.

|main[] -> void:
 var BoolType = type(bool);
 bind(BoolType) Item = true;

valid(keyword)

the valid keyword is an expression that returns a constant expression bool.

the keyword will check if an expression or statements will throw an compile time error.

for example:

        |main[] -> void:
         bool DoesFuncExist = valid(:Func();); 
         $if DoesFuncExist:
          Console::Log("found func");

the varable "DoesFuncExist" is false because the compiler will detect that Func cant be found in the scope.

[!NOTE] The valid keyword only checks the statement or expression.the statement or expression will never execute the code at runtime.

Keywords

Keywords are reserved identifiers that have special meanings to the compiler. They can't be used as identifiers in your program

this article lists keywords.

Built-in Types

All keywords that can be used as a type.

type keywords

All keywords that can be used to make a type. | Keyword | short Description |--- | --- | enum | a group of constants trait | shareing behavior between types tag | add information about functions and classes dynamic | dynamically dispatched traits

memory keyword

All keywords that can that deals with memory. | Keyword | short Description |--- | --- | new | allocate memory drop | free memory. unsafe | lets you do unsafe operations. bitcast | reinterpret the bytes of a type. shr | make a shared pointer. unq | make a unique pointer.

varable types keywords

All keywords that can that deals changes how a varable works. | Keyword | short Description |--- | --- | static | global variables thread | global variables but one per thread. eval | compile time constant expression.

Compile Time Keywords

All keywords that can that lets you do stuff at compile time.

miscellaneous keywords

All keywords that dont fit in the other categories.

for(KeyWord)

The for KeyWord can be used to make a loop or to loop for a list for items.

traditional for loop

a traditional for loop looks like this and works the same way as in C.

for [var Item = 0;Item < 10;Item++]:
  Fmt::Print(Item);

this will Log 1,2,3,4,5,6,7,8,9 and 10.

modern for loops

a modern for loop can be used to loop over a list for Items and can be overloaded.As showed below.

$LoopAbleObject:
  $LoopObject:   
   LoopAbleObject& _List;
   uintptr I = 0;
     
   //new loop
   |new[this&,LoopAbleObject& List]:
    _List &= List;

    //Check Value
    |?[this&] => I < _List.Size(); 


    //Get Value and MoveNext   
    |->[this&]:
      var& Item = _List._Buffer[I];
      I++;
      ret Item;

    //loop ended
    |drop[this&] -> void;
    //

  int[\3] _Buffer;
  |Size[this&] => 3;
     
  //overload
  |for[this&] => LoopObject(this); 

     

modern for int loops

modern for int loops can be showed below.

for [var I : 0..10]:
  DoSomeThing();
  

This will Call DoSomeThing 10 times.

here's its equivalent code.

for [var Item = 0;Item < 10;Item++]:
  DoSomeThing();

it also was its reverse variant.

for [var I : (0..10).Reverse()]:
  DoSomeThing();
  

here's its equivalent code.

for [var Item = 10;Item != (0-1);Item--]:
  DoSomeThing();

import(Keyword)

This keyword may get removed.

out(keyword)

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

panic(keyword)

[!IMPORTANT] This Is section Is incomplete but is implemented in the compiler.

use(keyword)