signalscript

signalscript copied to clipboard

signalscript

This is a fork of a scripting language that an old friend of mine made back in 2010.

The project got abandoned, and I made this fork just to get familiar with the code, add some small features, and learn about abstract syntax trees.

What the language had when Jeremic dropped the project:

• Fully working expressions.
• Conditional if/else blocks.
• Functions.
• All binary operators except modulo, exponent, +=, and -=.
• All unary operators except ++ and --.
• Class parsing but no actual functionality.
• Loop (while and for) parsing but no actual functionality.
• Parsing of break and continue statements but no actual functionality.
• Print() native function but no c-function exports.
• Basic string, number, boolean, and nil types.

What I've added in this fork:

• Loop functionality (compilation and interpretation) for both while and for loops.
• Functionality (compilation and interpretation) for both break and continue statements.
• Class instance creation (via new operator).
• Instance-level scoping for classes.
• Member function calls for classes (parameters are acting up, though).
• Unary operators ++ and -- (postfix).
• String unescaping to support characters such as "\n" and "\t".
• Many bug fixes with error reporting (std::strings were being passed into printf() as opposed to their .c_str() member calls).
• Some changes to the overall structure of the architecture and virtual processor.
• C++ function exporting
• Switch statements (lexing, parsing, compilation, and interpretation).
• Function keyword.
• Improvements to many binary operators.
• Numeric values which allow decimal places.
• Optimizations / cleanups to the VM code.
• Parsing and AST creation for tables (Currently no compilation or interpretation, though).

What I want to add before I inevitably get tired of playing with the language:

• Class members abstract the table interface (like in Lua).
• Fix parameter bugs for class member functions.
• Global variables.
• Remaining binary operators (modulo, exponent, +=, and -=).

Here's what the syntax/usage currently looks like (no class usage here, though, since it's pretty broken):

function testWhile()
{
    print("Expect 'haahaahaa'\n ");
    n = 0;
    while (true)
    {
        n = n + 1;
        print("h");

        i = 0;
        while (i < 2)
        {
            i = i + 1;
            print("a");
        }


        if (n == 3)
            break;
        else
            continue;
    }
    print("\n");
}


function testFor()
{
    print("Expect '012345 -- 54321 -- 13579'\n ");
    for (i = 0; i <= 5; i = i + 1)
    {
        print(i);
    }
    print(" -- ");
    for (i = 5; true; i = i - 1)
    {
        print(i);
        if (i == 1)
            break;
    }
    print(" -- ");
    for (i = 1; i < 10; i = i + 1)
    {
        if (i == 2 || i == 4 || i == 6 || i == 8)
            continue;
        print(i);
    }
    print("\n");
}


function testIncDec()
{
    print("Expect '01021 | -1 | 4'\n ");
    var = 0;
    print(var);


    var++;
    print(var);


    var--;
    print(var);


    var++;var++;
    print(var);


    var--;
    print(var);


    print(" | ");


    var--;var--;
    print(var);


    print(" | ");


    val = 1;
    val = val + val++;
    print(val);


    print("\n");
}


function testSwitch(value)
{
    switch (value)
    {
        case 3:
            print("three, ");
        case 2:
            {
                print("two, ");
            }
        case 1:
            {
                print("one\n");
                break;
            }
        default:
        {
            print("other\n");
        }
    }
}


function main()
{
    testWhile();
    testFor();
    testIncDec();


    print("Expect 'one'\n ");
    testSwitch(1);
    print("Expect 'two, one'\n ");
    testSwitch(2);
    print("Expect 'three, two, one'\n ");
    testSwitch(3);
    print("Expect 'other'\n ");
    testSwitch(4);
}

Here's the usage from C++:

FileInput file (name);
Lexer lexer (file);
Parser parser (lexer);
std::shared_ptr<AST> ast = parser.parse_program ();
Environment env = Environment ();
Compiler::Compile(env, ast);
Interpreter interpreter(env);
interpreter.execute ();

Here's how you export a C++ function:

//exported function prototype
std::shared_ptr<Object> printFunc(Environment env, std::vector<std::shared_ptr<Object>> args);

//call this before Compiler::Compile(env, ast);
env.exportFunction("print", printFunc);