Spiiin's blog

require strings
require fio

def run(code: string; var tape: array<uint8>; var codePos, tapePos: int&; skip: bool): bool
	while tapePos >= 0 && codePos < length(code)
		if tapePos >= length(tape) { tape |> push(uint8(0)); }

		let sym1  = code |> character_at(codePos)
		if sym1 == '['
			++codePos
			let oldPos = codePos
			while run(code, tape, codePos, tapePos, tape[tapePos] == uint8(0))
				codePos = oldPos
		elif sym1 == ']'
			return tape[tapePos] != uint8(0)
		elif !skip
			let sym  = code |> character_at(codePos)
			if sym == '+' { tape[tapePos] = uint8(int(tape[tapePos]) + 1); }
			elif sym == '-' { tape[tapePos] = uint8(int(tape[tapePos]) - 1); }
			elif sym == '>' { ++tapePos; }
			elif sym == '<' { --tapePos; }
			elif sym == '.' { print("{int(tape[tapePos]) |> to_char}"); }
			elif sym == ',' { tape[tapePos] = uint8(getchar()); }
			else { }
		++codePos
	return false

def interpret(code: string)
	let totalTime = ref_time_ticks()
	var tape: array<uint8>
	var codePos, tapePos : int
	run(code, tape, codePos, tapePos, false)
	let totalDt = double(get_time_usec(totalTime)) /1000000.0lf
	to_log(LOG_INFO, "total {totalDt} sec\n")

tape: array<uint8>
tape[index] // tape[check_range(index)] //медленно

var ptape: uint8? = addr(tape[0])
ptape[index] //check_not_null(ptape)[index] //быстрее, обращение без проверок

[unsafe_deref]
ptape[index] //ptape[index] //еще быстрее, обращение без перепроверок указателя на nullptr

[unsafe_deref]
def run(code: uint8?; lengthOfCode:int; var tape: uint8?; var codePos, tapePos: int&; skip: bool): bool
	unsafe
		while tapePos >= 0 && codePos < lengthOfCode
			let sym1  = int(code[codePos])
			if sym1 == '['
				++codePos
				let oldPos = codePos
				while run(code, lengthOfCode, tape, codePos, tapePos, tape[tapePos] == uint8(0))
					codePos = oldPos
			elif sym1 == ']'
				return tape[tapePos] != uint8(0)
			elif !skip
				let sym  = int(code[codePos])
				if sym == '+' { tape[tapePos] = uint8(int(tape[tapePos]) + 1); }
				elif sym == '-' { tape[tapePos] = uint8(int(tape[tapePos]) - 1); }
				elif sym == '>' { ++tapePos; }
				elif sym == '<' { --tapePos; }
				elif sym == '.' { print(int(tape[tapePos]) |> to_char); }
				elif sym == ',' { tape[tapePos] = uint8(getchar()); }
				else { }
			++codePos
		return false

def interpret(code: string)
	let totalTime = ref_time_ticks()
	var tape: array<uint8>
	var codePos, tapePos : int
	tape |> resize(1000000)
	unsafe
		run(reinterpret<uint8?> code, length(code), addr(tape[0]), codePos, tapePos, false)
	let totalDt = double(get_time_usec(totalTime)) /1000000.0lf
	to_log(LOG_INFO, "total {totalDt} sec\n")

e:\src\daScript\bin\Release>tutorial02aot.exe
[I] total 34.27342399999999856 sec

[jit,unsafe_deref]
def run(code: uint8?; lengthOfCode:int; var tape: uint8?; var codePos, tapePos: int&; skip: bool): bool

module brainfuck_macro shared public

