vn/code/vn_scene.cpp

#include "generated/vn_scene.meta.h"
#include "generated/vn_scene.meta.c"

static void S_EmitByte(scene_compiler *Compiler, u8 Byte)
{
    scene_annotated_bytecode_bucket *Bucket = Compiler->CurrentBucket;
    scene_annotated_bytecode_chunk *Chunk = Bucket->Last;
    if(!Chunk || Chunk->Count >= ArrayCount(Chunk->Data) || !AreEqual(Chunk->Name, Compiler->CurrentName))
    {
        Chunk = PushStruct(Compiler->Arena, scene_annotated_bytecode_chunk);
        Chunk->Name = Compiler->CurrentName;
        
        QueuePush(Bucket->First, Bucket->Last, Chunk);
        Bucket->Count += 1;
    }
    Chunk->Data[Chunk->Count] = Byte;
    Chunk->Count += 1;
}

static u64 S_MakeConstant(scene_compiler *Compiler, scene_value Value)
{
    scene_value_chunk *Chunk = Compiler->LastValueChunk;
    if(!Chunk || Chunk->Count >= ArrayCount(Chunk->Values))
    {
        Chunk = PushStruct(Compiler->Arena, scene_value_chunk);
        QueuePush(Compiler->FirstValueChunk, Compiler->LastValueChunk, Chunk);
    }
    Chunk->Values[Chunk->Count] = Value;
    u64 Result = Compiler->ValueCount;
    Compiler->ValueCount += 1;
    Chunk->Count += 1;
    return(Result);
}

static void S_EmitVariableLength(scene_compiler *Compiler, u64 Value)
{
    u64 Index = Value;
    for(;Index > 0x7F; Index >>= 7)
    {
        S_EmitByte(Compiler, Index|0x80);
        InvalidCodepath;
    }
    S_EmitByte(Compiler, Index);
}

static u64 S_ReadVariableLength(u8 **BytePtr)
{
    u64 Result = 0;
    u8 *Byte = *BytePtr;
    for(;*Byte & 0x80; Byte += 1)
    {
        Result = (Result<<7)|(*Byte & 0x7F);
    }
    Result = (Result<<7)|(*Byte & 0x7F);
    *BytePtr = Byte;
    return(Result);
}

static void S_EmitConstant(scene_compiler *Compiler, scene_value Value)
{
    S_EmitByte(Compiler, S_Op_Constant);
    S_EmitVariableLength(Compiler, S_MakeConstant(Compiler, Value));
}

static void S_SetEmissionTarget(scene_compiler *Compiler, string Target)
{
    if(AreEqual(Target, StrLit("")))
    {
        Compiler->CurrentBucket = &Compiler->GlobalScope;
        Compiler->CurrentName = StrLit("Global Scope");
    }
    else
    {
        u64 Hash = HashString(Target);
        Compiler->CurrentBucket = &Compiler->ProcBuckets[Hash % ArrayCount(Compiler->ProcBuckets)];
        Compiler->CurrentName = Target;
    }
}

static scene_annotated_bytecode_chunk *S_FindBytecodeChunkByName(scene_compiler *Compiler, string Name)
{
    scene_annotated_bytecode_chunk *Result = 0;
    u64 Hash = HashString(Name);
    scene_annotated_bytecode_bucket *Bucket = &Compiler->ProcBuckets[Hash%ArrayCount(Compiler->ProcBuckets)];
    for(scene_annotated_bytecode_chunk *Chunk = Bucket->First; Chunk != 0; Chunk = Chunk->Next)
    {
        if(AreEqual(Chunk->Name, Name))
        {
            Result = Chunk;
            break;
        }
    }
    return(Result);
}

static void S_AdvanceCompiler(scene_compiler *Compiler)
{
    Compiler->At += 1;
}

