private void RenderToFile(string path, IEnumerable <GlobalDeclarationSyntax?> globals)
{
using (var fileStream = FileProvider.CreateFileAndFolder(path))
{
using (var writer = new StreamWriter(fileStream, new UTF8Encoding(false, true)))
{
var renderer = new JassRenderer(writer);
renderer.Options = _rendererOptions;
var globalsArray = globals.Where(global => global != null).ToArray();
var globalsDeclarationList = globalsArray.Length == 0
? new GlobalsDeclarationListSyntax(new EmptyNode(0))
: new GlobalsDeclarationListSyntax(globalsArray);
renderer.Render(JassSyntaxFactory.File(
new NewDeclarationSyntax(
new DeclarationSyntax(new GlobalsBlockSyntax(
new TokenNode(new SyntaxToken(SyntaxTokenType.GlobalsKeyword), 0),
new LineDelimiterSyntax(new EndOfLineSyntax(new TokenNode(new SyntaxToken(SyntaxTokenType.NewlineSymbol), 0))),
globalsDeclarationList,
new TokenNode(new SyntaxToken(SyntaxTokenType.EndglobalsKeyword), 0))),
new LineDelimiterSyntax(new EndOfLineSyntax(new TokenNode(new SyntaxToken(SyntaxTokenType.NewlineSymbol), 0))))));
}
}
}
public static void CompileScript(this Map map, MapScriptBuilder mapScriptBuilder)
{
if (map is null)
{
throw new ArgumentNullException(nameof(map));
}
if (mapScriptBuilder is null)
{
throw new ArgumentNullException(nameof(mapScriptBuilder));
}
if (map.Info.ScriptLanguage != ScriptLanguage.Jass)
{
throw new InvalidOperationException($"The map's script language must be set to jass in order to use the jass compiler.");
}
var compilationUnit = mapScriptBuilder.Build(map);
using var stream = new MemoryStream();
using (var writer = new StreamWriter(stream, _defaultEncoding, leaveOpen: true))
{
var renderer = new JassRenderer(writer);
renderer.Render(compilationUnit);
}
stream.Position = 0;
map.SetScriptFile(stream);
}
private void RenderToFile(string path, IEnumerable <FunctionSyntax> functions)
{
using (var fileStream = FileProvider.CreateFileAndFolder(path))
{
using (var writer = new StreamWriter(fileStream, new UTF8Encoding(false, true)))
{
var renderer = new JassRenderer(writer);
renderer.Options = _rendererOptions;
renderer.Render(JassSyntaxFactory.File(functions));
}
}
}
private static void RenderFunctionToFile(string path, FileSyntax fileSyntax)
{
using (var fileStream = FileProvider.OpenNewWrite(path))
{
using (var writer = new StreamWriter(fileStream, new UTF8Encoding(false, true)))
{
var mainAndConfigRenderer = new JassRenderer(writer);
mainAndConfigRenderer.SetNewlineString(true, true);
mainAndConfigRenderer.Comments = false;
mainAndConfigRenderer.Indentation = 4;
mainAndConfigRenderer.OptionalWhitespace = true;
mainAndConfigRenderer.OmitEmptyLines = false;
mainAndConfigRenderer.InlineConstants = false;
mainAndConfigRenderer.Render(fileSyntax);
}
}
}
public AdaptResult AdaptFile(Stream stream, TargetPatch targetPatch, GamePatch originPatch)
{
try
{
var commonJPath = Path.Combine(targetPatch.GameDataPath, PathConstants.CommonJPath);
if (!File.Exists(commonJPath))
{
return(new AdaptResult
{
Status = MapFileStatus.ConfigError,
Diagnostics = commonJPath.GetFileNotFoundDiagnostics(),
});
}
var blizzardJPath = Path.Combine(targetPatch.GameDataPath, PathConstants.BlizzardJPath);
if (!File.Exists(blizzardJPath))
{
return(new AdaptResult
{
Status = MapFileStatus.ConfigError,
Diagnostics = blizzardJPath.GetFileNotFoundDiagnostics(),
});
}
var commonJText = File.ReadAllText(commonJPath);
var commonJCompilationUnit = JassSyntaxFactory.ParseCompilationUnit(commonJText);
var blizzardJText = File.ReadAllText(blizzardJPath);
var blizzardJCompilationUnit = JassSyntaxFactory.ParseCompilationUnit(blizzardJText);
string scriptText;
using (var reader = new StreamReader(stream, leaveOpen: true))
{
scriptText = reader.ReadToEnd();
}
var compilationUnit = JassSyntaxFactory.ParseCompilationUnit(scriptText);
try
{
var context = new JassMapScriptAdapterContext();
foreach (var declaration in commonJCompilationUnit.Declarations)
{
RegisterDeclaration(declaration, context);
}
foreach (var declaration in blizzardJCompilationUnit.Declarations)
{
RegisterDeclaration(declaration, context);
}
// Common.j and Blizzard.j should not cause any diagnostics.
if (context.Diagnostics.Count > 0)
{
return(new AdaptResult
{
Status = MapFileStatus.AdapterError,
Diagnostics = context.Diagnostics.ToArray(),
});
}
if (TryAdaptCompilationUnit(context, compilationUnit, out var adaptedCompilationUnit))
{
var memoryStream = new MemoryStream();
using var writer = new StreamWriter(memoryStream, new UTF8Encoding(false, true), leaveOpen: true);
var renderer = new JassRenderer(writer);
renderer.Render(adaptedCompilationUnit);
return(new AdaptResult
{
Status = MapFileStatus.Adapted,
Diagnostics = context.Diagnostics.ToArray(),
AdaptedFileStream = memoryStream,
});
}
if (context.Diagnostics.Count == 0)
{
return(new AdaptResult
{
Status = MapFileStatus.Compatible,
});
}
else
{
return(new AdaptResult
{
Status = MapFileStatus.Incompatible,
Diagnostics = context.Diagnostics.ToArray(),
});
}
}
catch
{
return(new AdaptResult
{
Status = MapFileStatus.AdapterError,
});
}
}
catch (Exception e)
{
return(new AdaptResult
{
Status = MapFileStatus.ParseError,
Diagnostics = new[] { e.Message },
});
}
}
