The jet from matt-attack

Optimize ResolveDependencies()

Part of the implementation of #19
Currently loads and parses the "db" for each project, could cache this at least for the lookups of one project.

Allow casting to/constructing of array type

Currently there is no way to instantiate an array type without also allocating an array. Perhaps allow user to instantiate on the stack a [] object and assign to it manually.

let int[] arr;
arr.size = 5;
arr.ptr = <int*>malloc(5*4);

More complex syntax could also be allowed which lets the user construct it like any other object.

let arr = int[](5, <int*>malloc(5*4));

Add option for safe array access in debug

Since the size of an array type is always known, could insert a bounds check in debug mode or when a flag is used.

Correctly Handle Floats vs Double Constants

Currently everything is just a double. Need to handle floats with an f at at the end

Make basic error handling function similar to panic()

Should catch crashes or be used in libraries to indicate problems. Would be nice if it could print a callstack out to the user so they arent completely in the dark if something goes wrong.

Chaining function calls tends to fail.

For instance, in the Vector test project, tt.GetEnumerator().Test() fails with an error about tt being undefined.

On Linux No Debug Symbols Appear to be Output

For some reason debug information is nowhere to be found in output executables or at the very least GDB cannot find it. Need to fix this on Linux.

Allow dynamically sized array types to be stored as member variables in a class

This could be an issue with the circular dependency checker

Add version option to project files

required for #19 eventually

Just add a new option in project files to accept a version string that will be stored alongside the package name and location in the central database later.

Some tokens being lost from original when printing out tree.

Convert everything to use Tokens rather than strings and store all tokens. This is done for many cases, but some are still left.

Local Project Management

Enable finding of projects stored throughout your computer. Based on idea from #18

Implementation of this would involve storing a list of projects built and their locations in a central location on the computer for the compiler to be able to find when searching for dependencies.
Currently, dependencies are specified as a path relative to the project requiring them. This will have to be changed somewhat. The initial idea is to search for projects in this list if no path delimiter is specified (/) and allow for a required version to be added after the project name.

Exact details on the version system and how to handle duplicates will have to be figured out in following issues. The main goal of this issue is the central database and being able to find packages with no version resolution.

Package manager

Because nobody likes managing their own packages

Make building instructions for the compiler

Merge .jlib file and .a file

Currently compilation output is in the form of two separate files, a .a archive with all the .o files and a .jlib with all the language specific metadata.

add typedef like expression

Proposed syntax is "using NewType = OtherType;"

Compiler needs to recompile projects if a dependency changed.

Determine how to name projects

Currently the project management system uses the name you supplied to build the library, not the folder name or something hardcoded. Perhaps this would be good to add to the project file for consistency.

This is causing things to fail because of capitalization mismatches. (JetCore vs jetcore)

Bool Types Casting

Allow implicit casting of 0 and 1 to bool. Perhaps consider allowing values above 1 to cast to bool through a comparison. But a bool should ONLY be equal to zero or one.

Remove size from array type

Array size member of Type is no longer used as it was shared between all usages of the type and led to issues. Need to remove it and all remaining uses of it.

Future addition could be adding a new place for this size to help with the compiler making smarter decisions and to give better hints to the user.

Make the compiler return structs normally if they are below a certain size.

Currently structs are all returned by passing a pointer to the return value as one of the arguments. This doesnt always give a gain, especially for small structs on the order of the size of a double.

Improve and finish up lambdas

Currently they have a fixed max capture size of 64 bytes. Need to start by making this an error condition then make it dynamically allocate for larger.
Also need to include the function type somewhere so it works properly.

Correctly handle Int constant sizes

Currently every integer constant is a int32, need to make it use a large enough one to fit and error if it gets cropped of or something.

Circular Dependencies Infinite Loop

Need to ensure that the compiler doesn't try to compile the same project more than once in a build command.

Add Basic Doc Generator

Should start out by generating basic html file that lists types and functions so that one does not have to scan all the code to find it. Then have it load basic description from comment above the declaration.

Allow member variable initialization inline

Allow users to declare the value to initialize member variables to inline, much like the feature in C++. The value would automatically be assigned to the variable at the start of the destructor, assigning at the end could cause conflict or confusion if the user decides to assign to it in the constructor as well.
Ex: struct Type { int p = 5; }

matt-attack / jet Goto Github PK

jet's People

Contributors

Stargazers

Watchers

jet's Issues

Recommend Projects

Recommend Topics

Recommend Org