static scene_parse_rule S_ParseRuleFromToken(scene_compiler *Compiler, token Token)
{
    scene_parse_rule Result = {};
    switch(Token.Kind)
    {
        case TokenKind_ParenthesisOpen: { Result = { S_ParseGrouping, 0,             S_Precedence_None       }; } break;
        case TokenKind_Bang:            { Result = { S_ParseUnary,    0,             S_Precedence_None       }; } break;
        case TokenKind_Minus:           { Result = { S_ParseUnary,    S_ParseBinary, S_Precedence_Term       }; } break;
        case TokenKind_Plus:            { Result = { 0,               S_ParseBinary, S_Precedence_Term       }; } break;
        case TokenKind_Star:            { Result = { 0,               S_ParseBinary, S_Precedence_Factor     }; } break;
        case TokenKind_Slash:           { Result = { 0,               S_ParseBinary, S_Precedence_Factor     }; } break;
        case TokenKind_EqualEqual:      { Result = { 0,               S_ParseBinary, S_Precedence_Equality   }; } break;
        case TokenKind_BangEqual:       { Result = { 0,               S_ParseBinary, S_Precedence_Equality   }; } break;
        case TokenKind_Greater:         { Result = { 0,               S_ParseBinary, S_Precedence_Comparison }; } break;
        case TokenKind_GreaterEqual:    { Result = { 0,               S_ParseBinary, S_Precedence_Comparison }; } break;
        case TokenKind_Less:            { Result = { 0,               S_ParseBinary, S_Precedence_Comparison }; } break;
        case TokenKind_LessEqual:       { Result = { 0,               S_ParseBinary, S_Precedence_Comparison }; } break;
        case TokenKind_False:           { Result = { S_ParseLiteral,  0,             S_Precedence_None       }; } break;
        case TokenKind_True:            { Result = { S_ParseLiteral,  0,             S_Precedence_None       }; } break;
        case TokenKind_Numeric:         { Result = { S_ParseNumber,   0,             S_Precedence_None       }; } break;
        case TokenKind_Identifier:      { Result = { S_ParseVariable, 0,             S_Precedence_None       }; } break;
        default:
        {
            //InvalidCodepath;
        } break;
    }
    
    return(Result);
}

static b32 S_MatchToken(scene_compiler *Compiler, token Token, token_kind Kind)
{
    b32 Result = false;
    string String = T_StringFromToken(Compiler->Text, Token);
    if(Token.Kind == Kind)
    {
        Result = true;
    }
    return(Result);
}

static token S_ConsumeToken(scene_compiler *Compiler, token_kind Kind, char *Message)
{
    token Token = Compiler->At[0];
    string String = T_StringFromToken(Compiler->Text, Token);
    if(Token.Kind != Kind)
    {
        S_ParseError(Compiler, Message);
    }
    
    Compiler->At += 1;
    return(Token);
}

static void S_ParseTopLevelDeclaration(scene_compiler *Compiler)
{
    if(Compiler->At[0].Kind == TokenKind_Proc)
    {
        Compiler->At += 1;
        S_ParseProcedure(Compiler);
    }
    else if(Compiler->At[0].Kind == TokenKind_Var)
    {
        Compiler->At += 1;
        S_ParseVariableDeclaration(Compiler);
    }
    else
    {
        S_ParseError(Compiler, "Expected top-level declaration (proc or var)..");
    }
}

static void S_ParseProcedure(scene_compiler *Compiler)
{
    token NameToken = S_ConsumeToken(Compiler, TokenKind_Identifier, "Expected procedure name after 'proc'");
    S_ConsumeToken(Compiler, TokenKind_CurlyOpen, "Expected '{' after procedure name.");
    
    S_SetEmissionTarget(Compiler, T_StringFromToken(Compiler->Text, NameToken));
    
    for(;Compiler->At < Compiler->TokensEnd;)
    {
        if(Compiler->At[0].Kind == TokenKind_CurlyClose)
        {
            Compiler->At += 1;
            break;
        }
        else
        {
            S_ParseDeclaration(Compiler);
        }
    }
}

static void S_ParseDeclaration(scene_compiler *Compiler)
{
    switch(Compiler->At[0].Kind)
    {
        case TokenKind_Var:
        {
            Compiler->At += 1;
            S_ParseVariableDeclaration(Compiler);
        } break;
        case TokenKind_StringLiteral:
        {
            Compiler->At += 1;
            S_ParseLineEntry(Compiler);
        } break;
        default:
        {
            S_ParseStatement(Compiler);
        } break;
    }
}

