root/attic/minid_old.d

module minid;

import std.c.stdlib;
import std.conv;
import std.perf;
import std.stdio;
import std.stream;
import std.string;
import std.utf;

/*
Calling a closure (of any type):
    ocall ox, 0

Calling methods with "this":
    ocall ox, index
    
Downcalling dynamic closures:
    ecall index

Calling static functions / Sidecalling dynamic closures:
    rcall index

Referencing static functions / Sidereferencing dynamic closures:
    rfuncref index

Downreferencing dynamic closures:
    efuncref index

Downclosing a function:
    eclose index

Sideclosing a function
    rclose index

Closing/referencing methods with "this" (delegation):
    oclose ox, index

Create closures at a static function level.
*/

/*
the minid module:

class Object
{
    int opCmp(Object other);
    bool opEquals(Object other);
    int getHash();
    char[] toString();
}

// Cut down on duplication of effort with RTTI!
// But that involves either subverting the typesafe compiler or adding in a new "feature" to allow an "any" type.
// How about instead of converting arrays to __Arrays right away, save that for the codegen, or somewhere between
// semantic and codegen?  That would work.

class __Array : Object
{
    this(TypeInfo ti, int length);

    int opCmp(__Array other);
    bool opEquals(__Array other);
    int getHash();
    char[] toString();

    // These return an "int", but the return type is really dictated by the compiler.
    int opIndex(int index);

    // These all take "ints", but again, it's type-dependent.
    int opIndexAssign(int value, int index);

    __Array opSlice();
    __Array opSlice(int lo, int hi);
    __Array opSliceAssign(int value);
    __Array opSliceAssign(int value, int lo, int hi);
    __IntArray dup();
    void sort();
    void reverse();
    
    namespace length
    {
        int opGet();
        int opSet(int l);
    }
    
    __IntArray opCat(__IntArray other);
    __IntArray opCatEq(__IntArray other);
}
*/

void main()
{
    BufferedFile f = new BufferedFile(`testscript.txt`, FileMode.In);

    auto Compiler c = new Compiler();

    c.compile(`testscript.txt`, f);
    
    f.close();
    delete f;
}

class Compiler
{
    public this()
    {

    }

    public void compile(char[] name, Stream source)
    {
        auto Lexer l = new Lexer();
        auto HighPerformanceCounter hpc = new HighPerformanceCounter();
        hpc.start();
        Token* tokens = l.lex(name, source);
        Module m = Module.parse(tokens);
        m.semantic();
        hpc.stop();
        writefln("Took ", hpc.microseconds() / 1000.0, "ms\n");
        m.showChildren();
        //writefln(m);
    }
}

int toInt(char[] s, int base)
{
    assert(base >= 2 && base <= 36);

    static char[] transTable =
    [
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 
        73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 0, 0, 0, 0, 0, 
        0, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
        73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    ];

    int length = s.length;

    if(!length)
        throw new ConvError(s);

    int sign = 0;
    int v = 0;
    
    char maxDigit = '0' + base - 1;

    for(int i = 0; i < length; i++)
    {
        char c = transTable[s[i]];

        if(c >= '0' && c <= maxDigit)
        {
            uint v1 = v;
            v = v * base + (c - '0');

            if(cast(uint)v < v1)
                throw new ConvOverflowError(s);
        }
        else if(c == '-' && i == 0)
        {
            sign = -1;

            if(length == 1)
                throw new ConvError(s);
        }
        else if(c == '+' && i == 0)
        {
            if(length == 1)
                throw new ConvError(s);
        }
        else
            throw new ConvError(s);
    }

    if(sign == -1)
    {
        if(cast(uint)v > 0x80000000)
            throw new ConvOverflowError(s);

        v = -v;
    }
    else
    {
        if(cast(uint)v > 0x7FFFFFFF)
            throw new ConvOverflowError(s);
    }

    return v;
}

struct Token
{
    public static enum Type
    {
        Assert,
        Bool,
        Break,
        Case,
        Cast,
        Char,
        Class,
        Closure,
        Continue,
        Def,
        Default,
        Delete,
        Do,
        Else,
        False,
        Float,
        For,
        Foreach,
        Function,
        If,
        Import,
        Int,
        Main,
        Module,
        Namespace,
        New,
        Null,
        Return,
        Super,
        Switch,
        This,
        True,
        Vararg,
        Void,
        While,

