Goose  Check-in [f1cab5f761]

            [pEnv]( uint32_t budget )
            {
                static bool used = false;

                if( used )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage( 0,
                        "SetExecutionBudget can only be used once." );
                    return;
                }

                used = true;
                execute::VM::SetExecutionBudget( budget );
            } );

        RegisterBuiltinFunc< Eager< Value > ( Value, string ) >( e, "#ExternalFunction"_sid,
            [pEnv]( const Value& f, const string& symbol )
            {
                auto ft = FromValue< FuncType >( f );
                if( !ft )
                    return ToValue( "error"s ).setPoison();

                return ToValue( BuildExternalFunc( *ft, symbol ) );
            } );
















        RegisterBuiltinFunc< Intrinsic< uint32_t ( string ) > >( e, "ExecuteFile"_sid,
            [pEnv]( const Value& fnameval ) -> Value
            {
                auto filename = *FromValue< string >( fnameval );
                auto identity = InjectDomainIntoIdentity( RootIdentity(), DomainCompileTime() );














                auto result = Compiler::LoadAndExecuteFile( pEnv.lock(), filename, identity, GetValueType< uint32_t >() );

                if( !result )
                    return ToValue< uint32_t >( 1 );

                return *result;
            } );

        RegisterBuiltinFunc< Eager< Value > ( string, Value, Value ) >( e, "#CompileFileToFunction"_sid,
            [pEnv]( const string& filename, const Value& rt, const Value& params ) -> Value
            {
                // Validate those generic value inputs
                if( !rt.isType() )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage( rt.locationId(),
                        "#CompileFileToFunction: type expected." );
                    return PoisonValue();
                }

                if( CheckParamListKind( params ) != ParamListKind::Regular )
                {
                    DiagnosticsManager::GetInstance().emitErrorMessage( params.locationId(),
                        "#CompileFileToFunction: template parameter lists are not supported." );
                    return PoisonValue();
                }

                auto ftype = BuildFuncType( sema::DomainAny(), rt, params );

                // TODO at some point we'll want to pass the base identity to use as a param but
                // let's wait and see how the module and namespace stuff pans out first

                    InjectDomainIntoIdentity( funcIdentity, ANYTERM( _ ) ) );

                auto func = BuildFunc( c, ftype, identity, params, nullptr, c );
                const auto& pFuncLLR = func.llr();

                auto cfg = Compiler::LoadAndParseFile( pEnv.lock(), filename,  funcIdentity, ftype.returnType() );




                if( cfg->isPoisoned() )
                    return PoisonValue();

                if( c.returnType() != GetValueType< void >()
                    && !cfg->areAllBBTerminated() )
                {
                    pFuncLLR->setInvalid();

#include "builtins/builtins.h"

using namespace empathy;
using namespace empathy::ir;

namespace empathy::builtins
{
    void SetupTupleUnification( Env& e )
    {
        // Single element tuple unwrapping rule: if we encounter such a tuple, attempt to unify
        // its contained value with whatever's on the other side.
        e.unificationRuleSet()->addSymRule(



            ValueToIRExpr( ValuePattern(
                ANYTERM( _ ),
                ValueToIRExpr( MkTupleType( ANYTERM( _ ), VEC( ANYTERM( _ ) ) ) ),
                ANYTERM( _ ) ) ),

            ANYTERM( _ ),

        []( const Term& lhs, const Term& rhs, UnificationContext& c ) -> UniGen
        {
            // Only deal with during the second pass, we may have unresolved holes
            // messing things up.
            if( !c.secondPass() )
            {
                co_yield { lhs, c };
                co_return;
            }

            auto tup = ValueFromIRExpr( lhs );
            assert( tup );

            const auto& vec1 = *get< pvec >( tup->val() );

            // In some cases, the tuple may not be an actual tuple value but merely
            // a pattern for a tuple value, with a hole instead of its content vector.
            // If it happens, since that hole is represented as a vector, we'll have a longer than
            // 1 vector here. But this means we can't extract the first element anyway (since it
            // doesn't really exist yet), so just yield the tuple as is.
            if( vec1.length().minLength() != 1 )
            {
                co_yield { lhs, c };
                co_return;
            }

            co_yield Unify( vec1[0], rhs, c );
        } );

        // When unifying a tuple against a value whose type is a hole, we don't want
        // the above rule to apply (ie we don't want 1 element tuples bound to generic
        // template parameters to be peeled off). So here's a rule for this case which
        // leaves the tuple unchanged. It will take priority over the above rule in
        // those cases because it matches a more specific pattern.

            format( "{}: can not be executed.", filename ) );
        return PoisonValue();
    }

    execute::VM vm;
    return vm.execute( cfg->entryBB() );
}


