Execute Brain****/Elena: Difference between revisions

From Rosetta Code
Content added Content deleted
No edit summary
imported>Arakov
mNo edit summary
 
(8 intermediate revisions by 3 users not shown)
Line 1: Line 1:
ELENA 6.x:
<lang elena>import system'collections.
import system'routines.
<syntaxhighlight lang="elena">import system'collections;
import system'dynamic.
import system'routines;
import system'dynamic'expressions;

import extensions.
import extensions'scripting.
import extensions;
import extensions'scripting;

class BFTape
const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.";
{

object theArray.
class TapeAssembler
object thePointer.
{
object theBrackets.
Stack _brackets;
List<Expression> _tape;
constructor new:aLength
[
constructor()
theArray := Array new:aLength; populate(:n) [ Integer new:0 ].
{
thePointer := Integer new:0.
_brackets := new Stack();
_tape := new List<Expression>();
theBrackets := Stack new.
_tape.append(Expression.DeclareAndAssigning(
]
"ptr",
Expression.Constant(0)));
append
[
}
theArray[thePointer] append:1.
constructor load(assembly_program)
]
{
assembly_program(self)
reduce
[
}
theArray[thePointer] reduce:1.
]
open()
{
_brackets.push(_tape);
next
_tape := new List<Expression>();
[
}
thePointer append:1.
]
close()
previous
{
var loop := Expression.Loop(
[
Expression.MessageCall(
thePointer reduce:1.
new Message("notequal[2]"),
]
Expression.MessageCall(
new Message("at[2]"),
push : bookmark
Expression.Variable("tape"),
[
Expression.Variable("ptr")
theBrackets push:bookmark.
),
]
Expression.Constant($0)
),
pop
CodeblockExpression.new(_tape.Value));
=> theBrackets.
_tape := _brackets.pop();
input
_tape.append(loop)
[
}
theArray[thePointer] := console readChar; toInt.
]
input()
output
{
_tape.append(
[
Expression.MessageCall(
console write(theArray[thePointer] toChar).
new Message("setAt[3]"),
]
Expression.Variable("tape"),
Expression.Variable("ptr"),
check = theArray[thePointer] != 0.
Expression.MessageCall(
new Message("readChar[1]"),
Expression.Constant(console)
)
)
)
}
output()
{
_tape.append(
Expression.MessageCall(
new Message("write[2]"),
Expression.Constant(console),
Expression.MessageCall(
new Message("at[2]"),
Expression.Variable("tape"),
Expression.Variable("ptr")
)
)
)
}
next()
{
_tape.append(
Expression.Assigning(
"ptr",
Expression.MessageCall(
new Message("add[2]"),
Expression.Variable("ptr"),
Expression.Constant(1))))
}
previous()
{
_tape.append(
Expression.Assigning(
"ptr",
Expression.MessageCall(
new Message("subtract[2]"),
Expression.Variable("ptr"),
Expression.Constant(1))))
}
increase()
{
_tape.append(
Expression.MessageCall(
new Message("setAt[3]"),
Expression.Variable("tape"),
Expression.Variable("ptr"),
Expression.MessageCall(
new Message("load[2]"),
Expression.Constant(CharValue),
Expression.MessageCall(
new Message("add[2]"),
Expression.MessageCall(
new Message("toInt[2]"),
Expression.Constant(intConvertExt),
Expression.MessageCall(
new Message("at[2]"),
Expression.Variable("tape"),
Expression.Variable("ptr")
)
),
Expression.Constant(1)
)
)
));
}
decrease()
{
_tape.append(
Expression.MessageCall(
new Message("setAt[3]"),
Expression.Variable("tape"),
Expression.Variable("ptr"),
Expression.MessageCall(
new Message("load[2]"),
Expression.Constant(CharValue),
Expression.MessageCall(
new Message("subtract[2]"),
Expression.MessageCall(
new Message("toInt[2]"),
Expression.Constant(intConvertExt),
Expression.MessageCall(
new Message("at[2]"),
Expression.Variable("tape"),
Expression.Variable("ptr")
)
),
Expression.Constant(1)
)
)
));
}
compiled()
{
var program := DynamicSingleton.load(
Expression.Method(
"eval",
CodeblockExpression.new(_tape.Value),
ScopeIdentifier.Variable("tape"))
).compile();
^(tape){ program.eval(tape) }
}
}
}