def generateFunction(uniqueName, code)
    let seqStr = string(code)

    var blkArr : array<array<ExpressionPtr>>; defer_delete(blkArr)

    var blk : array<ExpressionPtr>; defer_delete(blk)
    blkArr |> emplace(blk)

    blkArr[0] |> emplace_new <| qmacro_expr( ${ var tape: array<uint8>; })
    blkArr[0] |> emplace_new <| qmacro_expr( ${ var tapePos : int; })
    blkArr[0] |> emplace_new <| qmacro_expr( ${ tape |> resize(1000000); })
    blkArr[0] |> emplace_new <| qmacro_expr( ${ var ptape = addr(tape[0]); })
    
    for sym in seqStr
        if sym == '+'   { back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(int(ptape[tapePos]) + 1); }); }
        elif sym == '-' { back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(int(ptape[tapePos]) - 1); }); }
        elif sym == '>' { back(blkArr) |> emplace_new <| qmacro_expr( ${ ++tapePos; }); } 
        elif sym == '<' { back(blkArr) |> emplace_new <| qmacro_expr( ${ --tapePos; }); }
        elif sym == '.' { back(blkArr) |> emplace_new <| qmacro_expr( ${ print(int(ptape[tapePos]) |> to_char); }); }
        elif sym == ',' { back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(getchar()); }); }
        elif sym == '['
            var blk1 : array<ExpressionPtr>; defer_delete(blk1)
            blkArr |> emplace(blk1)
        elif sym == ']'
            var last <- back(blkArr)
            blkArr |> pop()
            var whileExpr <- qmacro_expr <|
                while ptape[tapePos] != uint8(0)
                    $b(last)
            back(blkArr) |> emplace_new <| whileExpr
        else { }

    var fnArguments : array<VariablePtr>;
    var fn <- qmacro_function(uniqueName) <| $ ($a(fnArguments))
        unsafe
            $b(blkArr[0])
    defer_delete(fn)

    var args:array< tuple<argname:string;argvalue:RttiValue> >
    fn |> append_annotation("$", "unsafe_deref", args)
    //print(describe(fn))
    compiling_module() |> add_function(fn)

[reader_macro(name="bf")]
class private BrainfuckReader : AstReaderMacro
    def override accept( prog:ProgramPtr; mod:Module?; var expr:ExprReader?; ch:int; info:LineInfo) : bool
        append(expr.sequence, ch)
        if ends_with(expr.sequence,"%%")
            let len = length(expr.sequence)
            resize(expr.sequence,len-2)
            return false
        else
            return true
    def override visit( prog:ProgramPtr; mod:Module?; expr:smart_ptr<ExprReader>) : ExpressionPtr
        let str <- make_unique_private_name("bf`exec", expr.at)
        generateFunction(str, expr.sequence)

        var ftype <- new [[TypeDecl() at=expr.at, baseType=Type tFunction ]]
        ftype.firstType <- new [[TypeDecl() at=expr.at, baseType=Type tVoid]]
        var funcPtr <- new [[ExprAddr() at=expr.at, target:=str, funcType <- ftype]]
        return funcPtr

require brainfuck_macro
//генерируем функцию
let func = %bf~++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.%%
//вызываем сгенерированную функцию
invoke(func)

let func = %bf~[->+<]%%
//сгенерированный код

[unsafe_deref]
def public bf`exec_0xd_0xc
    unsafe
        var tape:array<uint8> -const                          //declare variables
        var tapePos:int -const
        resize(tape,1000000)
        var ptape:auto -const = addr(tape[0])

        while ptape[tapePos] != uint8(0)                      //[
            ptape[tapePos] = uint8(int(ptape[tapePos]) - 1)   //-
            ++tapePos                                         //>
            ptape[tapePos] = uint8(int(ptape[tapePos]) + 1)   //+
            --tapePos                                         //<]
let func = @@bf`exec_0xd_0xc //указатель на функцию

fn |> append_annotation("$", "unsafe_deref", args)
fn |> append_annotation("$", "jit", args)

def seachRepeats(symIt; var sym:int&; symbolToCheck)
    var count = 1
    while next(symIt, sym)
        if sym == symbolToCheck
            ++count
        else
            return count
    return count

