source: EcnlProtoTool/trunk/webapp/webmrbc/Ruby/Logic.cs@ 270

// Porting from 
// https://github.com/jeanlazarou/blockly2ruby
// Copyright (c) 2014 Jean Lazarou
// MIT Lisence
using System;
using Bridge;
using System.Collections.Generic;

namespace WebMrbc
{
        partial class Ruby
        {
                public node controls_if(ControlsIfBlock block)
                {
                        // If/elseif/else condition.
                        node code = null;
                        if (block.elseCount_ != 0) {
                                code = statementToCode(block, "ELSE");
                                if (code == null) code = new nil_node(this);
                        }
                        for (var n = block.elseifCount_; n >= 0; n--) {
                                var argument = valueToCode(block, "IF" + n);
                                if (argument == null) argument = new false_node(this);
                                var branch = statementToCode(block, "DO" + n);
                                code = new if_node(this, argument, branch, code, false);
                        }
                        return code;
                }

                public node logic_compare(LogicCompareBlock block)
                {
                        // Comparison operator.
                        var OPERATORS = new Dictionary<string, string>() {
                                { "EQ", "==" },
                                { "NEQ", "!=" },
                                { "LT", "<" },
                                { "LTE", "<=" },
                                { "GT", ">" },
                                { "GTE", ">=" },
                        };
                        var @operator = OPERATORS[block.getFieldValue("OP")];
                        var argument0 = valueToCode(block, "A");
                        if (argument0 == null) argument0 = new int_node(this, 0);
                        var argument1 = valueToCode(block, "B");
                        if (argument1 == null) argument1 = new int_node(this, 0);
                        return new call_node(this, argument0, intern(@operator), argument1);
                }

                public node logic_operation(LogicOperationBlock block)
                {
                        // Operations 'and', 'or'.
                        var @operator = (block.getFieldValue("OP") == "AND") ? "&&" : "||";
                        var argument0 = valueToCode(block, "A");
                        var argument1 = valueToCode(block, "B");
                        if (argument0 == null && argument1 == null) {
                                // If there are no arguments, then the return value is false.
                                argument0 = new false_node(this);
                                argument1 = new false_node(this);
                        }
                        else {
                                // Single missing arguments have no effect on the return value.
                                var defaultArgument = (@operator == "&&") ? (node)new true_node(this) : (node)new false_node(this);
                                if (argument0 == null) {
                                        argument0 = defaultArgument;
                                }
                                if (argument1 == null) {
                                        argument1 = defaultArgument;
                                }
                        }
                        if (@operator == "&&")
                                return new and_node(this, argument0, argument1);
                        else
                                return new or_node(this, argument0, argument1);
                }

                public node logic_negate(LogicNegateBlock block)
                {
                        // Negation.
                        var argument0 = valueToCode(block, "BOOL");
                        if (argument0 == null) argument0 = new true_node(this);
                        return new call_node(this, argument0, intern("!"), (node)null);
                }

                public node logic_boolean(LogicBooleanBlock block)
                {
                        // Boolean values true and false.
                        return (block.getFieldValue("BOOL") == "TRUE") ? (node)new true_node(this) : (node)new false_node(this);
                }

                public node logic_null(LogicNullBlock block)
                {
                        // Null data type.
                        return new nil_node(this);
                }

                public node logic_ternary(LogicTernaryBlock block)
                {
                        // Ternary operator.
                        var value_if = valueToCode(block, "IF");
                        if (value_if == null) value_if = new false_node(this);
                        var value_then = valueToCode(block, "THEN");
                        if (value_then == null) value_then = new nil_node(this);
                        var value_else = valueToCode(block, "ELSE");
                        if (value_else == null) value_else = new nil_node(this);
                        return new if_node(this, value_if, value_then, value_else, true);
                }
        }
}