public program()
const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.".
{
var bfAssemblyProgram := new ScriptEngine()
program =
.loadPath("asmrules.es")
[
.buildScript(bf_program);
console

writeLine:bf_program.
var bfProgram := TapeAssembler.load(bfAssemblyProgram).compiled();

var program := scriptEngine
var bfTape := Array.allocate(1024).populate::(n => $0);
load path:"rules.es";

eval:bf_program.
console.writeLine(bf_program);

program eval:(BFTape new:1024).
bfProgram(bfTape)
].</lang>
}</syntaxhighlight>
The grammar:
The grammar:
<lang elena>[[
<syntaxhighlight lang="elena">[[
#grammar transform
#grammar build
#grammar cf
#grammar cf


#define start ::=
#define start ::= <= ( > += " 2" += " %""system'dynamic'tapeOp.tape_var[]""" => commands <= " *" "system'dynamic'Tape" "=" # ) =>;
<=
system'dynamic'DynamicTape (
system'dynamic'AllocFunction ( "1" )
system'dynamic'LocalFunction ( "2" ) => command commands
<= ) =>;

#define start ::= $eof;


#define commands ::= command commands;
#define commands ::= command commands;
Line 86: Line 204:
#define commands ::= $eof;
#define commands ::= $eof;


#define command ::= <= += " %""output[0]"" " => ".";
#define command ::= <= system'dynamic'MessageFunction ( "output[1]" ) => ".";
#define command ::= <= += " %""input[0]"" " => ",";
#define command ::= <= system'dynamic'MessageFunction ( "input[1]" ) => ",";
#define command ::= <= += " %""previous[0]"" " => "<";
#define command ::= <= system'dynamic'MessageFunction ( "previous[1]" ) => "<";
#define command ::= <= += " %""next[0]"" " => ">";
#define command ::= <= system'dynamic'MessageFunction ( "next[1]" ) => ">";
#define command ::= <= += " %""append[0]"" " => "+";
#define command ::= <= system'dynamic'MessageFunction ( "increase[1]" ) => "+";
#define command ::= <= += " %""reduce[0]"" " => "-";
#define command ::= <= system'dynamic'MessageFunction ( "decrease[1]" ) => "-";
#define command ::= <= += " -2" += " %""system'dynamic'tapeOp.tape_ptr[]"" " += " 1" += " %""system'dynamic'tapeOp.tape_stack[]"" " += "%""push[1]"" " => "[";
#define command ::= <= system'dynamic'MessageFunction ( "open[1]" ) => "[";
#define command ::= <= += " 0" += " %""system'dynamic'tapeOp.tape_stack[]"" " += " %""check[0]"" " += " 1" += " %""system'dynamic'tapeOp.tape_stack[]"" " += " %""pop[0]"" " += " %""system'dynamic'tapeOp.tape_jumpif[]"" " => "]";
#define command ::= <= system'dynamic'MessageFunction ( "close[1]" ) => "]";


#define comment ::= " " comments;
#define comment ::= " " comments;
Line 104: Line 222:


#mode symbolic;
#mode symbolic;
]]</lang>
]]</syntaxhighlight>
{{out}}
{{out}}
<pre>
<pre>
ELENA VM 3.2.15 (C)2005-2017 by Alex Rakov
Initializing...
Debug mode...
Done...
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
Hello World!
Hello World!

Latest revision as of 10:41, 25 January 2024

ELENA 6.x: 

import system'collections;
import system'routines;
import system'dynamic'expressions;

import extensions;
import extensions'scripting;

const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.";

class TapeAssembler
{    
    Stack            _brackets;
    List<Expression> _tape;
    
    constructor()
    {
        _brackets := new Stack();
        _tape := new List<Expression>();
        
        _tape.append(Expression.DeclareAndAssigning(
            "ptr",
            Expression.Constant(0)));
    }
    
    constructor load(assembly_program)
    {
        assembly_program(self)
    }    
    
    open()
    {
        _brackets.push(_tape);
        _tape := new List<Expression>();
    }
    
    close()
    {
        var loop := Expression.Loop(
                          Expression.MessageCall(
                             new Message("notequal[2]"),
                             Expression.MessageCall(
                                new Message("at[2]"),
                                Expression.Variable("tape"),
                                Expression.Variable("ptr")
                             ),
                             Expression.Constant($0)
                          ),
                          CodeblockExpression.new(_tape.Value));
                          
        _tape := _brackets.pop();
        _tape.append(loop)                 
    }
    
    input()
    {
       _tape.append(
          Expression.MessageCall(
             new Message("setAt[3]"),
             Expression.Variable("tape"),
             Expression.Variable("ptr"),
             Expression.MessageCall(
                new Message("readChar[1]"),
                Expression.Constant(console)
             )
            )
        )
    }
    
