Data update

Task/Arithmetic-evaluation/Elena/arithmetic-evaluation.elena

@@ -4,338 +4,340 @@ import extensions'text;
 
 class Token
 {
-    object theValue;
+   object _value;
 
-    rprop int Level;
+   int Level : rprop;
 
-    constructor new(int level)
-    {
-        theValue := new StringWriter();
-        Level := level + 9;
-    }
+   constructor new(int level)
+   {
+      _value := new StringWriter();
+      Level := level + 9;
+   }
 
-    append(ch)
-    {
-        theValue.write(ch)
-    }
+   append(ch)
+   {
+      _value.write(ch)
+   }
 
-    Number = theValue.toReal();
+   Number = _value.toReal();
 }
 
 class Node
 {
-    prop object Left;
-    prop object Right;
-    rprop int Level;
+   object Left  : prop;
+   object Right : prop;
+   int Level    : rprop;
 
-    constructor new(int level)
-    {
-        Level := level
-    }
+   constructor new(int level)
+   {
+      Level := level
+   }
 }
 
 class SummaryNode : Node
 {
-    constructor new(int level)
-        <= new(level + 1);
+   constructor new(int level)
+      <= super new(level + 1);
 
-    Number = Left.Number + Right.Number;
+   Number = Left.Number + Right.Number;
 }
 
 class DifferenceNode : Node
 {
-    constructor new(int level)
-        <= new(level + 1);
+   constructor new(int level)
+      <= super new(level + 1);
 
-    Number = Left.Number - Right.Number;
+   Number = Left.Number - Right.Number;
 }
 
 class ProductNode : Node
 {
-    constructor new(int level)
-        <= new(level + 2);
+   constructor new(int level)
+      <= super new(level + 2);
 
-    Number = Left.Number * Right.Number;
+   Number = Left.Number * Right.Number;
 }
 
 class FractionNode : Node
 {
-    constructor new(int level)
-        <= new(level + 2);
+   constructor new(int level)
+      <= super new(level + 2);
 
-    Number = Left.Number / Right.Number;
+   Number = Left.Number / Right.Number;
 }
 
 class Expression
 {
-    rprop int Level;
-    prop object Top;
+   int Level  :rprop;
+   object Top :prop;
 
-    constructor new(int level)
-    {
-        Level := level
-    }
+   constructor new(int level)
+   {
+      Level := level
+   }
 
-    Right
-    {
-        get() = Top;
+   object Right
+   {
+      get() = Top;
 
-        set(object node)
-        {
-            Top := node
-        }
-    }
+      set(object node)
+      {
+         Top := node
+      }
+   }
 
-    get Number() => Top;
+   get Number() => Top;
 }
 
 singleton operatorState
 {
-    eval(ch)
-    {
-        ch =>
-            $40 {      // (
-                ^ __target.newBracket().gotoStarting()
-            }
-            : {
-                ^ __target.newToken().append(ch).gotoToken()
-            }
-    }
+   eval(ch)
+   {
+      ch =>
+         $40 {      // (
+            ^ weak self.newBracket().gotoStarting()
+         }
+         : {
+            ^ weak self.newToken().append(ch).gotoToken()
+         }
+   }
 }
 
 singleton tokenState
 {
-    eval(ch)
-    {
-        ch =>
-            $41 {      // )
-                ^ __target.closeBracket().gotoToken()
-            }
-            $42 {      // *
-                ^ __target.newProduct().gotoOperator()
-            }
-            $43 {      // +
-                ^ __target.newSummary().gotoOperator()
-            }
-            $45 {      // -
-                ^ __target.newDifference().gotoOperator()
-            }
-            $47 {      // /
-                ^ __target.newFraction().gotoOperator()
-            }
-            : {
-                ^ __target.append:ch
-            }
-    }
+   eval(ch)
+   {
+      ch =>
+         $41 {      // )
+            ^ weak self.closeBracket().gotoToken()
+         }
+         $42 {      // *
+            ^ weak self.newProduct().gotoOperator()
+         }
+         $43 {      // +
+            ^ weak self.newSummary().gotoOperator()
+         }
+         $45 {      // -
+            ^ weak self.newDifference().gotoOperator()
+         }
+         $47 {      // /
+            ^ weak self.newFraction().gotoOperator()
+         }
+         : {
+            ^ weak self.append:ch
+         }
+   }
 }
 
 singleton startState
 {
-    eval(ch)
-    {
-        ch =>
-            $40 {      // (
-                ^ __target.newBracket().gotoStarting()
-            }
-            $45 { // -
-                ^ __target.newToken().append("0").newDifference().gotoOperator()
-            }
-            : {
-                ^ __target.newToken().append:ch.gotoToken()
-            }
-    }
+   eval(ch)
+   {
+      ch =>
+         $40 {      // (
+            ^ weak self.newBracket().gotoStarting()
+         }
+         $45 { // -
+            ^ weak self.newToken().append("0").newDifference().gotoOperator()
+         }
+         : {
+            ^ weak self.newToken().append:ch.gotoToken()
+         }
+   }
 }
 
 class Scope
 {
-    object theState;
-    int    theLevel;
-    object theParser;
-    object theToken;
-    object theExpression;
+   object _state;
+   int    _level;
+   object _parser;
+   object _token;
+   object _expression;
 
-    constructor new(parser)
-    {
-        theState := startState;
-        theLevel := 0;
-        theExpression := Expression.new(0);
-        theParser := parser
-    }
+   constructor new(parser)
+   {
+      _state := startState;
+      _level := 0;
+      _expression := Expression.new(0);
+      _parser := parser
+   }
 
-    newToken()
-    {
-        theToken := theParser.appendToken(theExpression, theLevel)
-    }
+   newToken()
+   {
+      _token := _parser.appendToken(_expression, _level)
+   }
 
-    newSummary()
-    {
-        theToken := nil;
+   newSummary()
+   {
+      _token := nil;
 
-        theParser.appendSummary(theExpression, theLevel)
-    }
+      _parser.appendSummary(_expression, _level)
+   }
 
-    newDifference()
-    {
-        theToken := nil;
+   newDifference()
+   {
+      _token := nil;
 
-        theParser.appendDifference(theExpression, theLevel)
-    }
+      _parser.appendDifference(_expression, _level)
+   }
 
-    newProduct()
-    {
-        theToken := nil;
+   newProduct()
+   {
+      _token := nil;
 
-        theParser.appendProduct(theExpression, theLevel)
-    }
+      _parser.appendProduct(_expression, _level)
+   }
 
-    newFraction()
-    {
-        theToken := nil;
+   newFraction()
+   {
+      _token := nil;
 
-        theParser.appendFraction(theExpression, theLevel)
-    }
+      _parser.appendFraction(_expression, _level)
+   }
 
-    newBracket()
-    {
-        theToken := nil;
+   newBracket()
+   {
+      _token := nil;
 
-        theLevel := theLevel + 10;
+      _level := _level + 10;
 
-        theParser.appendSubexpression(theExpression, theLevel)
-    }
+      _parser.appendSubexpression(_expression, _level)
+   }
 
-    closeBracket()
-    {
-        if (theLevel < 10)
-            { InvalidArgumentException.new:"Invalid expression".raise() };
+   closeBracket()
+   {
+      if (_level < 10)
+         { InvalidArgumentException.new:"Invalid expression".raise() };
 
-        theLevel := theLevel - 10
-    }
+      _level := _level - 10
+   }
 
-    append(ch)
-    {
-        if(ch >= $48 && ch < $58)
-        {
-            theToken.append:ch
-        }
-        else
-        {
-            InvalidArgumentException.new:"Invalid expression".raise()
-        }
-    }
+   append(ch)
+   {
+      if(ch >= $48 && ch < $58)
+      {
+         _token.append:ch
+      }
+      else
+      {
+         InvalidArgumentException.new:"Invalid expression".raise()
+      }
+   }
 
-    append(string s)
-    {
-        s.forEach:(ch){ self.append:ch }
-    }
+   append(string s)
+   {
+      s.forEach:(ch){ self.append:ch }
+   }
 
-    gotoStarting()
-    {
-        theState := startState
-    }
+   gotoStarting()
+   {
+      _state := startState
+   }
 
-    gotoToken()
-    {
-        theState := tokenState
-    }
+   gotoToken()
+   {
+      _state := tokenState
+   }
 
-    gotoOperator()
-    {
-        theState := operatorState
-    }
+   gotoOperator()
+   {
+      _state := operatorState
+   }
 
-    get Number() => theExpression;
+   get Number() => _expression;
 
-    dispatch() => theState;
+   dispatch() => _state;
 }
 
 class Parser
 {
-    appendToken(object expression, int level)
-    {
-        var token := Token.new(level);
+   appendToken(object expression, int level)
+   {
+      var token := Token.new(level);
 
-        expression.Top := self.append(expression.Top, token);
+      expression.Top := self.append(expression.Top, token);
 
-        ^ token
-    }
+      ^ token
+   }
 
-    appendSummary(object expression, int level)
-    {
-        expression.Top := self.append(expression.Top, SummaryNode.new(level))
-    }
+   appendSummary(object expression, int level)
+   {
+      var t := expression.Top;
 
-    appendDifference(object expression, int level)
-    {
-        expression.Top := self.append(expression.Top, DifferenceNode.new(level))
-    }
+      expression.Top := self.append(/*expression.Top*/t, SummaryNode.new(level))
+   }
 
-    appendProduct(object expression, int level)
-    {
-        expression.Top := self.append(expression.Top, ProductNode.new(level))
-    }
+   appendDifference(object expression, int level)
+   {
+      expression.Top := self.append(expression.Top, DifferenceNode.new(level))
+   }
 
-    appendFraction(object expression, int level)
-    {
-        expression.Top := self.append(expression.Top, FractionNode.new(level))
-    }
+   appendProduct(object expression, int level)
+   {
+      expression.Top := self.append(expression.Top, ProductNode.new(level))
+   }
 
-    appendSubexpression(object expression, int level)
-    {
-        expression.Top := self.append(expression.Top, Expression.new(level))
-    }
+   appendFraction(object expression, int level)
+   {
+      expression.Top := self.append(expression.Top, FractionNode.new(level))
+   }
 
-    append(lastNode, newNode)
-    {
-        if(nil == lastNode)
-            { ^ newNode };
+   appendSubexpression(object expression, int level)
+   {
+      expression.Top := self.append(expression.Top, Expression.new(level))
+   }
 
-        if (newNode.Level <= lastNode.Level)
-            { newNode.Left := lastNode; ^ newNode };
+   append(object lastNode, object newNode)
+   {
+      if(nil == lastNode)
+         { ^ newNode };
 
-        var parent := lastNode;
-        var current := lastNode.Right;
-        while (nil != current && newNode.Level > current.Level)
-            { parent := current; current := current.Right };
+      if (newNode.Level <= lastNode.Level)
+         { newNode.Left := lastNode; ^ newNode };
 
-        if (nil == current)
-        {
-            parent.Right := newNode
-        }
-        else
-        {
-            newNode.Left := current; parent.Right := newNode
-        };
+      var parent := lastNode;
+      var current := lastNode.Right;
+      while (nil != current && newNode.Level > current.Level)
+         { parent := current; current := current.Right };
 
-        ^ lastNode
-    }
+      if (nil == current)
+      {
+         parent.Right := newNode
+      }
+      else
+      {
+         newNode.Left := current; parent.Right := newNode
+      };
 
-    run(text)
-    {
-        var scope := Scope.new(self);
+      ^ lastNode
+   }
 
-        text.forEach:(ch){ scope.eval:ch };
+   run(text)
+   {
+      var scope := Scope.new(self);
 
-        ^ scope.Number
-    }
+      text.forEach:(ch){ scope.eval:ch };
+
+      ^ scope.Number
+   }
 }
 
 public program()
 {
-    var text := new StringWriter();
-    var parser := new Parser();
+   var text := new StringWriter();
+   var parser := new Parser();
 
-    while (console.readLine().saveTo(text).Length > 0)
-    {
-        try
-        {
-            console.printLine("=",parser.run:text)
-        }
-        catch(Exception e)
-        {
-            console.writeLine:"Invalid Expression"
-        };
+   while (console.readLine().writeTo(text).Length > 0)
+   {
+      try
+      {
+         console.printLine("=",parser.run:text)
+      }
+      catch(Exception e)
+      {
+         console.writeLine:"Invalid Expression"
+      };
 
-        text.clear()
-    }
+      text.clear()
+   }
 }

