// Sets up single-instance methods for methods with the 'rule' attribute.
public void SetupSubroutine()
{
if (!IsSubroutine)
{
throw new Exception(Name + " does not have the subroutine attribute.");
}
// Setup the subroutine element.
Subroutine subroutine = parseInfo.TranslateInfo.SubroutineCollection.NewSubroutine(Name);
// Create the rule.
TranslateRule subroutineRule = new TranslateRule(parseInfo.TranslateInfo, SubroutineName, subroutine);
// Setup the return handler.
ReturnHandler returnHandler = new ReturnHandler(subroutineRule.ActionSet, Name, multiplePaths);
ActionSet actionSet = subroutineRule.ActionSet.New(returnHandler).New(subroutineRule.ActionSet.IndexAssigner.CreateContained());
// Get the variables that will be used to store the parameters.
IndexReference[] parameterStores = new IndexReference[ParameterVars.Length];
for (int i = 0; i < ParameterVars.Length; i++)
{
parameterStores[i] = actionSet.IndexAssigner.Add(actionSet.VarCollection, ParameterVars[i], true, null, Attributes.Recursive) as IndexReference;
}
// If the subroutine is an object function inside a class, create a variable to store the class object.
IndexReference objectStore = null;
if (Attributes.ContainingType != null && !Static)
{
objectStore = actionSet.VarCollection.Assign("_" + Name + "_subroutineStore", true, true);
Attributes.ContainingType.AddObjectVariablesToAssigner(objectStore.GetVariable(), actionSet.IndexAssigner);
}
// Set the subroutine info.
subroutineInfo = new SubroutineInfo(subroutine, returnHandler, subroutineRule, parameterStores, objectStore);
// Parse the block.
block.Translate(actionSet);
// Apply returns.
returnHandler.ApplyReturnSkips();
// Add the subroutine.
parseInfo.TranslateInfo.WorkshopRules.Add(subroutineRule.GetRule());
}
// Sets up single-instance methods for methods with the 'rule' attribute.
public void SetupSubroutine()
{
if (subroutineInfo != null || !IsSubroutine)
{
return;
}
// Setup the subroutine element.
Subroutine subroutine = parseInfo.TranslateInfo.SubroutineCollection.NewSubroutine(Name);
// Create the rule.
TranslateRule subroutineRule = new TranslateRule(parseInfo.TranslateInfo, subroutine, SubroutineName, subroutineDefaultGlobal);
// Setup the return handler.
ReturnHandler returnHandler = new ReturnHandler(subroutineRule.ActionSet, Name, multiplePaths || Attributes.Virtual);
ActionSet actionSet = subroutineRule.ActionSet.New(returnHandler).New(subroutineRule.ActionSet.IndexAssigner.CreateContained());
// Get the variables that will be used to store the parameters.
IndexReference[] parameterStores = new IndexReference[ParameterVars.Length];
for (int i = 0; i < ParameterVars.Length; i++)
{
// Create the workshop variable the parameter will be stored as.
IndexReference indexResult = actionSet.IndexAssigner.AddIndexReference(actionSet.VarCollection, ParameterVars[i], subroutineDefaultGlobal, Attributes.Recursive);
parameterStores[i] = indexResult;
// Assign virtual variables to the index reference.
foreach (Var virtualParameterOption in VirtualVarGroup(i))
{
actionSet.IndexAssigner.Add(virtualParameterOption, indexResult);
}
}
// If the subroutine is an object function inside a class, create a variable to store the class object.
IndexReference objectStore = null;
if (Attributes.ContainingType != null && !Static)
{
objectStore = actionSet.VarCollection.Assign("_" + Name + "_subroutineStore", true, !Attributes.Recursive);
// Set the objectStore as an empty array if the subroutine is recursive.
if (Attributes.Recursive)
{
actionSet.InitialSet().AddAction(objectStore.SetVariable(new V_EmptyArray()));
Attributes.ContainingType.AddObjectVariablesToAssigner(Element.Part <V_LastOf>(objectStore.GetVariable()), actionSet.IndexAssigner);
actionSet = actionSet.New(Element.Part <V_LastOf>(objectStore.GetVariable())).PackThis();
}
else
{
Attributes.ContainingType.AddObjectVariablesToAssigner(objectStore.GetVariable(), actionSet.IndexAssigner);
actionSet = actionSet.New(objectStore.GetVariable()).PackThis();
}
}
// Set the subroutine info.
subroutineInfo = new SubroutineInfo(subroutine, returnHandler, subroutineRule, parameterStores, objectStore);
MethodBuilder builder = new MethodBuilder(this, actionSet, returnHandler);
builder.BuilderSet = builder.BuilderSet.New(Attributes.Recursive);
builder.ParseInner();
// Apply returns.
returnHandler.ApplyReturnSkips();
// Pop object array and parameters if recursive.
if (Attributes.Recursive)
{
if (objectStore != null)
{
actionSet.AddAction(objectStore.ModifyVariable(Operation.RemoveFromArrayByIndex, Element.Part <V_CountOf>(objectStore.GetVariable()) - 1));
}
RecursiveStack.PopParameterStacks(actionSet, ParameterVars);
}
// Add the subroutine.
Rule translatedRule = subroutineRule.GetRule();
parseInfo.TranslateInfo.WorkshopRules.Add(translatedRule);
var codeLens = new ElementCountCodeLens(DefinedAt.range, parseInfo.TranslateInfo.OptimizeOutput);
parseInfo.Script.AddCodeLensRange(codeLens);
codeLens.RuleParsed(translatedRule);
}
void ToWorkshop(Func <VarCollection, Rule[]> addRules)
{
// Set up the variable collection.
VarCollection.Setup();
// Set up initial global and player rules.
InitialGlobal = new TranslateRule(this, "Initial Global", RuleEvent.OngoingGlobal);
InitialPlayer = new TranslateRule(this, "Initial Player", RuleEvent.OngoingPlayer);
WorkshopRules = new List <Rule>();
// Assign static variables.
foreach (var type in types)
{
type.WorkshopInit(this);
}
// Assign variables at the rule-set level.
foreach (var variable in rulesetVariables)
{
// Assign the variable an index.
DefaultIndexAssigner.Add(VarCollection, variable, true, null);
var assigner = DefaultIndexAssigner[variable] as IndexReference;
if (assigner != null && variable.InitialValue != null)
{
var addToInitialRule = GetInitialRule(variable.VariableType == VariableType.Global);
addToInitialRule.ActionSet.AddAction(assigner.SetVariable(
(Element)variable.InitialValue.Parse(addToInitialRule.ActionSet)
));
}
}
// Setup single-instance methods.
foreach (var method in subroutines)
{
method.SetupSubroutine();
}
// Parse the rules.
foreach (var rule in rules)
{
var translate = new TranslateRule(this, rule);
WorkshopRules.Add(translate.GetRule());
}
if (InitialPlayer.Actions.Count > 0)
{
WorkshopRules.Insert(0, InitialPlayer.GetRule());
}
if (InitialGlobal.Actions.Count > 0)
{
WorkshopRules.Insert(0, InitialGlobal.GetRule());
}
if (addRules != null)
{
WorkshopRules.AddRange(addRules.Invoke(VarCollection).Where(rule => rule != null));
}
// Order the workshop rules by priority.
WorkshopRules = WorkshopRules.OrderBy(wr => wr.Priority).ToList();
// Get the final workshop string.
WorkshopBuilder result = new WorkshopBuilder(Language);
LanguageInfo.I18nWarningMessage(result, Language);
// Get the custom game settings.
if (MergedLobbySettings != null)
{
Ruleset settings = Ruleset.Parse(MergedLobbySettings);
settings.ToWorkshop(result);
result.AppendLine();
}
// Get the variables.
VarCollection.ToWorkshop(result);
result.AppendLine();
// Get the subroutines.
SubroutineCollection.ToWorkshop(result);
// Get the rules.
foreach (var rule in WorkshopRules)
{
result.AppendLine(rule.ToWorkshop(Language, OptimizeOutput));
}
WorkshopCode = result.ToString();
}
void ToWorkshop(Func <VarCollection, Rule[]> addRules)
{
VarCollection.Setup();
InitialGlobal = new TranslateRule(this, "Initial Global", RuleEvent.OngoingGlobal);
InitialPlayer = new TranslateRule(this, "Initial Player", RuleEvent.OngoingPlayer);
WorkshopRules = new List <Rule>();
foreach (var variable in rulesetVariables)
{
// Assign the variable an index.
DefaultIndexAssigner.Add(VarCollection, variable, true, null);
var assigner = DefaultIndexAssigner[variable] as IndexReference;
if (assigner != null && variable.InitialValue != null)
{
var addToInitialRule = GetInitialRule(variable.VariableType == VariableType.Global);
addToInitialRule.ActionSet.AddAction(assigner.SetVariable(
(Element)variable.InitialValue.Parse(addToInitialRule.ActionSet)
));
}
}
foreach (var rule in rules)
{
var translate = new TranslateRule(this, rule);
WorkshopRules.Add(translate.GetRule());
}
if (InitialPlayer.Actions.Count > 0)
{
WorkshopRules.Insert(0, InitialPlayer.GetRule());
}
if (InitialGlobal.Actions.Count > 0)
{
WorkshopRules.Insert(0, InitialGlobal.GetRule());
}
if (addRules != null)
{
WorkshopRules.AddRange(addRules.Invoke(VarCollection).Where(rule => rule != null));
}
// Get the final workshop string.
StringBuilder result = new StringBuilder();
I18n.I18n.I18nWarningMessage(result, I18n.I18n.CurrentLanguage);
// Get the variables.
VarCollection.ToWorkshop(result, I18n.I18n.CurrentLanguage);
result.AppendLine();
// Get the rules.
foreach (var rule in WorkshopRules)
{
result.AppendLine(rule.ToWorkshop(I18n.I18n.CurrentLanguage));
}
WorkshopCode = result.ToString();
}
private ParsingData(string file, string content)
{
Rule initialGlobalValues = new Rule(Constants.INTERNAL_ELEMENT + "Initial Global Values");
Rule initialPlayerValues = new Rule(Constants.INTERNAL_ELEMENT + "Initial Player Values", RuleEvent.OngoingPlayer, Team.All, PlayerSelector.All);
globalTranslate = new TranslateRule(initialGlobalValues, Root, this);
playerTranslate = new TranslateRule(initialPlayerValues, Root, this);
GetRulesets(content, file, true, null);
VarCollection = new VarCollection(ReservedGlobalIDs.ToArray(), ReservedGlobalNames.ToArray(), ReservedPlayerIDs.ToArray(), ReservedPlayerNames.ToArray());
Root = new ScopeGroup(VarCollection);
ClassIndexes = IndexedVar.AssignInternalVar(VarCollection, null, "_classIndexes", true);
ClassArray = IndexedVar.AssignInternalVar(VarCollection, null, "_classArray", true);
if (!Diagnostics.ContainsErrors())
{
foreach (var ruleset in Rulesets)
{
GetObjects(ruleset.Value, ruleset.Key, globalTranslate, playerTranslate);
}
}
foreach (var type in DefinedTypes)
{
try
{
type.RegisterParameters(this);
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
foreach (var method in UserMethods)
{
try
{
method.RegisterParameters(this);
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
if (!Diagnostics.ContainsErrors())
{
// Parse the rules.
Rules = new List <Rule>();
for (int i = 0; i < RuleNodes.Count; i++)
{
try
{
var result = TranslateRule.GetRule(RuleNodes[i], Root, this);
Rules.Add(result);
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
foreach (var definedVar in VarCollection.AllVars)
{
try
{
if (definedVar is IndexedVar && definedVar.IsDefinedVar && definedVar.Scope == Root)
{
Node value = ((IDefine)definedVar.Node).Value;
if (value != null)
{
if (((IndexedVar)definedVar).IsGlobal)
{
globalTranslate.Actions.AddRange(((IndexedVar)definedVar).SetVariable(globalTranslate.ParseExpression(Root, Root, value)));
}
else
{
playerTranslate.Actions.AddRange(((IndexedVar)definedVar).SetVariable(playerTranslate.ParseExpression(Root, Root, value)));
}
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
globalTranslate.Finish();
playerTranslate.Finish();
// Add the player initial values rule if it was used.
if (initialPlayerValues.Actions.Length > 0)
{
Rules.Insert(0, initialPlayerValues);
}
// Add the global initial values rule if it was used.
if (initialGlobalValues.Actions.Length > 0)
{
Rules.Insert(0, initialGlobalValues);
}
foreach (Rule rule in AdditionalRules)
{
if (rule.Actions.Length > 0)
{
Rules.Add(rule);
}
}
}
Success = !Diagnostics.ContainsErrors();
}
void ToWorkshop(Func <VarCollection, Rule[]> addRules)
{
// Set up the variable collection.
VarCollection.Setup();
// Set up initial global and player rules.
InitialGlobal = new TranslateRule(this, "Initial Global", RuleEvent.OngoingGlobal);
InitialPlayer = new TranslateRule(this, "Initial Player", RuleEvent.OngoingPlayer);
WorkshopRules = new List <Rule>();
// Init called types.
foreach (var type in Types.CalledTypes.Distinct())
{
type.WorkshopInit(this);
}
// Assign variables at the rule-set level.
foreach (var variable in rulesetVariables)
{
// Assign the variable an index.
var assigner = DefaultIndexAssigner.Add(VarCollection, variable, true, null) as IndexReference;
// Assigner will be non-null if it is an IndexReference.
if (assigner != null)
{
DebugVariables.Add(variable, assigner);
// Initial value.
if (variable.InitialValue != null)
{
var addToInitialRule = GetInitialRule(variable.VariableType == VariableType.Global);
addToInitialRule.ActionSet.AddAction(assigner.SetVariable(
(Element)variable.InitialValue.Parse(addToInitialRule.ActionSet)
));
}
}
}
// Setup single-instance methods.
foreach (var method in subroutines)
{
method.SetupSubroutine();
}
// Parse the rules.
foreach (var rule in rules)
{
var translate = new TranslateRule(this, rule);
Rule newRule = translate.GetRule();
WorkshopRules.Add(newRule);
rule.ElementCountLens.RuleParsed(newRule);
}
// Add built-in rules.
// Initial player
if (InitialPlayer.Actions.Count > 0)
{
WorkshopRules.Insert(0, InitialPlayer.GetRule());
}
// Initial global
if (InitialGlobal.Actions.Count > 0)
{
WorkshopRules.Insert(0, InitialGlobal.GetRule());
}
// Additional
if (addRules != null)
{
WorkshopRules.AddRange(addRules.Invoke(VarCollection).Where(rule => rule != null));
}
// Order the workshop rules by priority.
WorkshopRules = WorkshopRules.OrderBy(wr => wr.Priority).ToList();
// Get the final workshop string.
WorkshopBuilder result = new WorkshopBuilder(Language);
LanguageInfo.I18nWarningMessage(result, Language);
// Get the custom game settings.
if (Importer.MergedLobbySettings != null)
{
Ruleset settings = Ruleset.Parse(Importer.MergedLobbySettings);
settings.ToWorkshop(result);
result.AppendLine();
}
// Get the variables.
VarCollection.ToWorkshop(result);
result.AppendLine();
// Print class identifiers.
Types.PrintClassIdentifiers(result);
// Get the subroutines.
SubroutineCollection.ToWorkshop(result);
// Get the rules.
for (int i = 0; i < WorkshopRules.Count; i++)
{
WorkshopRules[i].ToWorkshop(result, OptimizeOutput);
ElementCount += WorkshopRules[i].ElementCount(OptimizeOutput);
if (i != WorkshopRules.Count - 1)
{
result.AppendLine();
}
}
WorkshopCode = result.ToString();
}
void ToWorkshop(Func <VarCollection, Rule[]> addRules)
{
// Set up the variable collection.
VarCollection.Setup();
WorkshopConverter = new ToWorkshop(this);
// Set up initial global and player rules.
InitialGlobal = new TranslateRule(this, "Initial Global", RuleEvent.OngoingGlobal);
InitialPlayer = new TranslateRule(this, "Initial Player", RuleEvent.OngoingPlayer);
WorkshopRules = new List <Rule>();
WorkshopConverter.InitStatic();
// Init called types.
foreach (var workshopInit in _workshopInit)
{
workshopInit.WorkshopInit(this);
}
// Assign variables at the rule-set level.
foreach (var variable in rulesetVariables)
{
var addToInitialRule = GetInitialRule(variable.VariableType == VariableType.Global);
// Assign the variable an index.
IGettable value = variable
.GetDefaultInstance(null)
.GetAssigner(new(addToInitialRule.ActionSet))
.GetValue(new GettableAssignerValueInfo(addToInitialRule.ActionSet)
{
SetInitialValue = SetInitialValue.SetIfExists
});
DefaultIndexAssigner.Add(variable, value);
if (value is IndexReference indexReference)
{
DebugVariables.Add(variable, indexReference);
}
}
// Parse the rules.
foreach (var rule in rules)
{
var translate = new TranslateRule(this, rule);
Rule newRule = GetRule(translate.GetRule());
WorkshopRules.Add(newRule);
rule.ElementCountLens.RuleParsed(newRule);
}
// Add built-in rules.
// Initial player
if (InitialPlayer.Actions.Count > 0)
{
WorkshopRules.Insert(0, GetRule(InitialPlayer.GetRule()));
}
// Initial global
if (InitialGlobal.Actions.Count > 0)
{
WorkshopRules.Insert(0, GetRule(InitialGlobal.GetRule()));
}
// Additional
if (addRules != null)
{
WorkshopRules.AddRange(addRules.Invoke(VarCollection).Where(rule => rule != null));
}
// Complete portable functions
WorkshopConverter.LambdaBuilder.Complete();
// Order the workshop rules by priority.
WorkshopRules = WorkshopRules.OrderBy(wr => wr.Priority).ToList();
// Get the final workshop string.
WorkshopBuilder result = new WorkshopBuilder(Language);
LanguageInfo.I18nWarningMessage(result, Language);
// Get the custom game settings.
if (Importer.MergedLobbySettings != null)
{
Ruleset settings = Ruleset.Parse(Importer.MergedLobbySettings);
settings.ToWorkshop(result);
result.AppendLine();
}
// Get the variables.
VarCollection.ToWorkshop(result);
result.AppendLine();
// Get the subroutines.
SubroutineCollection.ToWorkshop(result);
// Get the rules.
for (int i = 0; i < WorkshopRules.Count; i++)
{
WorkshopRules[i].ToWorkshop(result);
ElementCount += WorkshopRules[i].ElementCount();
if (i != WorkshopRules.Count - 1)
{
result.AppendLine();
}
}
WorkshopCode = result.GetResult();
}