protected override EntityType TryParse(ParseContext ctx)
{
var clone = ctx.Clone();
var result = ParsePattern.Parse(clone);
if (result.IsSuccess)
{
var expressions = result.Matches.OfType <ExpressionParseMatch>().Select(c => c.Expression).ToList();
var entityData =
expressions.SelectMany(e => e.GetValues <EntityData>()).FirstOrDefault()?.Value as EntityData;
var amount = expressions.SelectMany(e => e.GetValues <double>()).Cast <Expression <double?> >()
.Select(c => c.GenericValue ?? 1d)
.DefaultIfEmpty(1).FirstOrDefault();
if (entityData == null)
{
return(null);
}
ctx.CurrentPosition = clone.CurrentPosition;
return(new EntityType(amount, expressions.SelectMany(e => e.GetValues <double>()).Any(), entityData));
}
return(null);
}
protected override SkriptType TryParse(ParseContext ctx, List <MatchAnnotation> matchAnnotationsHolder)
{
var litElement = new LiteralPatternElement("");
var startPos = ctx.CurrentPosition;
var clone = ctx.Clone();
(int finalPos, SkriptType finalType)? regexMatch = null;
foreach (var type in CurrentWorkspace.TypesManager.KnownTypesFromAddons)
{
clone.CurrentPosition = startPos;
litElement.Value = type.FinalTypeName;
var result = litElement.Parse(clone);
if (!result.IsSuccess)
{
//The name wasn't matched so try with regex
var isRegexSuccess = false;
if (type.LoosePatternsRegexps != null)
{
foreach (var regex in type.LoosePatternsRegexps)
{
if (isRegexSuccess)
{
break;
}
clone.CurrentPosition = startPos;
var match = regex.Match(clone.PeekUntilEnd());
if (!match.Success)
{
continue;
}
regexMatch = (clone.CurrentPosition + match.Length, type);
isRegexSuccess = true;
}
}
continue;
}
if (CurrentWorkspace.WorkspaceManager.KnownTypesManager.GetTypeByName(type.TypeName) != null)
{
matchAnnotationsHolder.Add(new MatchAnnotation(MatchAnnotationSeverity.Error,
MatchAnnotationCode.CodeUsesInternalType));
}
ctx.CurrentPosition = clone.CurrentPosition;
return(type);
}
if (regexMatch != null)
{
ctx.CurrentPosition = regexMatch.Value.finalPos;
return(regexMatch.Value.finalType);
}
return(null);
}
protected override Experience TryParse(ParseContext ctx, List <MatchAnnotation> matchAnnotationsHolder)
{
var clone = ctx.Clone();
var result = ParsePattern.Parse(clone);
if (!result.IsSuccess)
{
return(null);
}
var resultObj = new Experience();
var number = result.Matches.GetExplicitValue <double?>(0);
resultObj.Type = (ExperienceType)result.ParseMark;
if (number?.GenericValue.HasValue == true)
{
resultObj.Amount = number.GenericValue.Value;
}
else
{
matchAnnotationsHolder.Add(new MatchAnnotation(MatchAnnotationSeverity.Error,
"ExperienceNumberIsNotIncluded",
$"The amount of {resultObj.Type.Humanize()} must be included"));
}
ctx.ReadUntilPosition(clone.CurrentPosition);
return(resultObj);
}
protected override EntityData TryParse(ParseContext ctx)
{
var clone = ctx.Clone(false);
var pos = clone.CurrentPosition;
foreach (var type in WorkspaceManager.CurrentWorkspace.WorkspaceManager.Current.TypesManager
.KnownTypesFromAddons
.Where(c => c.PossibleValuesAsNouns != null))
{
foreach (var noun in type.PossibleValuesAsNouns)
{
var result = noun.Pattern.Parse(clone);
if (result.IsSuccess)
{
ctx.ReadUntilPosition(clone.CurrentPosition);
var data = new EntityData(noun, (EntityData.EntityTypeUsedValues)result.ParseMark);
return(data);
}
clone.CurrentPosition = pos;
clone.Matches.Clear();
}
}
return(null);
}
protected override double?TryParse(ParseContext ctx)
{
var ctxClone = ctx.Clone(false);
var sb = new StringBuilder();
var hasDot = false;
var negative = false;
var isValid = true;
while (isValid)
{
var parseResult = NumberPattern.Parse(ctxClone);
if (parseResult.IsSuccess)
{
if (parseResult.ParseMark == Dot)
{
if (!hasDot)
{
hasDot = true;
}
else
{
isValid = false;
}
}
else if (parseResult.ParseMark == Minus)
{
if (!negative && sb.Length == 0)
{
negative = true;
}
else
{
isValid = false;
}
continue;
}
sb.Append(parseResult.Matches.Last().RawContent);
}
else
{
isValid = false;
}
}
if (!double.TryParse(sb.ToString(), out var result))
{
return(null);
}
ctx.ReadUntilPosition(ctxClone.CurrentPosition);
return(Math.Abs(result) * (negative ? -1 : 1));
}
protected override SkriptRepresentation?TryParse(ParseContext ctx)
{
var clone = ctx.Clone();
var result = Pattern.Parse(clone);
if (result.IsSuccess)
{
ctx.CurrentPosition = clone.CurrentPosition;
return((SkriptRepresentation)result.ParseMark);
}
return(null);
}
public static T TryParse(ParseContext ctx)
{
var parseContext = ctx.Clone(false);
var parseResult = ExpressionPattern.Parse(parseContext);
if (!parseResult.IsSuccess)
{
return(null);
}
var literalExpression =
parseResult.Matches.GetValue <SkriptBoolean.SkriptRepresentation?>(0) as
Expression <SkriptBoolean.SkriptRepresentation?>;
//Check if literal
T expression = null;
if (literalExpression?.GenericValue != null)
{
expression = new T
{
Literal = literalExpression
};
}
//No literal found. Attempt to get a conditional expression
if (parseResult.Matches.GetValue <ConditionalExpression>(0) is ConditionalExpression conditionalExpression)
{
expression = new T
{
Condition = conditionalExpression
};
}
//Users can also use expressions that return a boolean. Try that
if (parseResult.Matches.GetValue <SkriptExpression>(0) is SkriptExpression skriptExpression)
{
expression = new T
{
Expression = skriptExpression
};
}
if (expression != null)
{
ctx.ReadUntilPosition(parseContext.CurrentPosition);
}
return(expression);
}
public static SkriptEnumValue <T> TryParse(ParseContext ctx)
{
var clone = ctx.Clone();
foreach (var(color, skriptPattern) in ValuesMap)
{
var result = skriptPattern.Parse(clone);
if (!result.IsSuccess)
{
continue;
}
ctx.ReadUntilPosition(clone.CurrentPosition);
return(new SkriptEnumValue <T>(color, result.Matches.Last().RawContent));
}
return(null);
}
protected override SkriptVariable TryParse(ParseContext ctx)
{
var clone = ctx.Clone();
if (clone.PeekNext(1) == "{")
{
var result = SkriptVariable.TryParse(clone);
if (result != null)
{
ctx.ReadUntilPosition(clone.CurrentPosition);
}
if (ctx.ReadNext(1) == "}")
{
return(result);
}
}
return(null);
}
protected override FunctionParameter TryParse(ParseContext ctx)
{
var clone = ctx.Clone();
var result = ParsePattern.Parse(clone);
if (result.IsSuccess)
{
var expressions = result.Matches.OfType <ExpressionParseMatch>().Select(c => c.Expression).ToList();
var name = expressions.Select(e => e.GetExplicitValue <string>(0)).FirstOrDefault(c => c != null);
var type = expressions.Select(e => e.GetExplicitValue <SkriptType>(0)).FirstOrDefault(c => c != null);
if (name != null && type != null)
{
//Try to match an optional default value
clone.Matches.Clear();
var defValPattern = GetDefaultValuePatternForType(type.GenericValue);
var optResult = defValPattern.Parse(clone);
IExpression defVal = null;
if (optResult.IsSuccess)
{
defVal = optResult.Matches.OfType <ExpressionParseMatch>().FirstOrDefault()?.Expression;
}
ctx.CurrentPosition = clone.CurrentPosition;
//Return what we have
return(new FunctionParameter
{
NameExpr = name,
TypeExpr = type,
DefaultValue = defVal
});
}
}
return(null);
}
public JToken Do(ParseContext context, JToken jOptions, JObject obj, string keyWord)
{
var options = Common.ParseOptions <LoadOptions>(jOptions, context.Serializer).Single();
context = context.Clone();
context.DisableProcessors = options.DisableProcessors ?? false;
if (context.Parameters == null)
{
context.Parameters = options.Parameters;
}
else if (options.Parameters != null)
{
foreach (KeyValuePair <string, object> optionParameter in options.Parameters)
{
context.Parameters[optionParameter.Key] = optionParameter.Value;
}
}
return(context.Manager.LoadSettings(options.DataSource, context, options.Mode));
}
protected override EnchantmentType TryParse(ParseContext ctx)
{
var clone = ctx.Clone(false);
var result = TypePattern.Parse(clone);
if (result.IsSuccess)
{
var expressions = result.Matches.OfType <ExpressionParseMatch>().Select(c => c.Expression).ToList();
var enchantment = expressions.SelectMany(e => e.GetEnumValues <Enchantment>()).FirstOrDefault();
var level = expressions.SelectMany(e => e.GetValues <double>()).Cast <Expression <double?> >()
.Select(c => c.GenericValue ?? 1d)
.DefaultIfEmpty(1).FirstOrDefault();
ctx.ReadUntilPosition(clone.CurrentPosition);
return(new EnchantmentType(enchantment, expressions.SelectMany(e => e.GetValues <double>()).Any(),
level));
}
return(null);
}
public JToken Do(ParseContext context, JToken jOptions, JObject obj, string keyWord)
{
var options = Common.ParseOptions <MergeArrayOptions>(jOptions, context.Serializer).Single();
context.MergeArray = true;
context = context.Clone();
context.DisableProcessors = options.DisableProcessors ?? false;
if (context.Parameters == null)
{
context.Parameters = options.Parameters;
}
else if (options.Parameters != null)
{
foreach (KeyValuePair <string, object> optionParameter in options.Parameters)
{
context.Parameters[optionParameter.Key] = optionParameter.Value;
}
}
JToken otherToken;
otherToken = context.Manager.LoadSettings(options.DataSource, context, LoadMode.Json);
var otherArray = otherToken as JArray;
if (otherArray == null)
{
throw new SettingsException($"Merge path {options.DataSource} must be JArray");
}
return(otherArray);
}
protected override string TryParse(ParseContext ctx)
{
var sb = new StringBuilder();
var conditionForMatch =
new Func <char, bool>(c => sb.IsEmpty() ? char.IsLetter(c) : char.IsLetterOrDigit(c) || c == '_');
var clone = ctx.Clone();
foreach (var c in clone)
{
if (!conditionForMatch(c))
{
break;
}
sb.Append(c);
}
if (!sb.IsEmpty())
{
ctx.ReadUntilPosition(clone.CurrentPosition - 1);
}
return(sb.ToString().IsEmpty() ? null : sb.ToString());
}
public IExpression TryParseValue(ParseContext ctx)
{
ctx.StartRangeMeasure();
if (ctx.PeekNext(1) == "(")
{
ctx.ReadNext(1); //Read the first bracket
var nextBracket = ctx.FindNextBracket('(', ')');
if (nextBracket != -1)
{
var ctxClone = ctx.Clone(false);
var result = InnerPattern.Parse(ctxClone);
var value = result.Matches.OfType <ExpressionParseMatch>().FirstOrDefault()?.Expression;
var oldPos = ctxClone.CurrentPosition;
if (result.IsSuccess)
{
ctx.ReadUntilPosition(oldPos);
}
if (value != null && ctx.ReadNext(1) == ")")
{
return(new ParenthesesExpression(value, this)
{
Range = ctx.EndRangeMeasure()
});
}
//Rollback in case of it not working
ctx.CurrentPosition = oldPos;
}
}
ctx.UndoRangeMeasure();
return(null);
}
public JToken Do(ParseContext context, JToken jOptions, JObject obj, string keyWord)
{
var options = Common.ParseOptions <MergeOptions>(jOptions, context.Serializer);
JObject resultObj = obj;
foreach (var option in options)
{
var jsonMergeSettings = new JsonMergeSettings
{
MergeNullValueHandling = option.NullValueHandling,
MergeArrayHandling = MergeArrayHandling.Replace,
PropertyNameComparison =
option.IgnoreCase
? StringComparison.OrdinalIgnoreCase
: StringComparison.Ordinal
};
var mergePath = option.DataSource;
context = context.Clone();
context.DisableProcessors = option.DisableProcessors ?? false;
if (context.Parameters == null)
{
context.Parameters = option.Parameters;
}
else if (option.Parameters != null)
{
foreach (KeyValuePair <string, object> optionParameter in option.Parameters)
{
context.Parameters[optionParameter.Key] = optionParameter.Value;
}
}
var otherToken = context.Manager.LoadSettings(mergePath, context, LoadMode.Json);
var otherObj = otherToken as JObject;
if (otherObj == null)
{
throw new SettingsException($"Merge path {mergePath} must be JObject");
}
if (option.Priority == MergePriority.This)
{
otherObj.Merge(resultObj, jsonMergeSettings);
resultObj = otherObj;
}
else if (option.Priority == MergePriority.Other)
{
resultObj.Merge(otherObj, jsonMergeSettings);
}
else
{
throw new NotImplementedException(option.Priority.ToString());
}
}
return(resultObj);
}
protected override WrappedObject TryParse(ParseContext ctx)
{
var clone = ctx.Clone();
ctx.Properties.WrappedObjectCount++;
var typePattern = new TypePatternElement();
var possibleValues = new List <(int CurrentPosition, List <ParseMatch> expression, ParseResult result)>();
var startPos = clone.CurrentPosition;
foreach (var type in WorkspaceManager.CurrentWorkspace.TypesManager.KnownTypesFromAddons)
{
//Only match once, multiple types are parsed elsewhere
if (type.IsPlural)
{
continue;
}
clone.Matches.Clear();
clone.CurrentPosition = startPos;
typePattern.Type = type.FinalTypeName;
if (typePattern.ToString().Contains("%object"))
{
Debugger.Break();
}
if (!RuntimeHelpers.TryEnsureSufficientExecutionStack())
{
Debugger.Break();
}
var result = typePattern.Parse(clone);
if (result.IsSuccess)
{
var expression = new List <ParseMatch>(clone.Matches);
if (expression.Count > 0)
{
possibleValues.Add((clone.CurrentPosition, expression, result));
}
}
}
{
//clone.ShouldJustCheckExpressionsThatMatchType = true;
var expressions =
WorkspaceManager.CurrentWorkspace.TypesManager.GetExpressionsThatCanFitType(KnownTypesManager
.JavaLangObjectClass);
if (expressions != null)
{
foreach (var expression in expressions)
{
foreach (var pattern in expression.PatternNodes)
{
if (pattern.ToString().Contains("ExprJavaCall"))
{
Debugger.Break();
}
clone.Matches.Clear();
clone.CurrentPosition = startPos;
clone.StartRangeMeasure();
var result = pattern.Parse(clone);
if (!result.IsSuccess)
{
clone.UndoRangeMeasure();
continue;
}
var exprResult = clone.Matches;
if (exprResult.Count > 0)
{
var cloneParseContext = clone.Clone();
result.Context = cloneParseContext;
var expr = new SkriptExpression(expression, clone.EndRangeMeasure(), cloneParseContext);
possibleValues.Add((clone.CurrentPosition,
new List <ParseMatch>(new[] { new ExpressionParseMatch(expr, null) }), result));
}
}
}
}
}
possibleValues.Sort((c1, c2) => - 1 * c1.CurrentPosition.CompareTo(c2.CurrentPosition));
if (possibleValues.Count <= 0)
{
return(null);
}
{
var(lastPos, matches, _) = possibleValues[0];
ctx.ReadUntilPosition(lastPos);
ctx.Properties.WrappedObjectCount--;
return(new WrappedObject(matches));
}
}
public IExpression?TryParseValue(ParseContext ctx)
{
var typeInstance = Type.CreateNewInstance();
var ourContext = ctx.Clone(false);
var resultExpression = new MultiValueExpression();
ctx.StartRangeMeasure();
ctx.StartMatch();
var count = 0;
var isValid = true;
var lastGoodPos = ourContext.CurrentPosition;
while (isValid)
{
ourContext.Matches.Clear();
ourContext.RemoveNarrowLimit();
var result = NextValuePattern.Parse(ourContext);
isValid = result.IsSuccess;
if (!isValid)
{
continue;
}
//Check if the parser consumed content and had a valid result. If not, just let go and give up.
if (lastGoodPos == ourContext.CurrentPosition)
{
break;
}
var expr = (ourContext.Matches.FirstOrDefault() as ExpressionParseMatch)?.Expression;
if (expr != null)
{
resultExpression.Values.Add(
new MultiValueExpression.ValueDescription(expr,
ourContext.Matches.Where(c => c != null && !(c is ExpressionParseMatch))
.Where(c => !c.RawContent.IsEmpty()).Skip(1).FirstOrDefault()));
}
count++;
}
if (count > 0)
{
//Remove last splitter
var lastVal = resultExpression.Values?.Last();
if (lastVal != null)
{
if (lastVal.RawSplitter != null)
{
ourContext.CurrentPosition = (int)lastVal.RawSplitter.Range.Start.Character;
lastVal.RawSplitter = null;
}
ctx.ReadUntilPosition(ourContext.CurrentPosition);
}
}
if (count > 0)
{
resultExpression.Range = ctx.EndRangeMeasure();
resultExpression.Context = ctx;
resultExpression.Type = typeInstance;
return(resultExpression);
}
ctx.UndoRangeMeasure();
ctx.UndoMatch();
return(null);
}
