stryku / cmakesl Goto Github PK

View Code? Open in Web Editor NEW

59.0 59.0 3.0 2.98 MB

An attempt to introduce a new scripting language for CMake

License: BSD 3-Clause "New" or "Revised" License

CMake 1.40% C++ 96.37% Shell 0.05% Python 2.18%

cmakesl's People

Contributors

Stargazers

Watchers

Forkers

doyouevencpp blockspacer

cmakesl's Issues

Introduce class execution smoke tests

Use gtest_main library wherever possible

Implement range-based for loop

Implement designated initializers

Designated initializers should be implemented, e.g.

class foo
{
    int bar = 42;
    string baz = "42";
    bool qux;
};

foo f1 = foo{ .baz = "84"; };
// f1.bar equals 42
// f1.baz equals "84"
// f1.qux equals false;

Actually, this is under discussion. If you have any thoughts, feel free to comment here.

Missing string::operator=

int main()
{
    string s;
    s = "foo";
    return 0;
}

Produces error:

./CMakeLists.cmsl:4:8: error: string doesn't support operator =
    s = "foo";

Implement GDB pretty-printers

It should be implemented for:

token
sema_type
type_representation
type

Improve readme

Mention

tools
function overloading
errors
classes
type safety
youtube video
cmake integration
memory managment

Implement void type

At this point void type is imitated by instances of type bool. Additionally, user is not able to declare e.g. a function returning void.

void type should be added to builtin types and handled wherever possible.

Introduce overload resolution tests

Move parser tests to ast folder

Parser tests should be moved to ast directory.

Improve user guide

Explain

type safety
function overloading
no conversions
classes
generics
initializer list
memory managment

Handle if-else blocks in execution

Currently, executing if-else nodes is not implemented.

cmakesl binary crashes when sema tree can not be built

Any malformed code leads to a crash. Sema tree can not be built but it is used at some point.
Example code:

int main()
{
    non_existing_type foo;
    return 0;
}

I'm working on new build system and package manager called sw:
https://github.com/SoftwareNetwork/sw
(3.5+ years mature)
(https://github.com/cppan/cppan - first version implemented on top of cmake itfself)

I've implemented build DSL (frontend) in C++ already. You could take a look at sw.cpp file and specifications on the website.

Sw allows you to implement your own frontends for build system generator (backend).
For example, we could implement real cmake frontend for sw.

Maybe you'll be interesting in such thing without re-implementing C++ in your project.

Feel free to ask any questions.

Implement global variables

Implement sema_context_impl tests

Indexer takes wrong token for function name in a call expression

Implement namespaces

Stuff to handle:

identifiers
types
functions

Implement operator= for user types

class Foo {
    int bar;
};

class Baz {
    Foo foo;
};

int main() {
    Foo foo;
    Baz baz;
    baz.foo = foo; // fails
    return 42;
}

use cmake_parse_arguments in utils code

cmake_parse_arguments should be used as a method to parse arguments in our utils code

Handle for loop node in indexer

Integrate valgrind and sanitizers

Introduce variable type deduction

Type deduction should be implemented for variable declaration, e.g.:

auto foo = bar + baz;

Implement comments

CMakeSL should handle comments like the ones from C++: // and /**/

Introduce sema identifier lookup tests

Introduce Travis

Create Travis CI script and enable CI on the site

Implement constructors of user types

Handle break node in indexer

Report error on keyword used as a identifier/type name

class int {}; // error
enum return {} // error
// etc...

isset() and similar features

CMakeSL should be able to accept variables from outside, e.g. from command line arguments.
Those variables should be visible inside the scripts, as a regular variables, so the user can use them.

isset(foo) is a good example of operating on such variables. It 'returns' whether a variable with a given name exists.

Sema should detect mismatched types in function return type and return statements.

string foo() {
  return 42; // Should raise error
}

Fix CMake Windows build

CMake with integrated CMakeSL doesn't build on Windows (tried with VS 2019)

executable::link_to error points to a wrong position in the executable documentation file

int main()
{
    project foo = project("Foo");
    executable bar = foo.add_executable("bar", { "bar.cpp" });
    executable baz = foo.add_executable("baz", { "baz.cpp" });
    baz.link_to(bar);

    return 0;
}

Leads to such an error message:

./CMakeLists.cmsl:6:10: error: No matching function for call
    baz.link_to(bar);
        ^^^^^^^
<unknown source>:0:0: note: candidate 'link_to'. Type of parameter at position 0 does not match
** \brief The builtin executable type.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               ^^^^^^^ 
./CMakeLists.cmsl:1:1: error: parsing failed, can not execute

Implement ternary operator

Implement in-class initializers

class foo
{
    int bar = 42;
};

Introduce function return type deduction

Deduction of a function return type should be implemented, e.g.:

auto foo() {
    return bar + baz;
}

auto foo_void() {}

// Should not compile because return expressions produces instances of different types
auto foo_error( bool flag ) {
    if( flag ) {
        return 42;
    } else {
        return "42";
    }
}

CMAKESL_WITH_EXAMPLES option should be introduced to make examples optional.
CMAKESL_WITH_TOOLS option should be introduced to make tools optional.

Logging, printing, asserting etc.

User should have possibility to log, print, assert etc.

cmake::message();
cmake::warning();
cmake::error();
cmake::fatal_error();

Allow empty initializer lists

Such construction {} in such context list<int> foo = {} should be treated as an empty generic list, which can initialize list<int> as an empty list.

Empty initializer list should not be allowed while declaring a list with auto type:

auto foo = {}; // error