ptr< llr::CFG > Compiler::LoadAndParseFile( const ptr< Env >& e, const string& filename, const Term& identity, optional< Term > returnType )
{
    ifstream sourcefile( filename.c_str() );
    if( !sourcefile.good() )
    {
        DiagnosticsManager::GetInstance().emitErrorMessage( 0,

// This is the interpreted code entry point of the empathy
// command line tool.
//
// This will setup the prelude and drive the compilation
// process (through function calls exposed by empathy).

// Direct run mode:
// We have a bunch of low level, simple tests of the basic language functionality
// and builtins provided by the compilers, which make do without the standard prelude and library.
// Since those tests are very useful, we want to be able to skip the regular front-end to
// be able to continue to run those tests.
// This is achieved by using a couple of utility builtin fonction to perform a crude parsing
// of the command line.
// If the command line starts with "--noprelude", followed by a filename, we skip the frontend
// and library setup and just run the provided file as is.

// This is a bit awkward for now: we need the parsing to be containd entirely
//  into compile time functions whose result can be eagerly evaluated, so
// that we can use it as parameters for the #if below. But we don't have any way to
// return multiple results yet, hence the awkward duplication.
void HandleForceColorOption()
{
    var args = Args()


    while true
    {
        if StrStartsWith( args, "--noprelude" )
        {

            args = StrStripFirstSubStr( args )
            continue
        }

        if StrStartsWith( args, "--forcecolors" )
        {
            DiagnosticsForceColors( true )
            return
        }

        break
    }
}

bool HandleNoPreludeOption()
{
    var args = Args()

    while true
    {
        if StrStartsWith( args, "--noprelude" )
        {
            return true
        }

        if StrStartsWith( args, "--forcecolors" )
        {
            args = StrStripFirstSubStr( args )
            continue
        }

        return false
    }
}

ct_string GetFilename()
{
    var args = Args()

    while true
    {
        if StrStartsWith( args, "--noprelude" )
        {
            args = StrStripFirstSubStr( args )
            continue
        }

        if StrStartsWith( args, "--forcecolors" )
        {
            args = StrStripFirstSubStr( args )
            continue
        }

        return args
    }
}

HandleForceColorOption()

#if HandleNoPreludeOption()
{
    using IsCompiling = false
    return ExecuteFile( GetFilename() )
}
#else
{
    using IsCompiling = true
    return ExecuteFile( "lib/frontend.em" )
}

// The front-end.

// Its job, as of now, is to take the source file name from the command line,
// and compile it into an executable file of the same name, with the .out suffix.
//
// There is zero goal of portability yet, all of this is linux specific.
//
// It will become more sophisticated later on as library facilities become available
// and allow to implement more intelligence here.

using filename = GetFilename()

// Create the module
var module = CGModuleCreate( filename )

// Setup the target.
if !CGModuleSetupTarget( module )
{
    Print( "Failed to setup llvm target.\n" )
    return 0
}

// Define the exit external function.
using exit = #ExternalFunction( void( uint( 32 ) returnCode ), "_exit" )

using main = #CompileFileToFunction( filename, void, () )

// The entry point of the binary.
// We have to use "using" and an anonymous function, because otherwise
// it would create an overloadset and CGGenerateFunction wouldn't know
// how to deal with that.
// This is basically the "crt0". Dunno yet if it's a good idea to build it myself
// or just to link to an existing crt0.o. This has the advantage of flexibility

    return 0
}

// Run the llvm optimization passes
CGModuleOptimize( module )

// Output the llvm ir and the asm for inspection.
CGModuleEmitLLVMIr( module, strcat( filename, ".ll" ) )

if !CGModuleEmitAsm( module, strcat( filename, ".s" ) )
{
    Print( strcat( "Failed to write ", strcat( filename, ".s\n" ) ) )
    return 0
}

// Output the object file.
if !CGModuleEmitObj( module, strcat( filename, ".o" ) )
{
    Print( strcat( "Failed to write ", strcat( filename, ".o\n" ) ) )
    return 0
}

// Link it and produce an executable file.
var linkerArgs = (
    strcat( filename, ".o" ),
    "-o", strcat( filename, ".out" ),
    "-L/lib/x86_64-linux-gnu", "-lc",
    "--dynamic-linker=/lib64/ld-linux-x86-64.so.2"
)

if !CGLinkerELF( linkerArgs )
    return 0

Print( strcat( "Built executable ", strcat( filename, ".out\n" ) ) )

ExecuteFile( "tests/noprelude/helpers.em"

bool lomarf()
{
    return true
}

ExecuteFile( "tests/noprelude/helpers.em" )

// Recursive using expression accross two files.
using SomeOtherThing = Laffo

SomeOtherThing

ExecuteFile( "tests/noprelude/helpers.em" )

// This will cause an error in a template function that wasn't directly called,
// but instantiated by being passed as a function object. This generates a
// specific context message.

ct_string higherTpl( ct_string( $T s ) func, $T x )
{

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string higherPoly( ct_string( $T s ) $f )
{
    return strcat( strcat( $f(5), ", " ), $f( "blah" ) )
}

ct_string someFunc( $T x )

ExecuteFile( "tests/noprelude/helpers.em" )

if !assert( 219 + 1337 == 1556, "add test" )
    return 0

if !assert( 219 - 1337 == -1118, "sub test" )
    return 0

ExecuteFile( "tests/noprelude/helpers.em" )

uint( 32 ) lomarf( uint( 32 ) a, uint( 32 ) b )
{
    return a ^ b;
}

if !assert( lomarf( 0xdeadbeef, 0xabadfeed ) == 0x75004002, "integer bitwise xor test" )

ExecuteFile( "tests/noprelude/helpers.em" )

if !assert( true == true, "eq test 1" )
    return 0

if !assert( 219 == 219, "eq test 2" )
    return 0

ExecuteFile( "tests/noprelude/helpers.em" )

var lomarf = 219

if !assert( lomarf == 219, "compound assignment operator test 1" )
    return 0

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string higher( ct_string( ct_string s ) func )
{
    return func( "higher" )
}

ct_string someFunc( $T a )

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string higherPoly( ct_string( $T s ) $func )
{
    return strcat( strcat( $func( 123 ), ", " ), $func( "blah" ) )
}

ct_string someFunc( $T x )

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string higherTpl( ct_string( $T s ) func, $T x )
{
    return strcat( "higher: ", func( x ) )
}

ct_string someFunc( $T x )

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string func1( bool b )
{
    if b return "lomarf"
    return "meh"
}

ExecuteFile( "tests/noprelude/helpers.em" )

uint(32) lomarf = 219

if !assert( lomarf == 219, "local variable test 1" )
    return 0

if !assert( lomarf != 1337, "local variable test 2" )

ExecuteFile( "tests/noprelude/helpers.em" )

bool lomarf( bool a, bool b )
{
    return a | b;
}

bool blah( bool a, bool b )

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string overloadedFunc()
{
    return "overload 1"
}

ct_string overloadedFunc( ct_string foo )

ExecuteFile( "tests/noprelude/helpers.em" )

ct_string tplTest1( $T a, $U b )
{
    return "different types"
}

ct_string tplTest1( $T a, $T b )

ExecuteFile( "tests/noprelude/helpers.em" )

using u1 = u2
using u2 = "test"

if !assert( u1 == "test", "using test" )
    return 0

ExecuteFile( "tests/noprelude/helpers.em" )

var i = 0
while( i < 10 )
{
    i += 1
}