    output()
    {
        _tape.append(
            Expression.MessageCall(
                 new Message("write[2]"),
                 Expression.Constant(console), 
                 Expression.MessageCall(
                   new Message("at[2]"),
                   Expression.Variable("tape"),
                   Expression.Variable("ptr")
                 )
            )
        )
    }
    
    next()
    {
        _tape.append(
            Expression.Assigning(
                "ptr",
                Expression.MessageCall(
                    new Message("add[2]"),
                    Expression.Variable("ptr"),
                    Expression.Constant(1))))
    }
    
    previous()
    {
        _tape.append(
            Expression.Assigning(
                "ptr",
                Expression.MessageCall(
                    new Message("subtract[2]"),
                    Expression.Variable("ptr"),
                    Expression.Constant(1))))
    }
    
    increase()
    {
        _tape.append(
            Expression.MessageCall(
                new Message("setAt[3]"),            
                Expression.Variable("tape"),
                Expression.Variable("ptr"), 
                Expression.MessageCall(
                    new Message("load[2]"),                    
                    Expression.Constant(CharValue),
                    Expression.MessageCall(
                        new Message("add[2]"),
                        Expression.MessageCall(                                    
                            new Message("toInt[2]"),                           
                            Expression.Constant(intConvertExt),
                            Expression.MessageCall(
                                new Message("at[2]"),
                                Expression.Variable("tape"),
                                Expression.Variable("ptr")
                            )
                        ),
                        Expression.Constant(1)
                    )
                )
            ));
    }
    
    decrease()
    {
        _tape.append(
            Expression.MessageCall(
                new Message("setAt[3]"),            
                Expression.Variable("tape"),
                Expression.Variable("ptr"), 
                Expression.MessageCall(
                    new Message("load[2]"),                    
                    Expression.Constant(CharValue),
                    Expression.MessageCall(
                        new Message("subtract[2]"),
                        Expression.MessageCall(                                    
                            new Message("toInt[2]"),                           
                            Expression.Constant(intConvertExt),
                            Expression.MessageCall(
                                new Message("at[2]"),
                                Expression.Variable("tape"),
                                Expression.Variable("ptr")
                            )
                        ),
                        Expression.Constant(1)
                    )
                )
            ));
    }
    
    compiled()
    {
        var program := DynamicSingleton.load(
                    Expression.Method(
                       "eval",
                       CodeblockExpression.new(_tape.Value),
                       ScopeIdentifier.Variable("tape"))
                    ).compile();           
                   
        ^(tape){ program.eval(tape) }
    }
}

public program()
{
    var bfAssemblyProgram := new ScriptEngine() 
        .loadPath("asmrules.es")
        .buildScript(bf_program);

    var bfProgram := TapeAssembler.load(bfAssemblyProgram).compiled();

    var bfTape := Array.allocate(1024).populate::(n => $0);

    console.writeLine(bf_program);

    bfProgram(bfTape)
}

The grammar: 

[[
   #grammar build
   #grammar cf

   #define start      ::= 
<= 
	system'dynamic'DynamicTape ( 
		system'dynamic'AllocFunction ( "1" ) 
		system'dynamic'LocalFunction ( "2" ) => command commands 
<=      ) =>;

   #define start      ::= $eof;

   #define commands   ::= command commands;
   #define commands   ::= comment commands;
   #define commands   ::= $eof;

   #define command    ::= <= system'dynamic'MessageFunction ( "output[1]"   ) => ".";
   #define command    ::= <= system'dynamic'MessageFunction ( "input[1]"    ) => ",";
   #define command    ::= <= system'dynamic'MessageFunction ( "previous[1]" ) => "<";
   #define command    ::= <= system'dynamic'MessageFunction ( "next[1]"     ) => ">";
   #define command    ::= <= system'dynamic'MessageFunction ( "increase[1]" ) => "+";
   #define command    ::= <= system'dynamic'MessageFunction ( "decrease[1]" ) => "-";
   #define command    ::= <= system'dynamic'MessageFunction ( "open[1]"     ) => "[";
   #define command    ::= <= system'dynamic'MessageFunction ( "close[1]"    ) => "]";

   #define comment    ::= " " comments;
   #define comment    ::= "'" comments;
   #define comment    ::= "!" comments;
   #define comment    ::= $eol;

   #define comments   ::= $chr comments;
   #define comments   ::= $eps;

   #mode symbolic;
]]
Output:
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
Hello World!
Retrieved from "https://rosettacode.org/wiki/Execute_Brain****/Elena?oldid=352221"