static void S_ParseVariableDeclaration(scene_compiler *Compiler)
{
    S_ConsumeToken(Compiler, TokenKind_Identifier, "Expected variable name.");
    u64 NameConstant = S_MakeConstant(Compiler, S_MakePointer(&Compiler->At[-1]));
    
    if(Compiler->At[0].Kind == TokenKind_Equal)
    {
        Compiler->At += 1;
        S_ParseExpression(Compiler);
    }
    else
    {
        S_EmitByte(Compiler, S_Op_Nil);
    }
    
    S_ConsumeToken(Compiler, TokenKind_Semicolon, "Expected ';' after variable declaration.");
    
    S_EmitByte(Compiler, S_Op_DefineGlobal);
    u64 Index = NameConstant;
    for(;Index > 0x7F; Index >>= 7)
    {
        S_EmitByte(Compiler, Index|0x80);
        InvalidCodepath;
    }
    S_EmitByte(Compiler, Index);
}

static void S_ParseVariable(scene_compiler *Compiler, b32 CanAssign)
{
    S_ParseNamedVariable(Compiler, &Compiler->At[-1], CanAssign);
}

static void S_ParseNamedVariable(scene_compiler *Compiler, token *Token, b32 CanAssign)
{
    u64 NameConstant = S_MakeConstant(Compiler, S_MakePointer(Token));
    if(CanAssign && Compiler->At[0].Kind == TokenKind_Equal)
    {
        Compiler->At += 1;
        S_ParseExpression(Compiler);
        S_EmitByte(Compiler, S_Op_SetGlobal);
    }
    else
    {
        S_EmitByte(Compiler, S_Op_GetGlobal);
    }
    S_EmitVariableLength(Compiler, NameConstant);
}

static void S_ParseLineEntry(scene_compiler *Compiler)
{
    token *LineToken = &Compiler->At[-1];
    
    b32 EmitAwait = true;
    
    // sixten: tags -> flags
    scene_line_entry_flag Flags = 0;
    for(;Compiler->At[0].Kind == TokenKind_PoundSign;)
    {
        Compiler->At += 1;
        token TagToken = S_ConsumeToken(Compiler, TokenKind_Identifier, "Expected tag name after '#'.");
        string TagString = T_StringFromToken(Compiler->Text, TagToken);
        if(AreEqual(TagString, StrLit("noclear")))
        {
            Flags |= S_LineEntryFlag_NoClear;
        }
        else if(AreEqual(TagString, StrLit("noawait")))
        {
            EmitAwait = false;
        }
        else
        {
            S_ParseError(Compiler, "Unknown tag.");
        }
    }
    
    S_ConsumeToken(Compiler, TokenKind_Semicolon, "Expected ';' after line entry.");
    
    S_EmitByte(Compiler, S_Op_LineEntry|Flags);
    S_EmitVariableLength(Compiler, S_MakeConstant(Compiler, S_MakePointer(LineToken)));
    if(EmitAwait)
    {
        S_EmitByte(Compiler, S_Op_AwaitInput);
    }
}

static void S_ParseStatement(scene_compiler *Compiler)
{
    S_ParseExpression(Compiler);
    S_ConsumeToken(Compiler, TokenKind_Semicolon, "Expected ';' after statement.");
}

static void S_ParseExpression(scene_compiler *Compiler)
{
    S_ParsePrecedence(Compiler, S_Precedence_Assignment);
}

static void S_ParseLiteral(scene_compiler *Compiler, b32 CanAssign)
{
    string Value = T_StringFromToken(Compiler->Text, Compiler->At[-1]);
    switch(Compiler->At[-1].Kind)
    {
        case TokenKind_False: { S_EmitByte(Compiler, S_Op_False); } break;
        case TokenKind_True: { S_EmitByte(Compiler, S_Op_True); } break;
        InvalidDefaultCase;
    }
}

static void S_ParseNumber(scene_compiler *Compiler, b32 CanAssign)
{
    r64 Value = DoubleFromString(T_StringFromToken(Compiler->Text, Compiler->At[-1]));
    
    S_EmitConstant(Compiler, S_MakeNumber(Value));
}

