Rosetta Code

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

Page Discussion

Execute Brain****/Elena (view source)

Revision as of 10:41, 25 January 2024

207 bytes removed ,  3 months ago
m
no edit summary
No edit summary
imported>Arakov
mNo edit summary
 
(7 intermediate revisions by 3 users not shown)
Line 1:
ELENA 6.x:
<lang elena>import system'collections.
<syntaxhighlight lang="elena">import system'routines.collections;
import system'dynamic.routines;
import system'dynamic'expressions;
 
import extensions.
import extensions'scripting.;
import extensions'dynamic'expressions.scripting;
 
const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.".;▼
 
class TapeAssembler
{
stackStack theBrackets._brackets;
listList<TapeExpressionExpression> theTape._tape;
constructor new()
[{
theBrackets_brackets := Stack new. Stack();
theTape_tape := listnew List<TapeExpressionExpression>().;
theTape _tape.append(TapeExpression Declaring("ptr"))Expression.DeclareAndAssigning(
] "ptr",▼
theTape append(TapeExpression Assigning("ptr", TapeExpression Constant(0))).
Expression.Constant(0)));
]}
constructor new : load(assembly_program)
<= new;{
assembly_program(self)
[▼
} assembly_program($self).
▲ ]
open()
[{
theBrackets _brackets.push(theTape_tape).;
theTape_tape := listnew List<TapeExpressionExpression>().;
]}
close()
[{
var loop := TapeExpression Expression.Loop(
TapeExpression Expression.MessageCall(
TapeExpressionnew MessageCallMessage("notequal[2]"),
TapeExpression VariableExpression.MessageCall("tape"),
new Message("getAtat[2]"),
TapeExpression Expression.Variable("ptrtape"),
TapeExpression MessageCallExpression.Variable("ptr")▼
),
"notequal",Expression.Constant($0)
TapeExpression Constant($0)),
TapeExpression CodeCodeblockExpression.new(theTape array_tape.Value)).;
theTape_tape := theBrackets _brackets.pop.();
theTape _tape.append(loop).
]}
input()
[{
theTape _tape.append(TapeExpression MessageCall(
Expression.MessageCall(
TapeExpression Variable("tape"),▼
new Message("setAt[3]"),
TapeExpression Expression.Variable("ptrtape"),
TapeExpression MessageCallExpression.Variable("ptr"),
TapeExpression ConstantExpression.MessageCall(console),
new Message("readChar[1]"),
Expression.Constant(console))).
] )
)
)
▲ [}
output()
[{
theTape _tape.append(TapeExpression MessageCall(
TapeExpression Expression.MessageCall(▼
TapeExpression Constant(console),
new Message("write[2]"),
Expression.Constant(console), TapeExpression MessageCall(
TapeExpression VariableExpression.MessageCall("tape"),
new Message("getAtat[2]"),
TapeExpression Expression.Variable("ptrtape"),
Expression.Variable("ptr"))).
] )
)
] )▼
]}▼
next()
[{
theTape _tape.append(TapeExpression Assigning(
"ptr",Expression.Assigning(
TapeExpression MessageCall( "ptr",
TapeExpression VariableExpression.MessageCall("ptr"),
new Message("add[2]"),
TapeExpression Constant Expression.Variable(1"ptr")))).,
▲ TapeExpression Expression.Constant(console1)))),
▲ ]
]}▼
previous()
[{
theTape _tape.append(TapeExpression Assigning(
"ptr",Expression.Assigning(
TapeExpression MessageCall( "ptr",
TapeExpression VariableExpression.MessageCall("ptr"),
new Message("subtract[2]"),
TapeExpression Constant Expression.Variable(1"ptr")))).,
Expression.Constant(1))))
▲ ]
]}▼
increase()
[{
theTape _tape.append(TapeExpression MessageCall(
TapeExpression VariableExpression.MessageCall("tape"),
new Message("setAt[3]"), "setAt",
TapeExpression Expression.Variable("ptrtape"),
▲ TapeExpression Expression.Variable("tapeptr"),
▲ TapeExpression MessageCall(
TapeExpression ConstantExpression.MessageCall(CharValue),
new Message("load[2]"), "new",
TapeExpression MessageCallExpression.Constant(CharValue),
TapeExpression Expression.MessageCall(
new TapeExpression ConstantMessage(convertor"add[2]"),
Expression.MessageCall( "toInt",
new Message("toInt[2]"), TapeExpression MessageCall(
TapeExpression VariableExpression.Constant("tape"intConvertExt),
"getAt",Expression.MessageCall(
new TapeExpression VariableMessage("ptrat[2]")),
Expression.Variable("tape"),
Expression.Variable("addptr",)
TapeExpression Constant(1))))).
),
▲ ]
Expression.Constant(1)
)
)
));
]}▼
decrease()
[{
theTape _tape.append(TapeExpression MessageCall(
TapeExpression VariableExpression.MessageCall("tape"),
new Message("setAt[3]"), "setAt",
TapeExpression Expression.Variable("ptrtape"),
Expression.Variable("ptr"),
▲ TapeExpression MessageCall(
TapeExpression ConstantExpression.MessageCall(CharValue),
new Message("load[2]"), "new",
TapeExpression MessageCallExpression.Constant(CharValue),
TapeExpression Expression.MessageCall(
new TapeExpression ConstantMessage(convertor"subtract[2]"),
Expression.MessageCall( "toInt",
new Message("toInt[2]"), TapeExpression MessageCall(
TapeExpression VariableExpression.Constant("tape"intConvertExt),
"getAt",Expression.MessageCall(
new TapeExpression VariableMessage("ptrat[2]")),
Expression.Variable("tape"),
Expression.Variable("subtractptr",)
TapeExpression Constant(1))))).
),
 
Expression.Constant(1)
▲ ]
)
)
));
}▼
getcompiled()
[{
var program := TapeExpression SingletonDynamicSingleton.load(
TapeExpression Expression.Method(
"eval",
TapeExpression Code(theTape array CodeblockExpression.new(_tape.Value),
TapeExpression Parameter ScopeIdentifier.Variable("tape"))).
).compile();
var^(tape){ o := (program compiled).eval(tape). }
}
^(:tape) [ o eval(tape) ]
▲ ]
}
 
