deforestt / aflat Goto Github PK

We need to create a mode that links the system malloc rather than any of the fun home-brewed stuff that we are used to. It should look like this in the aflat.cfg

set compatible 

it should link to a secondary {std file} file that does define any memory operations. Any secondary functions that are dependent on the specific memory function implementations should simply panic that they cannot be used in Compatibility Mode. the Function <function-name> is not supported in compatibility mode. Aborting. When compatibility mode is active, it will allow aflat to play nicely with the c standard library.

We will be migrating from make to CMake for better dependency control.

Overload functions should be allowed via name mangling. The first function should have the standard name functionName The subsequent functions should have the argument types prepended with dashes. functionName-int-adr-...

Get the code less repetitive and more readable.

A structure will define a list of dataTypes that make it up.
structures will be defined like so:
struct person {
char 20 firstName;
char age;
char 20 lastName;
int age;
};

when instantiated, the compiler should create a contiguous block of memory to hold the data.

A function should be able to be decorated with a class the same way that it can be decorated with another function. It should look like this.

class Decorator {
     adr foo = foo;
     Decorator init(adr foo){
          return my;
     };
     
    int run(adr args) {
         return my.foo(args);
     };
};

int decorated(adr args) : Decorator {
     return 0;
};

The decorator should create a dynamic const Object with the decorator passed into the constructor

Add a library to process command line args

If a classes constructor takes only one argument, the AFlat compiler should be able to implicitly create an instance of the expected type.

for example

printString("Test String") -> printString(String("Test String"));

Add gdb debug symbols to output when in debug mode

enums should work like in c, they should just be fancy constants. They should require a dot though we like to be explicit here.

enum colors { red, green, blue };

...
io.printInt(colors.red)

this should return 0;

Enums should be exportable or and importable classes.

The string overload '==' should compare two string types

Floats do not behave correctly when certain functions are called. Need to investigate this. maybe the float registers have been muddied somewhere?

Library build script should be included in install script

Function signatures should be hoisted to the top of their scope.
This needs to happen after parsing in the lowering stage so that the function can be used throughout code generation.

There should be a new type called generic which is an adr, that cannot be implicitly cast.

We will implement catch2 testing framework