static void S_ParseGrouping(scene_compiler *Compiler, b32 CanAssign)
{
    S_ParseExpression(Compiler);
    S_ConsumeToken(Compiler, TokenKind_ParenthesisClose, "Expected ')' after expression.");
}

static void S_ParseUnary(scene_compiler *Compiler, b32 CanAssign)
{
    scene_operator Operator = S_OperatorFromString(T_StringFromToken(Compiler->Text, Compiler->At[-1]));
    S_ParsePrecedence(Compiler, S_Precedence_Unary);
    
    switch(Operator)
    {
        case S_Operator_Minus: { S_EmitByte(Compiler, S_Op_Negate); } break;
        case S_Operator_Not:   { S_EmitByte(Compiler, S_Op_Not);    } break;
        InvalidDefaultCase;
    }
}

static void S_ParseBinary(scene_compiler *Compiler, b32 CanAssign)
{
    token Token = Compiler->At[-1];
    scene_operator Operator = S_OperatorFromString(T_StringFromToken(Compiler->Text, Token));
    scene_parse_rule Rule = S_ParseRuleFromToken(Compiler, Token);
    S_ParsePrecedence(Compiler, (scene_precedence)(Rule.Precedence + 1));
    
    switch(Operator)
    {
        case S_Operator_Add:                 { S_EmitByte(Compiler, S_Op_Add);                                      } break;
        case S_Operator_Minus:               { S_EmitByte(Compiler, S_Op_Subtract);                                 } break;
        case S_Operator_Multiply:            { S_EmitByte(Compiler, S_Op_Multiply);                                 } break;
        case S_Operator_Divide:              { S_EmitByte(Compiler, S_Op_Divide);                                   } break;
        case S_Operator_Equals:              { S_EmitByte(Compiler, S_Op_Equal);                                    } break;
        case S_Operator_NotEquals:           { S_EmitByte(Compiler, S_Op_Equal);    S_EmitByte(Compiler, S_Op_Not); } break;
        case S_Operator_Greater:             { S_EmitByte(Compiler, S_Op_Greater);                                  } break;
        case S_Operator_GreaterThanOrEquals: { S_EmitByte(Compiler, S_Op_Less);     S_EmitByte(Compiler, S_Op_Not); } break;
        case S_Operator_Less:                { S_EmitByte(Compiler, S_Op_Less);                                     } break;
        case S_Operator_LessThanOrEquals:    { S_EmitByte(Compiler, S_Op_Greater);  S_EmitByte(Compiler, S_Op_Not); } break;
        InvalidDefaultCase;
    }
}

static void S_ParsePrecedence(scene_compiler *Compiler, scene_precedence Precedence)
{
    b32 CanAssign = (Precedence <= S_Precedence_Assignment);
    
    S_AdvanceCompiler(Compiler);
    scene_parse_rule Rule = S_ParseRuleFromToken(Compiler, Compiler->At[-1]);
    if(Rule.PrefixRule)
    {
        Rule.PrefixRule(Compiler, CanAssign);
    }
    else
    {
        S_ParseError(Compiler, "Expected expression.");
    }
    
    
    while(Precedence <= (Rule = S_ParseRuleFromToken(Compiler, Compiler->At[0])).Precedence)
    {
        S_AdvanceCompiler(Compiler);
        Rule.InfixRule(Compiler, CanAssign);
    }
    
    if(CanAssign && Compiler->At[0].Kind == TokenKind_Equal)
    {
        S_ParseError(Compiler, "Invalid assignment target.");
    }
}

