private RulesetNode GetRuleset(string file, string content)
{
AntlrInputStream inputStream = new AntlrInputStream(content);
// Lexer
DeltinScriptLexer lexer = new DeltinScriptLexer(inputStream);
CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);
// Parse
DeltinScriptParser parser = new DeltinScriptParser(commonTokenStream);
var errorListener = new ErrorListener(file, Diagnostics);
parser.RemoveErrorListeners();
parser.AddErrorListener(errorListener);
DeltinScriptParser.RulesetContext ruleSetContext = parser.ruleset();
Log.Write(LogLevel.Verbose, ruleSetContext.ToStringTree(parser));
// Get the ruleset node.
RulesetNode ruleset = null;
if (!Diagnostics.ContainsErrors())
{
BuildAstVisitor bav = new BuildAstVisitor(file, Diagnostics);
ruleset = (RulesetNode)bav.Visit(ruleSetContext);
}
AdditionalErrorChecking aec = new AdditionalErrorChecking(file, parser, Diagnostics);
aec.Visit(ruleSetContext);
return(ruleset);
}
public DeltinScript(TranslateSettings translateSettings)
{
FileGetter = translateSettings.FileGetter;
Diagnostics = translateSettings.Diagnostics;
Language = translateSettings.OutputLanguage;
OptimizeOutput = translateSettings.OptimizeOutput;
GlobalScope = Scope.GetGlobalScope();
RulesetScope = GlobalScope.Child();
RulesetScope.PrivateCatch = true;
Types.GetDefaults(this);
Importer = new Importer(this, FileGetter, translateSettings.Root.Uri);
Importer.CollectScriptFiles(translateSettings.Root);
Translate();
if (!Diagnostics.ContainsErrors())
{
ToWorkshop(translateSettings.AdditionalRules);
}
foreach (IComponent component in Components)
{
if (component is IDisposable disposable)
{
disposable.Dispose();
}
}
}
public DeltinScript(FileGetter fileGetter, Diagnostics diagnostics, ScriptFile rootRuleset, Func <VarCollection, Rule[]> addRules = null)
{
FileGetter = fileGetter;
Diagnostics = diagnostics;
types.AddRange(CodeType.DefaultTypes);
Importer = new Importer(rootRuleset.Uri);
CollectScriptFiles(rootRuleset);
GlobalScope = Scope.GetGlobalScope();
RulesetScope = GlobalScope.Child();
Translate();
if (!diagnostics.ContainsErrors())
{
ToWorkshop(addRules);
}
}
public DeltinScript(TranslateSettings translateSettings)
{
FileGetter = translateSettings.FileGetter;
Diagnostics = translateSettings.Diagnostics;
Language = translateSettings.OutputLanguage;
OptimizeOutput = translateSettings.OptimizeOutput;
types.AddRange(CodeType.DefaultTypes);
Importer = new Importer(translateSettings.Root.Uri);
CollectScriptFiles(translateSettings.Root);
GlobalScope = Scope.GetGlobalScope();
RulesetScope = GlobalScope.Child();
RulesetScope.PrivateCatch = true;
Translate();
if (!Diagnostics.ContainsErrors())
{
ToWorkshop(translateSettings.AdditionalRules);
}
}
public DeltinScript(TranslateSettings translateSettings)
{
FileGetter = translateSettings.FileGetter;
Diagnostics = translateSettings.Diagnostics;
Language = translateSettings.OutputLanguage;
OptimizeOutput = translateSettings.OptimizeOutput;
Types = new ScriptTypes(this);
Types.GetDefaults();
GlobalScope = new Scope("global scope");
RulesetScope = GlobalScope.Child();
RulesetScope.PrivateCatch = true;
Types.AddTypesToScope(GlobalScope);
Importer = new Importer(this, FileGetter, translateSettings.Root.Uri);
Importer.CollectScriptFiles(this, translateSettings.Root);
Translate();
if (!Diagnostics.ContainsErrors())
{
try
{
ToWorkshop(translateSettings.AdditionalRules);
}
catch (Exception ex)
{
WorkshopCode = "An exception was thrown while translating to workshop.\r\n" + ex.ToString();
}
}
foreach (IComponent component in Components)
{
if (component is IDisposable disposable)
{
disposable.Dispose();
}
}
}
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();
}
private void GetRulesets(string document, string file, bool isRoot, ImportedFile cache)
{
string absolute = new Uri(file).AbsolutePath;
// If this file was already loaded, don't load it again.
if (Imported.Contains(absolute))
{
return;
}
Imported.Add(absolute);
Diagnostics.AddFile(file);
// Get the ruleset.
RulesetNode ruleset;
if (cache == null)
{
ruleset = GetRuleset(file, document);
}
else if (cache.Update() || cache.Cache == null)
{
ruleset = GetRuleset(file, cache.Content);
cache.Cache = ruleset;
}
else
{
ruleset = (RulesetNode)cache.Cache;
}
Rulesets.Add(file, ruleset);
// Get the imported files.
if (ruleset != null && !Diagnostics.ContainsErrors())
{
ReservedGlobalIDs.AddRange(ruleset.ReservedGlobalIDs);
ReservedPlayerIDs.AddRange(ruleset.ReservedPlayerIDs);
if (ruleset.ReservedGlobal != null)
{
ReservedGlobalIDs.AddRange(ruleset.ReservedGlobal.ReservedIDs);
ReservedGlobalNames.AddRange(ruleset.ReservedGlobal.ReservedNames);
}
if (ruleset.ReservedPlayer != null)
{
ReservedPlayerIDs.AddRange(ruleset.ReservedPlayer.ReservedIDs);
ReservedPlayerNames.AddRange(ruleset.ReservedPlayer.ReservedNames);
}
List <string> importedFiles = new List <string>();
foreach (ImportNode importNode in ruleset.Imports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importNode.File, file, importNode.Location);
if (!importer.AlreadyImported)
{
GetRulesets(null, importer.ResultingPath, false, importer.FileData);
importedFiles.Add(importer.ResultingPath);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
}
private void GetObjects(string document, string file, TranslateRule globalTranslate, TranslateRule playerTranslate, bool isRoot)
{
// If this file was already loaded, don't load it again.
if (Imported.Contains(file))
{
return;
}
Imported.Add(file);
Diagnostics.AddFile(file);
// Get the ruleset.
RulesetNode ruleset = GetRuleset(file, document);
Rulesets.Add(file, ruleset);
if (ruleset != null && !Diagnostics.ContainsErrors())
{
if (isRoot)
{
VarCollection = new VarCollection(ruleset.UseGlobalVar, ruleset.UsePlayerVar, ruleset.UseBuilderVar);
Root = new ScopeGroup(VarCollection);
}
// Get the defined types
foreach (var definedType in ruleset.DefinedTypes)
{
try
{
if (DefinedTypes.Any(type => type.Name == definedType.Name))
{
throw SyntaxErrorException.NameAlreadyDefined(definedType.Location);
}
DefinedTypes.Add(DefinedType.GetDefinedType(definedType));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the user methods.
for (int i = 0; i < ruleset.UserMethods.Length; i++)
{
try
{
UserMethods.Add(new UserMethod(Root, ruleset.UserMethods[i]));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the rules
RuleNodes.AddRange(ruleset.Rules);
List <string> importedFiles = new List <string>();
foreach (ImportObjectNode importObject in ruleset.ObjectImports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importObject.File, file, importObject.Location);
if (!importer.AlreadyImported)
{
importedFiles.Add(importer.ResultingPath);
string content = importer.GetFile();
switch (importer.FileType)
{
case ".obj":
Model newModel = Model.ImportObj(content);
new ModelVar(importObject.Name, Root, importObject, newModel);
break;
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Check the imported files.
foreach (ImportNode importNode in ruleset.Imports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importNode.File, file, importNode.Location);
if (!importer.AlreadyImported)
{
string content = File.ReadAllText(importer.ResultingPath);
GetObjects(content, importer.ResultingPath, globalTranslate, playerTranslate, false);
importedFiles.Add(importer.ResultingPath);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the variables
foreach (var definedVar in ruleset.DefinedVars)
{
try
{
IndexedVar var;
if (definedVar.UseVar == null)
{
var = VarCollection.AssignVar(Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
else
{
var = VarCollection.AssignVar(
Root,
definedVar.VariableName,
definedVar.IsGlobal,
definedVar.UseVar.Variable,
definedVar.UseVar.Index,
definedVar
);
}
if (definedVar.Type != null)
{
var.Type = GetDefinedType(definedVar.Type, definedVar.Location);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
}