library_loader.load_lib_and_dependecies will cause to go into a infinite recursion when ran on linux. Might want to limit how many nested calls can be made.

If you take the modulo of a variable while in a for loop (the variable must be the one used by the for loop (i in the example)), it yields a tuple where the first element is the floor division and the second element is the actual modulo Ex:

for i in range(100)
    print(i % 2) # yields (i // 2, i % 2)

My machine does not have GLIBC_2.29, so it causes a crash during the library loading, however, that exception is not handled properly and another attempt is made to load the library, with a messed up path (since the function just appends first piece of the path from error message), which causes a recursive loop, which will eventually crash the program.

A naive solution to the problem I've came up with is:

def load_lib_and_dependecies(path, lib):
    try:
        return ctypes.CDLL(path + lib)
    except OSError as excp:
        # Get the name of the library not found
        error_msg = excp.args[0]
        # Should crash for any errors that are not missing object file 
        # errors, since we can't handle them
        if not "cannot open shared" in error_msg:
            # https://stackoverflow.com/questions/24752395/python-raise-from-usage
            # Helps to avoid a massive error message due to recursive calls
            # within an try/except
            raise excp from None
        lib_load = error_msg.split(" ")[0]
        lib_load = lib_load[0:-1]
        # Now load it
        load_lib_and_dependecies(path,lib_load)
        return load_lib_and_dependecies(path,lib)

This branch aim was to implement an easy and expandable debug set of tools. All the code related to those tools is found in the flyable/debug directory. There is essentially 2 parts to this system

1. The debug flag system

• In main.py, there is now a new constant variable called ENABLED_DEBUG_FLAG where you put all the flags you want to enable during the compilation of the program.
• Inside the compiler, the programmer can add a call to the function value_if_debug that takes a normal value, a debug value and a debug flag. At runtime, the function will return the debug value if the specified flag is enabled, else the normal value.

example

ENABLED_DEBUG_FLAGS: list[DebugFlags] = [
    DebugFlags.SHOW_VISIT_AST,
    DebugFlags.SHOW_OUTPUT_BUILDER,
]
...
DebugFlags.enable_debug_flags(*ENABLED_DEBUG_FLAGS)

2. The analysers

• An analyser extends a particular class and wraps some of its methods to allow a non-intrusive, non-modifying way of debugging the class.
• It is recommended to create a debug flag for each analyser and instentiate it inside a value_if_debug function along side its non-debug counterpart

example

self.__builder = value_if_debug(CodeBuilder(self), CodeBuilderAnalyser(self), DebugFlags.SHOW_OUTPUT_BUILDER)

When a local variable has the same name as a global variable, flyable thinks we are talking about the global variable.

example 1:

x = "global "

def foo():
    x = x * 2
    print(x)

foo()
print(x)

cpython: error flyable: prints global global

example 2:

x = "global "

def foo():
    x = "hello"
    print(x)

foo()
print(x)

cpython: prints hello global flyable: prints hello hello

Implement the ability to check / dispatch call for inheritance.

For now, only single inheritance needs to be supported but some groundwork can be put in place for multiple inheritance.

It is possible that external libraries interpret the compiled python program as the location of the python executable instead of the actual path of the system's installed Python executable.

<module 'sympy' from '/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/sympy/__init__.py'>
Traceback (most recent call last):
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/numpy/core/__init__.py", line 23, in <module>
    from . import multiarray
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/numpy/core/multiarray.py", line 10, in <module>
    from . import overrides
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/numpy/core/overrides.py", line 6, in <module>
    from numpy.core._multiarray_umath import (
ImportError: PyCapsule_Import could not import module "datetime"

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/numpy/__init__.py", line 144, in <module>
    from . import core
  File "/Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages/numpy/core/__init__.py", line 49, in <module>
    raise ImportError(msg)
ImportError:

IMPORTANT: PLEASE READ THIS FOR ADVICE ON HOW TO SOLVE THIS ISSUE!

Importing the numpy C-extensions failed. This error can happen for
many reasons, often due to issues with your setup or how NumPy was
installed.

We have compiled some common reasons and troubleshooting tips at:

    https://numpy.org/devdocs/user/troubleshooting-importerror.html

Please note and check the following:

  * The Python version is: Python3.10 from ".../Flyable/build/macos-arm64/a.out"
  * The NumPy version is: "1.22.1"

and make sure that they are the versions you expect.
Please carefully study the documentation linked above for further help.

Original error was: PyCapsule_Import could not import module "datetime"

Application ended with code 0

Right now runtime object files, python static and dynamic libraries are all prsent in the multiples build folders. Ideally they would all be at the same place to avoid repetition.

When you compile your code, the compiler simply takes the argument on the left to resolve the binary operation, whatever it is. Ex:

3 + 4 # yields 3 

8 % 2 # yields 8

The compiler raise an exception when trying to handle comprehension with multiple for items. To fix this we need a unpack routine in the code.

`old_price = {'milk': 1.02, 'coffee': 2.5, 'bread': 2.5}

dollar_to_pound = 0.76 new_price = {item: value * dollar_to_pound for (item, value) in old_price.items()} print(new_price)`

We're currently including the addition of strings in our Number Protocol call PyNumber_Add, however Python has a separate way of adding strings.

From their handling of the Binary_Add bytecode:

// code ...
if (PyUnicode_CheckExact(left) &&
         PyUnicode_CheckExact(right)) {
    sum = unicode_concatenate(tstate, left, right, f, next_instr);
    /* unicode_concatenate consumed the ref to left */
}
else {
    sum = PyNumber_Add(left, right);
    Py_DECREF(left);
}
// ... code