public static ParameterBase[] GetParameters(ParsingData parser, ParameterDefineNode[] defineNodes)
{
ParameterBase[] parameters = new ParameterBase[defineNodes.Length];
for (int i = 0; i < parameters.Length; i++)
{
EnumData enumData = null;
DefinedType type = null;
if (defineNodes[i].Type != null)
{
enumData = EnumData.GetEnum(defineNodes[i].Type);
type = parser.GetDefinedType(defineNodes[i].Type, null);
if (enumData == null && type == null)
{
throw SyntaxErrorException.NonexistentType(defineNodes[i].Type, defineNodes[i].Location);
}
}
if (enumData != null)
{
parameters[i] = new EnumParameter(defineNodes[i].VariableName, enumData.Type);
}
else if (type != null)
{
parameters[i] = new TypeParameter(defineNodes[i].VariableName, type);
}
else
{
parameters[i] = new Parameter(defineNodes[i].VariableName, Elements.ValueType.Any, null);
}
}
return(parameters);
}
private static CompletionItem[] GetItems <T>(string tag) => EnumData.GetEnum <T>()
.Members.Select(m => new CompletionItem()
{
Label = m.CodeName,
Detail = m.CodeName,
//Detail = new MarkupBuilder().StartCodeLine().Add(tag + "." + m.CodeName).ToString(),
Kind = CompletionItemKind.Constant
}).ToArray();
protected DefinedType(TypeDefineNode node)
{
if (EnumData.GetEnum(node.Name) != null)
{
throw SyntaxErrorException.TypeNameConflict(node.Name, node.Location);
}
Name = node.Name;
DefinedVars = node.DefinedVars;
MethodNodes = node.Methods;
ConstructorNodes = node.Constructors;
}
private static T GetMember <T>(string groupName, string name, FileDiagnostics diagnostics, DocRange range)
{
foreach (var m in EnumData.GetEnum <T>().Members)
{
if (name == m.CodeName)
{
return((T)m.Value);
}
}
diagnostics.Error("Invalid " + groupName + " value.", range);
return(default(T));
}
private void GetRuleSettings(ParseInfo parseInfo, Scope scope, DeltinScriptParser.Ow_ruleContext ruleContext)
{
DeltinScriptParser.ExprContext eventContext = null;
DeltinScriptParser.ExprContext teamContext = null;
DeltinScriptParser.ExprContext playerContext = null;
foreach (var exprContext in ruleContext.expr())
{
missingBlockRange = DocRange.GetRange(exprContext);
EnumValuePair enumSetting = (ExpressionTree.ResultingExpression(parseInfo.GetExpression(scope, exprContext)) as CallVariableAction)?.Calling as EnumValuePair;
EnumData enumData = enumSetting?.Member.Enum;
if (enumData == null || !ValidRuleEnums.Contains(enumData))
{
parseInfo.Script.Diagnostics.Error("Expected enum of type " + string.Join(", ", ValidRuleEnums.Select(vre => vre.CodeName)) + ".", DocRange.GetRange(exprContext));
}
else
{
var alreadySet = new Diagnostic("The " + enumData.CodeName + " rule setting was already set.", DocRange.GetRange(exprContext), Diagnostic.Error);
// Get the Event option.
if (enumData == EnumData.GetEnum <RuleEvent>())
{
if (_setEventType)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
EventType = (RuleEvent)enumSetting.Member.Value;
_setEventType = true;
eventContext = exprContext;
}
// Get the Team option.
if (enumData == EnumData.GetEnum <Team>())
{
if (_setTeam)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
Team = (Team)enumSetting.Member.Value;
_setTeam = true;
teamContext = exprContext;
}
// Get the Player option.
if (enumData == EnumData.GetEnum <PlayerSelector>())
{
if (_setPlayer)
{
parseInfo.Script.Diagnostics.AddDiagnostic(alreadySet);
}
Player = (PlayerSelector)enumSetting.Member.Value;
_setPlayer = true;
playerContext = exprContext;
}
}
}
// Syntax error if changing the Team type when the Event type is set to Global.
if (_setEventType && EventType == RuleEvent.OngoingGlobal)
{
if (Team != Team.All)
{
parseInfo.Script.Diagnostics.Error("Can't change rule Team type with an event type of Ongoing Global.", DocRange.GetRange(teamContext));
}
if (Player != PlayerSelector.All)
{
parseInfo.Script.Diagnostics.Error("Can't change rule Player type with an event type of Ongoing Global.", DocRange.GetRange(playerContext));
}
}
}
public static WorkshopEnumType GetEnumType <T>()
{
var enumData = EnumData.GetEnum <T>();
return((WorkshopEnumType)CodeType.DefaultTypes.First(t => t is WorkshopEnumType && ((WorkshopEnumType)t).EnumData == enumData));
}
public override CodeParameter[] Parameters()
{
return(new CodeParameter[] {
new CodeParameter("map", WorkshopEnumType.GetEnumType(EnumData.GetEnum <Map>()))
});
}
public static ValueGroupType GetEnumType <T>() => GetEnumType(EnumData.GetEnum <T>());
string GetAutocomplete(string json)
{
/*
* Format:
* textDocument
* caret
* caret.line
* caret.character
*/
PosData posData = GetPosData(json);
if (posData == null)
{
return(null);
}
List <CompletionItem> completion = new List <CompletionItem>();
if (posData.SelectedNode != null)
{
switch (posData.SelectedNode.FirstOrDefault())
{
// Ruleset
case RulesetNode rulesetNode:
completion.AddRange(new CompletionItem[]
{
new CompletionItem("rule")
{
kind = CompletionItem.Keyword, textEdit = TextEdit.Insert(posData.Caret, Extras.Lines(
"rule: \"My Rule\"",
"Event.OngoingGlobal",
"{",
"}"
))
},
new CompletionItem("define")
{
kind = CompletionItem.Keyword
},
new CompletionItem("method")
{
kind = CompletionItem.Keyword, textEdit = TextEdit.Insert(posData.Caret, Extras.Lines(
"method myMethod()",
"{",
"}"
))
}
});
break;
// Rule node
case RuleNode ruleNode:
// Event type
if (ruleNode.IsEventOptionSelected(posData.Caret))
{
completion.AddRange(EnumData.GetEnum <RuleEvent>().GetCompletion());
}
// Player
else if (ruleNode.IsPlayerOptionSelected(posData.Caret))
{
completion.AddRange(EnumData.GetEnum <PlayerSelector>().GetCompletion());
}
// Team
else if (ruleNode.IsTeamOptionSelected(posData.Caret))
{
completion.AddRange(EnumData.GetEnum <Team>().GetCompletion());
}
else if (ruleNode.IsIfSelected(posData.Caret))
{
completion.AddRange(Element.GetCompletion(true, false));
}
else
{
completion.AddRange(new CompletionItem[]
{
new CompletionItem("Event")
{
kind = CompletionItem.Enum
},
new CompletionItem("Team")
{
kind = CompletionItem.Enum
},
new CompletionItem("Player")
{
kind = CompletionItem.Enum
},
});
}
break;
// Actions
case BlockNode blockNode:
// Get all action methods
completion.AddRange(Element.GetCompletion(true, true));
completion.AddRange(CustomMethodData.GetCompletion());
if (parserData.Success)
{
// Get all variables
if (blockNode.RelatedScopeGroup != null)
{
completion.AddRange(blockNode.RelatedScopeGroup.GetCompletionItems(posData.Caret));
}
// Get custom methods
if (parserData.UserMethods != null)
{
completion.AddRange(UserMethod.CollectionCompletion(parserData.UserMethods.ToArray()));
}
// Get structs
if (parserData.DefinedTypes != null)
{
completion.AddRange(DefinedType.CollectionCompletion(parserData.DefinedTypes.ToArray()));
}
}
break;
// Values
case MethodNode methodNode:
completion.AddRange(Element.GetCompletion(true, false));
completion.AddRange(EnumData.GetAllEnumCompletion());
completion.AddRange(CustomMethodData.GetCompletion());
if (parserData.Success)
{
// Get all variables
if (methodNode.RelatedScopeGroup != null)
{
completion.AddRange(methodNode.RelatedScopeGroup?.GetCompletionItems(posData.Caret));
}
// Get custom methods
if (parserData.UserMethods != null)
{
completion.AddRange(UserMethod.CollectionCompletion(parserData.UserMethods.ToArray()));
}
}
break;
// If the selected node is a string node, show all strings.
case StringNode stringNode:
completion.AddRange(Constants.Strings.Select(str =>
new CompletionItem(str)
{
kind = CompletionItem.Text
}
));
break;
case EnumNode enumNode:
var add = EnumData.GetEnum(enumNode.Type)?.GetCompletion();
if (add != null)
{
completion.AddRange(add);
}
break;
case ImportNode importNode:
string currentPath = importNode.File;
string path = Extras.CombinePathWithDotNotation(posData.File, importNode.File);
if (path != null)
{
completion.Add(new CompletionItem("../")
{
kind = CompletionItem.Folder
});
// GetDirectoryName can return null even if path isn't null.
path = Path.GetDirectoryName(path);
if (path != null)
{
foreach (string fullDirectoryPath in Directory.GetDirectories(path))
{
string directory = new DirectoryInfo(fullDirectoryPath).Name;
completion.Add(new CompletionItem(directory)
{
kind = CompletionItem.Folder
});
}
foreach (string fullFilePath in Directory.GetFiles(path))
{
string file = Path.GetFileName(fullFilePath);
completion.Add(new CompletionItem(file)
{
kind = CompletionItem.File
});
}
}
}
break;
}
}
return(JsonConvert.SerializeObject(completion.ToArray()));
}
static string GetAutocomplete(string json)
{
/*
* Format:
* textDocument
* caret
* caret.line
* caret.character
*/
dynamic inputJson = JsonConvert.DeserializeObject(json);
string document = inputJson.textDocument;
int line = inputJson.caret.line;
int character = inputJson.caret.character;
Pos caret = new Pos(line, character);
var parser = ParserData.GetParser(document, new Parse.Pos(caret.line, caret.character));
List <CompletionItem> completion = new List <CompletionItem>();
switch (parser.Bav?.SelectedNode.FirstOrDefault())
{
// Ruleset
case RulesetNode rulesetNode:
completion.AddRange(new CompletionItem[]
{
// TODO insert text
new CompletionItem("rule")
{
kind = CompletionItem.Keyword
},
new CompletionItem("define")
{
kind = CompletionItem.Keyword
},
new CompletionItem("method")
{
kind = CompletionItem.Keyword
}
});
break;
// Rule node
case RuleNode ruleNode:
// Event type
if (ruleNode.IsEventOptionSelected())
{
completion.AddRange(EnumData.GetEnum <RuleEvent>().GetCompletion());
}
// Player
else if (ruleNode.IsPlayerOptionSelected())
{
completion.AddRange(EnumData.GetEnum <PlayerSelector>().GetCompletion());
}
// Team
else if (ruleNode.IsTeamOptionSelected())
{
completion.AddRange(EnumData.GetEnum <TeamSelector>().GetCompletion());
}
else
{
completion.AddRange(new CompletionItem[]
{
new CompletionItem("Event")
{
kind = CompletionItem.Enum
},
new CompletionItem("Team")
{
kind = CompletionItem.Enum
},
new CompletionItem("Player")
{
kind = CompletionItem.Enum
},
});
}
break;
// Actions
case BlockNode blockNode:
// Get all action methods
completion.AddRange(Element.ActionList.Select(m =>
new CompletionItem(m.Name.Substring(2))
{
kind = CompletionItem.Method,
detail = ((Element)Activator.CreateInstance(m)).ToString(),
}));
if (parser.Success)
{
// Get all variables
if (blockNode.RelatedScopeGroup != null)
{
completion.AddRange(blockNode.RelatedScopeGroup.GetCompletionItems());
}
// Get custom methods
if (parser.UserMethods != null)
{
completion.AddRange(UserMethod.CollectionCompletion(parser.UserMethods));
}
}
break;
// Values
case MethodNode methodNode:
completion.AddRange(Element.ValueList.Select(m =>
new CompletionItem(m.Name.Substring(2))
{
kind = CompletionItem.Method,
detail = ((Element)Activator.CreateInstance(m)).ToString(),
}));
completion.AddRange(EnumData.GetAllEnumCompletion());
if (parser.Success)
{
// Get all variables
if (methodNode.RelatedScopeGroup != null)
{
completion.AddRange(methodNode.RelatedScopeGroup?.GetCompletionItems());
}
// Get custom methods
if (parser.UserMethods != null)
{
completion.AddRange(UserMethod.CollectionCompletion(parser.UserMethods));
}
}
break;
// If the selected node is a string node, show all strings.
case StringNode stringNode:
completion.AddRange(Constants.Strings.Select(str =>
new CompletionItem(str)
{
kind = CompletionItem.Text
}
));
break;
case EnumNode enumNode:
var add = EnumData.GetEnum(enumNode.Type)?.GetCompletion();
if (add != null)
{
completion.AddRange(add);
}
break;
}
return(JsonConvert.SerializeObject(completion.ToArray()));
}
