Esempio n. 1
0
        private IRppExpr MatchInstance(RppMember inVar, RppMember outOut, IRppExpr thenExpr, RppMatchingContext ctx)
        {
            // If type of input variable do not match pattern type, we need to cast it
            if (!inVar.Type.Equals(_type))
            {
                string localVar = ctx.CreateLocal(_type.Name.Name);
                var castedVariable = Val(localVar, _type.Value, new RppAsInstanceOf(inVar, _type));

                return If(BinOp("!=", new RppAsInstanceOf(inVar, _type), NullTy), Block(castedVariable, ProcessMatchExpr(Id(localVar), outOut, thenExpr, ctx)));
            }

            return ProcessMatchExpr(inVar, outOut, thenExpr, ctx);
        }
Esempio n. 2
0
        private IRppExpr ProcessCases(RppMember inVar, RppMember outOut, IRppExpr thenExpr, RppMatchingContext ctx, string localOptionVar, int patternIndex)
        {
            if (patternIndex >= _patterns.Length)
            {
                List<IRppNode> nodes = new List<IRppNode>();

                // Binding to a variable if it exists varid@Foo...
                if (BindedVariableToken != null)
                {
                    var varId = Val(BindedVariableToken, _type.Value, inVar);
                    nodes.Add(varId);
                }

                nodes.Add(thenExpr);
                nodes.Add(Break);
                return Block(nodes);
            }

            IRppExpr classParamValue = GetClassParam(localOptionVar, patternIndex, _patterns.Length);

            RppMatchPattern pattern = _patterns[patternIndex];
            int nextPatternIndex = patternIndex + 1;

            if (pattern is RppLiteralPattern)
            {
                RppLiteralPattern literalPattern = (RppLiteralPattern) pattern;
                return If(BinOp("==", literalPattern.Literal, classParamValue), ProcessCases(inVar, outOut, thenExpr, ctx, localOptionVar, nextPatternIndex));
            }

            RType classParamType = _classParamTypes[patternIndex];

            if (pattern is RppVariablePattern)
            {
                RType patternType = classParamType;
                RppVar var = Val(pattern.Token.Text, patternType, classParamValue);
                var.Token = pattern.Token;
                return Block(var, ProcessCases(inVar, outOut, thenExpr, ctx, localOptionVar, nextPatternIndex));
            }

            if (pattern is RppConstructorPattern)
            {
                RppConstructorPattern constructorPattern = (RppConstructorPattern) pattern;
                string classParamArg = ctx.CreateLocal(classParamType.Name);
                RppVar classParamArgVar = Val(classParamArg, classParamType, classParamValue);
                RppId classParamInput = StaticId(classParamArgVar);

                IRppExpr nextPattern = ProcessCases(inVar, outOut, thenExpr, ctx, localOptionVar, nextPatternIndex);
                return Block(classParamArgVar, constructorPattern.MatchInstance(classParamInput, outOut, nextPattern, ctx));
            }

            return ProcessCases(inVar, outOut, thenExpr, ctx, localOptionVar, nextPatternIndex);
        }