programpublic =program()▼
▲const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.".
{
▲
var bfAssemblyProgram := scriptEnginenew ScriptEngine() ▼
▲program =
load path:.loadPath("asmrules.es";)▼
[
eval.buildScript(bf_program).;▼
console
writeLine:bf_program.▼
 
var bfProgram := TapeAssembler new.load(bfAssemblyProgram); get.compiled();▼
▲ var bfAssemblyProgram := scriptEngine
▲ load path:"asmrules.es";
▲ eval(bf_program).
 
var bfTape := Array new:.allocate(1024; ).populate(::(n)<int =>( $0).;▼
▲ var bfProgram := TapeAssembler new(bfAssemblyProgram); get.
 
▲ console.writeLine:(bf_program.);
▲ var bfTape := Array new:1024; populate(:n)<int>($0).
 
bfProgram(bfTape).
}</syntaxhighlight>
].</lang>
The grammar:
<langsyntaxhighlight lang="elena">[[
#grammar transformbuild
#grammar cf
 
#define start ::= <= ( > => commands <= " * system'dynamic'ClosureTape= " # ) =>;
<=
system'dynamic'DynamicTape (
system'dynamic'AllocFunction ( "1" )
system'dynamic'LocalFunction ( "2" ) => command commands
<= ) =>;
 
#define start ::= $eof;
 
#define commands ::= command commands;
Line 181 ⟶ 204:
#define commands ::= $eof;
 
#define command ::= <= += " %""output[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newoutput[1]"" " ) => ".";
#define command ::= <= += " %""input[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newinput[1]"" " ) => ",";
#define command ::= <= += " %""previous[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newprevious[1]"" ") => "<";
#define command ::= <= += " %""next[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newnext[1]"" " ) => ">";
#define command ::= <= += " %""increase[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newincrease[1]"" ") => "+";
#define command ::= <= += " %""decrease[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newdecrease[1]"" ") => "-";
#define command ::= <= += " %""open[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newopen[1]"" " ) => "[";
#define command ::= <= += " %""close[0]"" system'dynamic'MessageClosureMessageFunction ( ^""newclose[1]"" " ) => "]";
 
#define comment ::= " " comments;
Line 199 ⟶ 222:
 
#mode symbolic;
]]</langsyntaxhighlight>
{{out}}
<pre>
ELENA VM 3.2.15 (C)2005-2017 by Alex Rakov
Initializing...
Debug mode...
Done...
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
Hello World!
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/236491...352221"