コード例 #1
0
 //  = %*type%
 private SkriptPattern GetDefaultValuePatternForType(SkriptType type)
 {
     return(new SkriptPattern
     {
         Children =
         {
             new LiteralPatternElement(" "),
             new LiteralPatternElement("="),
             new LiteralPatternElement(" "),
             new TypePatternElement
             {
                 Type = type.FinalTypeName, Constraint = SyntaxValueAcceptanceConstraint.LiteralsOnly
             }
         }
     });
 }
コード例 #2
0
 public IReadOnlyList <SyntaxSkriptExpression> GetExpressionsThatCanFitType(SkriptType type)
 {
     return(GetExpressionsThatCanFitType(type.ClassName));
 }
コード例 #3
0
        private static IExpression TryMatchExpressionOnFile(ParseContext ctx, SkriptTypesManager skriptTypesManager,
                                                            ParseContext clone, int currentPos, SkriptType skriptType)
        {
            IExpression result = null;

            //If we're dealing with a file, try matching event values too
            if (ctx is FileParseContext fileParseContext)
            {
                var currentNode = fileParseContext.File.Nodes[fileParseContext.CurrentLine];

                if (currentNode?.RootParentSyntax?.Element is SkriptEvent rootEvent)
                {
                    var typesAndExpressions = skriptTypesManager.GetEventExpressionsForEvent(rootEvent);

                    var exprs = typesAndExpressions;

                    if (exprs != null)
                    {
                        foreach (var(_, expressions) in exprs)
                        {
                            if (expressions != null)
                            {
                                foreach (var expression in expressions)
                                {
                                    clone.CurrentPosition = currentPos;
                                    clone.StartRangeMeasure("Event-Value Expression");
                                    clone.Matches.Clear();

                                    clone.VisitExpression(skriptType, expression);

                                    for (var index = 0; index < expression.PatternNodes.Length; index++)
                                    {
                                        var pattern     = expression.PatternNodes[index];
                                        var resultValue = pattern.Parse(clone);
                                        if (resultValue.IsSuccess)
                                        {
                                            var range = clone.EndRangeMeasure("Event-Value Expression");
                                            ctx.ReadUntilPosition(clone.CurrentPosition);

                                            result = new SkriptExpression(expression, range, ctx);
                                        }
                                    }

                                    clone.UndoRangeMeasure();
                                }
                            }
                        }
                    }
                }
            }

            return(result);
        }