dlurton / anode Goto Github PK

View Code? Open in Web Editor NEW

8.0 8.0 2.0 2.82 MB

Anode Programming Language

License: Other

CMake 0.85% C++ 98.60% C 0.55%

compiler language llvm parsers pratt-parser programming-language repl

anode's People

Contributors

Stargazers

Watchers

Forkers

linecode iriberri

anode's Issues

Defining same variable twice in repl results in debug assertion failure

It should result in a pretty error message instead.

Implement cmake superbuild pattern for dependencies

LLVM, the ANTLR4 cpp runtime and linenoise-ng could be built with the cmake superbuild pattern. See:

Add support for negative literal ints and floats.

Currently, no support for negative literal ints and floats.

lwnn::compile::CodeGenHelper and inheritors + CodeGenerationContext need to be refactored

Using these classes are kind of awkward in most cases. There's got to be a better way to organize this stuff.

Travis build is broken

Due to errors such as this:

In file included from /home/travis/build/dlurton/anode/src/front/ast.cpp:2:
In file included from /home/travis/build/dlurton/anode/src/include/anode/front/ast.h:4:
In file included from /home/travis/build/dlurton/anode/src/include/anode/anode.h:13:
In file included from /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/unordered_map:47:
/usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/hashtable.h:727:41: error: 
      too many arguments to function call, expected 2, have 3
            _M_node_allocator().construct(__n, std::forward<_Args>(__args)...);
            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~      ^~~~~~~~~~~~~~~~~~~~~~~~~~~
/usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/../../../../include/c++/4.8/bits/hashtable.h:1260:24: note: 
      in instantiation of function template specialization
      'std::_Hashtable<std::basic_string<char>, std::pair<const
      std::basic_string<char>, anode::type::ClassField *>,
      gc_allocator<std::pair<std::basic_string<char>, anode::type::ClassField *>
      >, std::__detail::_Select1st, std::equal_to<std::basic_string<char> >,
      std::hash<string>, std::__detail::_Mod_range_hashing,
      std::__detail::_Default_ranged_hash, std::__detail::_Prime_rehash_policy,
      std::__detail::_Hashtable_traits<true, false, true>
      >::_M_allocate_node<const std::basic_string<char> &,
      anode::type::ClassField *&>' requested here
        __node_type* __node = _M_allocate_node(std::forward<_Args>(__args)...);

These errors do not occur in a VM running Ubuntu 14.04 with the same packages specified in the .travis.yml file. I currently do not have any idea how to resolve this issue. I have tried everything I can think of.

`(? true, true, 1);` should result in a "cannot implicitly cast 'int' to 'bool' error

Instead, the expression to be evaluated when the expression is false (i.e. 1) is implicitly cast to bool.

Invoke callback to return REPL result instead of returning in the middle of the module init function!

In src/compile.cpp:

    class ModuleAstVisitor : public ScopeFollowingVisitor {
            ....
    public:
        virtual bool visitingExprStmt(ExprStmt *expr) override {
            ....
            if(visitor.hasValue()) {
                //This is temporary - can't be returning in the middle of module init!
                irBuilder_.CreateRet(visitor.getValue());
            }
            ...
        }

Probably going to want to create something like this for the short term:

 void receiveReplResult(type::PrimitiveType type, void *value) {
      switch(result->resultType) {
           ...cast dump value to std::cout...
      }
 }

Then, in the LLVM IR emit call sites to this function instead of ret instructions.

LLVM shared libraries and tools are huge

libLLVM-5.0svn.so for example is 725mb! This is crazy. Need to research to see if we can reduce this size. I'm also wondering if this will be fixed with a release build--we know it will get smaller, the question is, how much?

Using a function invocation in a binary expression causes an attempt to implicit cast

...the result of the function call which of course results in a debug assertion failure because we can't cast
void to anything.

func foo::void() 123
assert(123 == foo())

The ANTLR4 lexer allows literal numbers with any number of digits

From Lwnn.g4:

LIT_INT:    '-'?[0-9]+;
LIT_FLOAT:  '-'?[0-9]+'.'[0-9]+;

We will need to provide a proper error message when numbers like "999999999999999999999999999999" are used, for example because this could exceed the maximum value of 32 bit integers, for example.