protected override void GenerateOperator(BinaryExpression node, TypeExpression result)
        {
            BitwiseOperator bitwiseOperator = ((BitwiseExpression)node).Operator;

            switch (bitwiseOperator)
            {
            case BitwiseOperator.BitwiseOr:
                this.codeGenerator.or(this.indent);
                break;

            case BitwiseOperator.BitwiseAnd:
                this.codeGenerator.and(this.indent);
                break;

            case BitwiseOperator.BitwiseXOr:
                this.codeGenerator.xor(this.indent);
                break;

            case BitwiseOperator.ShiftLeft:
                this.codeGenerator.shl(this.indent);
                break;

            case BitwiseOperator.ShiftRight:
                this.codeGenerator.shr(this.indent);
                break;

            default:
                break;
            }

            if (!IsValueType(node.ExpressionType))
            {
                this.codeGenerator.Box(indent, IntType.Instance);
            }
        }
 public GenericHelper(TEnum rangeStart, TEnum rangeEnd)
     : base(
         new RangeCoercion <RedirectedControlCoercion <TEnum, TValue>, TValue>(
             r => (TValue)r.Values[rangeStart],
             r => (TValue)r.Values[rangeEnd]),
         BitwiseOperator <TEnum> .Or(rangeStart, rangeEnd))
 {
 }
        public BitwiseEvaluationStatement(EvaluationStatement left, BitwiseOperator @operator,
                                          EvaluationStatement right, StatementInfo info, IStatement parentStatement = null)
        {
            Left            = left;
            Operator        = @operator;
            Right           = right;
            Info            = info;
            ParentStatement = parentStatement;

            TraversableChildren = StatementHelpers.CreateChildren(left, @operator, right);
        }
Example #4
0
        public void SetIntents(byte first, byte last, Voice voice = null)
        {
            voice ??= this.voice;
            for (int i = first; i < last; i++)
            {
                if (ops[i] == null || ops[i].intent != voice.alg.intent[i])
                {
                    switch ((OpBase.Intents)voice.alg.intent[i])
                    {
                    case OpBase.Intents.FM_OP:
                        var op = new Operator();
                        ops[i] = op;
                        op.eg.Configure(voice.egs[i]);
                        op.pg        = voice.pgs[i]; //ByVal copy
                        op.wavetable = voice.wavetable;
                        break;

                    case OpBase.Intents.FILTER:
                        var f = new Filter();
                        ops[i] = f;
                        f.eg.Configure(voice.egs[i]);
                        f.SetOscillatorType(f.eg.aux_func);      //TODO:  Check if values out of range cause the filter to freak out
                        f.wavetable = voice.wavetable;
                        break;

                    case OpBase.Intents.BITWISE:      //Extends FM_OP
                        var op2 = new BitwiseOperator();
                        ops[i] = op2;
                        op2.eg.Configure(voice.egs[i]);
                        op2.pg        = voice.pgs[i]; //ByVal copy
                        op2.wavetable = voice.wavetable;
                        break;

                    case OpBase.Intents.WAVEFOLDER:
                        ops[i] = new WaveFolder();
                        ops[i].eg.Configure(voice.egs[i]);
                        ops[i].wavetable = voice.wavetable;
                        break;

                    default:
                        throw new NotImplementedException("Channel:  Attempting to create a new operator with no/invalid intent...");
                    }
                }
            }
        }
Example #5
0
        private static BinaryExpression BuildConcatExpression(Expression leftExpression, Expression rightExpression, BitwiseOperator bitwiseOperator = BitwiseOperator.AND)
        {
            Func <Expression, Expression, BinaryExpression> expression = Expression.AndAlso;

            if (bitwiseOperator == BitwiseOperator.OR)
            {
                expression = Expression.OrElse;
            }

            return(expression(leftExpression, rightExpression));
        }
 public SQLBitwiseExpression(SQLExpression objLeftExpression, BitwiseOperator eOperator, SQLExpression objRightExpression)
 {
     pobjLeft = objLeftExpression;
     peOperator = eOperator;
     pobjRight = objRightExpression;
 }
 public SQLBitwiseExpression(string strLeftFieldName, BitwiseOperator eOperator, SQLExpression objRightExpression)
     : this(new SQLFieldExpression(strLeftFieldName), eOperator, objRightExpression)
 {
 }
 public SQLBitwiseExpression(string strLeftFieldName, BitwiseOperator eOperator, object objRightValue)
     : this(new SQLFieldExpression(strLeftFieldName), eOperator, new SQLValueExpression(objRightValue))
 {
 }
Example #9
0
 /// <summary>
 /// Construtor padrĂ£o.
 /// </summary>
 /// <param name="functor"></param>
 /// <param name="generator"></param>
 /// <param name="bitwiseOperator"></param>
 public BitwiseFunction(IFunctor functor, IGenerator generator, BitwiseOperator bitwiseOperator)
 {
     _functor   = functor;
     _operator  = bitwiseOperator;
     _generator = generator;
 }
 /// <summary>
 /// Constructor of BitwiseExpression
 /// </summary>
 /// <param name="operand1">First operand.</param>
 /// <param name="operand2">Second operand.</param>
 /// <param name="op">Operator of the binary expression.</param>
 /// <param name="fileName">File name.</param>
 /// <param name="lineNumber">Line number.</param>
 /// <param name="columnNumber">Column number.</param>
 public BitwiseExpression(Expression operand1, Expression operand2, BitwiseOperator op, Location location)
     : base(operand1, operand2, location)
 {
     this.op = op;
 }