Rosetta Code

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

Page Discussion

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

Revision as of 10:41, 25 January 2024

98 bytes removed ,  4 months ago
m
no edit summary
mNo edit summary
imported>Arakov
mNo edit summary
 
(6 intermediate revisions by 3 users not shown)
Line 1:
ELENA 6.x:
<langsyntaxhighlight lang="elena">import system'collections;
import system'routines;
import system'dynamic'expressions;
 
import extensions;
import extensions'scripting;
 
import extensions'dynamic'expressions;
const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.";▼
 
class TapeAssembler
{
Stack theBrackets_brackets;
List<TapeExpressionExpression> theTape_tape;
constructor()
{
theBrackets_brackets := new Stack();
theTape_tape := new List<TapeExpressionExpression>();
<= ()▼
theTape_tape.append(TapeExpressionExpression.DeclaringDeclareAndAssigning("ptr"));
"ptr",
theTape.append(TapeExpression.Assigning("ptr", TapeExpression.Constant(0)))
Expression.Constant(0)));
}
constructor load(assembly_program)
▲ <= ()
{
assembly_program(self)
}
open()
{
theBrackets_brackets.push(theTape_tape);
theTape_tape := new List<TapeExpressionExpression>();
}
close()
{
var loop := TapeExpressionExpression.Loop(
TapeExpressionExpression.MessageCall(
TapeExpression.MessageCallnew Message("notequal[2]"),
TapeExpressionExpression.VariableMessageCall("tape"),
new Message("at[2]"),
TapeExpressionExpression.Variable("ptrtape"),
TapeExpressionExpression.ConstantVariable(console"ptr"), ▼
),
"notequal",Expression.Constant($0)
TapeExpression.Constant($0)),
TapeExpressionCodeblockExpression.Codenew(theTape_tape.Value));
theTape_tape := theBrackets_brackets.pop();
theTape_tape.append(loop)
}
input()
{
theTape_tape.append(TapeExpression.MessageCall(
TapeExpressionExpression.VariableMessageCall("tape"),
new Message("setAt[3]"),
TapeExpressionExpression.Variable("ptrtape"),
TapeExpressionExpression.MessageCallVariable("ptr"),
TapeExpressionExpression.ConstantMessageCall(console),
new Message("readChar[1]"),
))Expression.Constant(console)
)
)
)
}
output()
{
theTape_tape.append(TapeExpression.MessageCall(
Expression.MessageCall(
▲ TapeExpression.Constant(console),
new Message("write[2]"),
TapeExpressionExpression.MessageCallConstant(console),
TapeExpressionExpression.VariableMessageCall("tape"),
new Message("at[2]"),
TapeExpressionExpression.Variable("ptrtape"),
))Expression.Variable("ptr")
)
)
)
}
next()
{
theTape_tape.append(TapeExpression.Assigning(
"ptr",Expression.Assigning(
TapeExpression.MessageCall( "ptr",
TapeExpressionExpression.VariableMessageCall("ptr"),
new Message("add[2]"),
TapeExpression Expression.ConstantVariable(1)))"ptr"),
Expression.Constant(1))))
}
previous()
{
theTape_tape.append(TapeExpression.Assigning(
"ptr",Expression.Assigning(
TapeExpression.MessageCall( "ptr",
TapeExpressionExpression.VariableMessageCall("ptr"),
new Message("subtract[2]"),
TapeExpression Expression.ConstantVariable(1)))"ptr"),
Expression.Constant(1))))
}
increase()
{
theTape_tape.append(TapeExpression.MessageCall(
TapeExpressionExpression.VariableMessageCall("tape"),
new Message("setAt[3]"), "setAt",
TapeExpressionExpression.Variable("ptrtape"),
TapeExpressionExpression.MessageCallVariable("ptr"),
TapeExpressionExpression.ConstantMessageCall(CharValue),
new Message("load[2]"), "load",
TapeExpressionExpression.MessageCallConstant(CharValue),
TapeExpressionExpression.MessageCall(
new TapeExpression.ConstantMessage(convertor"add[2]"),
Expression.MessageCall( "toInt",
new Message("toInt[2]"), TapeExpression.MessageCall(
TapeExpressionExpression.VariableConstant("tape"intConvertExt),
"at",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(
TapeExpressionExpression.VariableMessageCall("tape"),
new Message("setAt[3]"), "setAt",
TapeExpressionExpression.Variable("ptrtape"),
TapeExpressionExpression.MessageCallVariable("ptr"),
TapeExpressionExpression.ConstantMessageCall(CharValue),
new Message("load[2]"), "load",
TapeExpressionExpression.MessageCallConstant(CharValue),
TapeExpressionExpression.MessageCall(
new TapeExpression.ConstantMessage(convertor"subtract[2]"),
Expression.MessageCall( "toInt",
new Message("toInt[2]"), TapeExpression.MessageCall(
TapeExpressionExpression.VariableConstant("tape"intConvertExt),
"at",Expression.MessageCall(
new TapeExpression.VariableMessage("ptrat[2]")),
Expression.Variable("tape"),
Expression.Variable("subtractptr",)
TapeExpression.Constant(1)))))
),
Expression.Constant(1)
)
)
));
}
getcompiled()
{
var program := TapeExpressionDynamicSingleton.Singletonload(
TapeExpression Expression.Method(
"eval",
TapeExpression CodeblockExpression.Codenew(theTape_tape.Value),
TapeExpression ScopeIdentifier.ParameterVariable("tape")));
).compile();
var o := (program.compiled())();
^(tape){ oprogram.eval(tape) }▼
▲ ^(tape){ o.eval(tape) }
}
}
 
▲const bf_program = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.";
public program()
{
var bfAssemblyProgram := new ScriptEngine() ▼
console.writeLine:bf_program;▼
.loadPath:("asmrules.es")▼
.evalbuildScript(bf_program);▼
▲ var bfAssemblyProgram := new ScriptEngine()
 
▲ .loadPath:"asmrules.es"
var bfProgram := TapeAssembler.load(bfAssemblyProgram).compiled();
▲ .eval(bf_program);
 
var bfProgrambfTape := new TapeAssemblerArray.allocate(bfAssemblyProgram1024).getpopulate::(n => $0);
 
▲ console.writeLine:(bf_program);
var bfTape := Array.allocate(1024).populate:(int n => $0);
 
bfProgram(bfTape)
}</langsyntaxhighlight>
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 180 ⟶ 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 198 ⟶ 222:
 
#mode symbolic;
]]</langsyntaxhighlight>
{{out}}
<pre>
ELENA VM 4.0.14 (C)2005-2019 by Alex Rakov
Initializing...
Done...
++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.
Hello World!
Anonymous user
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/236492...352221"