static string S_DisassembleBytecode(scene_compiler *Compiler, scene_annotated_bytecode_chunk *Chunk, memory_arena *Arena)
{
    string_list List = {};
    
    temporary_memory Scratch = GetScratch(&Arena, 1);
    
    u8 *ChunkBegin = Chunk->Data;
    u8 *ChunkEnd = ChunkBegin + Chunk->Count;
    for(u8 *Data = ChunkBegin; Data < ChunkEnd; Data += 1)
    {
        switch(*Data)
        {
            case S_Op_Constant:
            {
                Data += 1;
                u64 ValueIndex = S_ReadVariableLength(&Data);
                scene_value Value = Compiler->FirstValueChunk->Values[ValueIndex];
                AppendString(&List, StrLit("Constant: "), Scratch.Arena);
                switch(Value.Kind)
                {
                    case S_ValueKind_Number:  { AppendString(&List, PushFormat(Scratch.Arena, "%f (number)\n",  Value.Number),  Scratch.Arena); } break;
                    case S_ValueKind_Boolean: { AppendString(&List, PushFormat(Scratch.Arena, "%b (boolean)\n", Value.Boolean), Scratch.Arena); } break;
                    case S_ValueKind_Pointer: { AppendString(&List, PushFormat(Scratch.Arena, "%x (pointer)\n", Value.Pointer), Scratch.Arena); } break;
                }
            } break;
            case S_Op_Nil:      { AppendString(&List, StrLit("Nil\n"), Scratch.Arena);      } break;
            case S_Op_True:     { AppendString(&List, StrLit("True\n"), Scratch.Arena);     } break;
            case S_Op_False:    { AppendString(&List, StrLit("False\n"), Scratch.Arena);    } break;
            case S_Op_Negate:   { AppendString(&List, StrLit("Negate\n"), Scratch.Arena);   } break;
            case S_Op_Not:      { AppendString(&List, StrLit("Not\n"), Scratch.Arena);      } break;
            case S_Op_Add:      { AppendString(&List, StrLit("Add\n"), Scratch.Arena);      } break;
            case S_Op_Subtract: { AppendString(&List, StrLit("Subtract\n"), Scratch.Arena); } break;
            case S_Op_Multiply: { AppendString(&List, StrLit("Multiply\n"), Scratch.Arena); } break;
            case S_Op_Divide:   { AppendString(&List, StrLit("Divide\n"), Scratch.Arena);   } break;
            case S_Op_Equal:    { AppendString(&List, StrLit("Equal\n"), Scratch.Arena);    } break;
            case S_Op_Greater:  { AppendString(&List, StrLit("Greater\n"), Scratch.Arena);  } break;
            case S_Op_Less:     { AppendString(&List, StrLit("Less\n"), Scratch.Arena);     } break;
            case S_Op_DefineGlobal:
            {
                Data += 1;
                
                u64 Index = S_ReadVariableLength(&Data);
                u64 Pointer = Compiler->FirstValueChunk->Values[Index].Pointer;
                token *Token = (token *)Pointer;
                string String = T_StringFromToken(Compiler->Text, *Token);
                AppendString(&List, StrLit("Define Global: "), Scratch.Arena);
                AppendString(&List, String, Scratch.Arena);
                AppendString(&List, StrLit("\n"), Scratch.Arena);
            } break;
            
            case S_Op_GetGlobal:
            {
                Data += 1;
                u64 Pointer = Compiler->FirstValueChunk->Values[S_ReadVariableLength(&Data)].Pointer;
                token *Token = (token *)Pointer;
                string String = T_StringFromToken(Compiler->Text, *Token);
                AppendString(&List, PushFormat(Scratch.Arena, "Get Global: %S\n", String), Scratch.Arena);
            } break;
            case S_Op_SetGlobal:
            {
                Data += 1;
                u64 Pointer = Compiler->FirstValueChunk->Values[S_ReadVariableLength(&Data)].Pointer;
                token *Token = (token *)Pointer;
                string String = T_StringFromToken(Compiler->Text, *Token);
                AppendString(&List, PushFormat(Scratch.Arena, "Set Global: %S\n", String), Scratch.Arena);
            } break;
            case S_Op_AwaitInput: { AppendString(&List, StrLit("Await Input\n"), Scratch.Arena); } break;
            default:
            {
                if(*Data & S_Op_LineEntry)
                {
                    Data += 1;
                    u64 Pointer = Compiler->FirstValueChunk->Values[S_ReadVariableLength(&Data)].Pointer;
                    token *Token = (token *)Pointer;
                    string String = Substring(Compiler->Text, Pad(Token->Range, -1));
                    AppendString(&List, PushFormat(Scratch.Arena, "Line Entry: %S\n", String), Scratch.Arena);
                }
                else
                {
                    AppendString(&List, StrLit("Unknown Op\n"), Scratch.Arena);
                }
            } break;
        }
    }
    
    string Result = JoinStringList(&List, Arena);
    
    ReleaseScratch(Scratch);
    return(Result);
}