        Add,
        AddEq,
        Sub,
        SubEq,
        Mul,
        MulEq,
        Div,
        DivEq,
        Mod,
        ModEq,
        Pow,
        PowEq,
        Cat,
        CatEq,
        Assign,

        AndAnd,
        OrOr,

        Inc,
        Dec,

        LT,
        LE,
        GT,
        GE,
        EQ,
        NE,
        Is,

        Not,

        LParen,
        RParen,
        LBracket,
        RBracket,
        LBrace,
        RBrace,

        Colon,
        Comma,
        Semicolon,

        Dot,
        DotDot,

        Ident,
        BoolLiteral,
        StringLiteral,
        CharLiteral,
        IntLiteral,
        FloatLiteral,
        EOF
    }

    public static const char[][] tokenStrings =
    [
        "assert",
        "bool",
        "break",
        "case",
        "cast",
        "char",
        "class",
        "closure",
        "continue",
        "def",
        "default",
        "delete",
        "do",
        "else",
        "false",
        "float",
        "for",
        "foreach",
        "function",
        "if",
        "import",
        "int",
        "main",
        "module",
        "namespace"
        "new",
        "null",
        "return",
        "super",
        "switch",
        "this",
        "true",
        "vararg",
        "void",
        "while",

        "+",
        "+=",
        "-",
        "-=",
        "*",
        "*=",
        "/",
        "/=",
        "%",
        "%=",
        "^",
        "^=",
        "~",
        "~=",
        "=",

        "&&",
        "||",

        "++",
        "--",

        "<",
        "<=",
        ">",
        ">=",
        "==",
        "!=",
        "is",

        "!",

        "(",
        ")",
        "[",
        "]",
        "{",
        "}",

        ":",
        ",",
        ";",

        ".",
        "..",
        
        "Identifier",
        "Bool Literal",
        "String Literal",
        "Char Literal",
        "Int Literal",
        "Float Literal",
        "<EOF>"
    ];
    
    public static Type[char[]] stringToType;
    
    static this()
    {
        stringToType["assert"] = Type.Assert;
        stringToType["bool"] = Type.Bool;
        stringToType["break"] = Type.Break;
        stringToType["case"] = Type.Case;
        stringToType["cast"] = Type.Cast;
        stringToType["char"] = Type.Char;
        stringToType["class"] = Type.Class;
        stringToType["closure"] = Type.Closure;
        stringToType["continue"] = Type.Continue;
        stringToType["def"] = Type.Def;
        stringToType["default"] = Type.Default;
        stringToType["delete"] = Type.Delete;
        stringToType["do"] = Type.Do;
        stringToType["else"] = Type.Else;
        stringToType["false"] = Type.False;
        stringToType["float"] = Type.Float;
        stringToType["for"] = Type.For;
        stringToType["foreach"] = Type.Foreach;
        stringToType["function"] = Type.Function;
        stringToType["if"] = Type.If;
        stringToType["is"] = Type.Is;
        stringToType["import"] = Type.Import;
        stringToType["int"] = Type.Int;
        stringToType["main"] = Type.Main;
        stringToType["module"] = Type.Module;
        stringToType["namespace"] = Type.Namespace;
        stringToType["new"] = Type.New;
        stringToType["null"] = Type.Null;
        stringToType["return"] = Type.Return;
        stringToType["super"] = Type.Super;
        stringToType["switch"] = Type.Switch;
        stringToType["this"] = Type.This;
        stringToType["true"] = Type.True;
        stringToType["vararg"] = Type.Vararg;
        stringToType["void"] = Type.Void;
        stringToType["while"] = Type.While;
        stringToType["("] = Type.LParen;
        stringToType[")"] = Type.RParen;
        stringToType["["] = Type.LBracket;
        stringToType["]"] = Type.RBracket;
        stringToType["{"] = Type.LBrace;
        stringToType["}"] = Type.RBrace;
        stringToType[":"] = Type.Colon;
        stringToType[","] = Type.Comma;
        stringToType[";"] = Type.Semicolon;

        stringToType.rehash;
    }
    