def match_reset(data: array<int>)
    return length(data) == 3 && data[0] == '[' && data[1] == '-' && data[2] == ']'

def match_add_right_reset(data: array<int>)
    return length(data) == 6 && data[0] == '[' && data[1] == '-' && data[2] == '>' && data[3] == '+' && data[4] == '<' && data[5] == ']'

def generateFunction(uniqueName, code)
    let seqStr = string(code)

    var blkArr : array<array<ExpressionPtr>>; defer_delete(blkArr)

    var blk : array<ExpressionPtr>; defer_delete(blk)
    blkArr |> emplace(blk)

    var cyclePatternChecker:array<int>

    var initBlock <- quote() <|
        var tape: array<uint8>
        var tapePos : int
        tape |> resize(1000000)
        var ptape = addr(tape[0])
    //blkArr[0] |> emplace_new <| initBlock
    unsafe
        var _block <- reinterpret<smart_ptr<ExprBlock>>(reinterpret<smart_ptr<ExprMakeBlock>> initBlock)._block
        for blockItem in _block.list
            blkArr[0] |> emplace_new <| blockItem
    var symIt <- unsafe(each(seqStr))
    var sym : int
    var repeat = false
    var count : int = 1
    while repeat || next(symIt, sym)
        repeat = false
        if sym == '+'
            cyclePatternChecker |> push(sym)
            repeat = true
            count = seachRepeats(symIt, sym, '+')
            back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(int(ptape[tapePos]) + $v(count)); })
        elif sym == '-'
            cyclePatternChecker |> push(sym)
            repeat = true
            count = seachRepeats(symIt, sym, '-')
            back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(int(ptape[tapePos]) - $v(count)); })
        elif sym == '>'
            cyclePatternChecker |> push(sym)
            repeat = true
            count = seachRepeats(symIt, sym, '>')
            back(blkArr) |> emplace_new <| qmacro_expr( ${ tapePos +=  $v(count); })
        elif sym == '<'
            cyclePatternChecker |> push(sym)
            repeat = true
            count = seachRepeats(symIt, sym, '<')
            back(blkArr) |> emplace_new <| qmacro_expr( ${ tapePos -= $v(count); })

        elif sym == '.' { back(blkArr) |> emplace_new <| qmacro_expr( ${ print(int(ptape[tapePos]) |> to_char); }); }
        elif sym == ',' { back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(getchar()); }); }
        elif sym == '['
            cyclePatternChecker |> clear
            cyclePatternChecker |> push(sym)
            var blk1 : array<ExpressionPtr>; defer_delete(blk1)
            blkArr |> emplace(blk1)
        elif sym == ']'
            cyclePatternChecker |> push(sym)
            if match_reset(cyclePatternChecker)
                //match [-]
                blkArr |> pop()
                back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(0); })
            elif match_add_right_reset(cyclePatternChecker)
                //match [->+<]
                blkArr |> pop()
                back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos+$v(count)] = uint8(int(ptape[tapePos+$v(count)]) + int(ptape[tapePos])); })
                back(blkArr) |> emplace_new <| qmacro_expr( ${ ptape[tapePos] = uint8(0); })
            else
                //usual cycle
                var last <- back(blkArr)
                blkArr |> pop()
                var whileExpr <- qmacro_expr <|
                    while ptape[tapePos] != uint8(0)
                        $b(last)
                back(blkArr) |> emplace_new <| whileExpr

            cyclePatternChecker |> clear
        else { }

    var fnArguments : array<VariablePtr>;
    var fn <- qmacro_function(uniqueName) <| $ ($a(fnArguments))
        unsafe
            $b(blkArr[0])
    defer_delete(fn)

    var args:array< tuple<argname:string;argvalue:RttiValue> >
    fn |> append_annotation("$", "jit", args)
    fn |> append_annotation("$", "unsafe_deref", args)
    //print(describe(fn))
    compiling_module() |> add_function(fn)