struct proc_from_chunks_result
{
    scene_proc *Proc;
    scene_annotated_bytecode_chunk *NextChunk;
};

static proc_from_chunks_result S_ProcFromChunks(memory_arena *Arena, scene_annotated_bytecode_chunk *First)
{
    Assert(First != 0);
    string ChunkName = First->Name;
    
    //- sixten: find required bytes
    s64 RequiredBytes = 0;
    scene_annotated_bytecode_chunk *NextChunk = 0;
    {
        scene_annotated_bytecode_chunk *Chunk = First;
        for(; Chunk != 0 && AreEqual(Chunk->Name, ChunkName); Chunk = Chunk->Next)
        {
            RequiredBytes += Chunk->Count;
        }
        NextChunk= Chunk;
    }
    
    scene_proc *Proc = PushStruct(Arena, scene_proc);
    Proc->Name = ChunkName;
    Proc->Data = PushArray(Arena, u8, RequiredBytes);
    Proc->Count = RequiredBytes;
    
    //- sixten: copy over data from chunks
    u8 *Dest = Proc->Data;
    for(scene_annotated_bytecode_chunk *Chunk = First; Chunk != NextChunk; Chunk = Chunk->Next)
    {
        Copy(Dest, Chunk->Data, Chunk->Count);
        Dest += Chunk->Count;
    }
    
    //- sixten: fill & return
    proc_from_chunks_result Result;
    {
        Result.Proc = Proc;
        Result.NextChunk = NextChunk;
    }
    return(Result);
}

static compiled_scene S_ScriptFromText(memory_arena *Arena, string Text)
{
    compiled_scene Result = {};
    
    temporary_memory Scratch = GetScratch(&Arena, 1);
    tokenize_result TokenizeResult = T_TokenizeFromText(Arena, Text, T_IsIrregular);
    
    // sixten(TODO): append token errors
    
    //- sixten: tokens -> bytecode
    scene_compiler Compiler = {};
    {
        Compiler.Arena = Scratch.Arena;
        Compiler.Text = Text;
        Compiler.TokensBegin = TokenizeResult.Tokens.Tokens;
        Compiler.TokensEnd = Compiler.TokensBegin+TokenizeResult.Tokens.Count;
        Compiler.At = Compiler.TokensBegin;
    };
    
    S_SetEmissionTarget(&Compiler, StrLit(""));
    
    for(;Compiler.At < Compiler.TokensEnd;)
    {
        S_ParseTopLevelDeclaration(&Compiler);
    }
    
    //- sixten: bake compiled chunks
    for(s64 BucketIndex = 0; BucketIndex < ArrayCount(Compiler.ProcBuckets); BucketIndex += 1)
    {
        scene_annotated_bytecode_bucket *Bucket = &Compiler.ProcBuckets[BucketIndex];
        for(scene_annotated_bytecode_chunk *Chunk = Bucket->First; Chunk != 0;)
        {
            proc_from_chunks_result ProcResult = S_ProcFromChunks(Arena, Chunk);
            s64 Hash = HashString(Chunk->Name);
            scene_proc_bucket *DestBucket = &Result.Buckets[Hash%ArrayCount(Result.Buckets)];
            QueuePush(DestBucket->First, DestBucket->Last, ProcResult.Proc);
            Chunk = ProcResult.NextChunk;
        }
    }
    
    //- sixten: bake value chunks
    {
        Result.Values = PushArray(Arena, scene_value, Compiler.ValueCount);
        Result.ValueCount = Compiler.ValueCount;
        scene_value *Dest = Result.Values;
        for(scene_value_chunk *Chunk = Compiler.FirstValueChunk; Chunk != 0; Chunk = Chunk->Next)
        {
            Copy(Dest, Chunk->Values, Chunk->Count);
            Dest += Chunk->Count;
        }
    }
    
    // sixten(IMPORTANT): The text is assumed to remain in memory for the duration of the scene.
    Result.Source = Text;
    
    ReleaseScratch(Scratch);
    return(Result);
}