Task/Arithmetic-evaluation/Elixir/arithmetic-evaluation.elixir

@@ -0,0 +1,13 @@
+defmodule Ast do
+  def main do
+    expr = IO.gets("Give an expression:\n") |> String.Chars.to_string |> String.trim
+    case Code.string_to_quoted(expr) do
+      {:ok, ast} ->
+        IO.puts("AST is: " <> inspect(ast))
+        {result, _} = Code.eval_quoted(ast)
+        IO.puts("Result = #{result}")
+      {:error, {_meta, message_info, _token}} ->
+        IO.puts(message_info)
+    end
+  end
+end

Task/Arithmetic-evaluation/FutureBasic/arithmetic-evaluation.basic

@@ -0,0 +1,32 @@
+_window = 1
+begin enum 1
+  _expressionLabel
+  _expressionFld
+  _resultLabel
+end enum
+
+void local fn BuildUI
+  editmenu 1
+  window _window, @"Arithmetic Evaluation", (0,0,522,61)
+  textlabel _expressionLabel, @"Expression:", (18,23,74,16)
+  textfield _expressionFld,,, (98,20,300,21)
+  textlabel _resultLabel,, (404,23,100,16)
+  WindowMakeFirstResponder( _window, _expressionFld )
+end fn
+
+void local fn EvaluateExpression( string as CFStringRef )
+  ExpressionRef expression = fn ExpressionWithFormat( string )
+  textlabel _resultlabel, fn StringWithFormat( @"= %@", fn ExpressionValueWithObject( expression, NULL, NULL ) )
+end fn
+
+void local fn DoDialog( ev as long, tag as long )
+  select ( ev )
+    case _btnClick : fn EvaluateExpression( textfield(tag) )
+  end select
+end fn
+
+fn BuildUI
+
+on dialog fn DoDialog
+
+HandleEvents