    public char[] toString()
    {
        char[] ret;

        switch(type)
        {
            case Type.Ident:
                ret ~= "Ident: " ~ stringValue;
                break;
                
            case Type.BoolLiteral:
                ret ~= (boolValue ? "true" : "false");

            case Type.StringLiteral:
                ret ~= '"' ~ stringValue ~ '"';
                break;
                
            case Type.CharLiteral:
                ret ~= "'" ~ stringValue ~ "'";

            case Type.IntLiteral:
                ret ~= "Int: " ~ std.string.toString(intValue);
                break;

            case Type.FloatLiteral:
                ret ~= "Float: " ~ std.string.toString(floatValue);
                break;

            default:
                ret ~= tokenStrings[cast(uint)type];
                break;
        }
        
        return ret;
    }
    
    public static char[] toString(Type type)
    {
        return tokenStrings[type];
    }
    
    public void check(Type t)
    {
        if(type != t)
            throw new MDCompileException("'" ~ tokenStrings[t] ~ "' expected; found '" ~ tokenStrings[type] ~ "' instead", location);
    }

    public Type type;
    
    union
    {
        public bool boolValue;
        public char[] stringValue;
        public int intValue;
        public float floatValue;
    }

    public Location location;

    public Token* nextToken;
}

struct Location
{
    public uint line = 1;
    public uint column = 1;
    public char[] fileName;

    public static Location opCall(char[] fileName, uint line = 1, uint column = 1)
    {
        Location l;
        l.fileName = fileName;
        l.line = line;
        l.column = column;
        return l;
    }

    public char[] toString()
    {
        return fileName ~ "(" ~ .toString(line) ~ ":" ~ .toString(column) ~ ")";
    }
}

class MDException : Exception
{
    public this(char[] msg)
    {
        super(msg);
    }
}

class MDCompileException : MDException
{
    public this(char[] msg, Location loc)
    {
        super(loc.toString() ~ ": " ~ msg);
    }
}

class MDSymbolConflictException : MDCompileException
{
    public this(Symbol sym1, Symbol sym2)
    {
        super("'" ~ sym1.toPrettyString() ~ "' conflicts with '" ~ sym2.toPrettyString() ~ "'(" ~ sym2.mLocation.toString() ~ ")", sym1.mLocation);
    }
}

class MDShadowingException : MDCompileException
{
    public this(Symbol sym1, Symbol sym2)
    {
        super("'" ~ sym1.toPrettyString() ~ "' shadows '" ~ sym2.toPrettyString() ~ "'(" ~ sym2.mLocation.toString() ~ ")", sym1.mLocation);    
    }
}

class MDTypeConvException : MDCompileException
{
    public this(Expression from, Expression to)
    {
        super("Cannot implicitly convert expression '" ~ from.toString() ~ "' of type '" ~ from.mSemType.toString() ~ "' to type '" ~ to.mSemType.toString() ~ "'", from.mLocation);
    }
}

class Lexer
{
    protected Stream mSource;
    protected Location mLoc;
    protected char mCharacter;

    public this()
    {

    }

    public Token* lex(char[] name, Stream source)
    {
        if(!source.readable)
            throw new MDException(name ~ ": Source code stream is not readable");

        mLoc = Location(name);

        mSource = source;

        nextChar();

        Token* firstToken = nextToken();
        Token* t = firstToken;

        while(t.type != Token.Type.EOF)
        {
            Token* next = nextToken();

            t.nextToken = next;
            t = t.nextToken;
        }

        return firstToken;
    }

    protected static bool isEOF(char c)
    {
        return (c == '\0') || (c == char.init);
    }

    protected static bool isEOL(char c)
    {
        return isNewline(c) || isEOF(c);
    }

    protected static bool isWhitespace(char c)
    {
        return (c == ' ') || (c == '\t') || (c == '\v') || (c == '\u000C') || isEOL(c);
    }
    
    protected static bool isNewline(char c)
    {
        return (c == '\r') || (c == '\n');
    }
    
    protected static bool isBinaryDigit(char c)
    {
        return (c == '0') || (c == '1');
    }
    
    protected static bool isOctalDigit(char c)
    {
        return (c >= '0') && (c <= '7');
    }

    protected static bool isHexDigit(char c)
    {
        return ((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f')) || ((c >= 'A') && (c <= 'F'));
    }

    protected static bool isDecimalDigit(char c)
    {
        return (c >= '0') && (c <= '9');
    }
    
    protected static bool isAlpha(char c)
    {
        return ((c >= 'a') && (c <= 'z')) || ((c >= 'A') && (c <= 'Z'));
    }

    protected void nextChar()
    {
        mCharacter = mSource.getc();
        mLoc.column++;
  &nb