public CompilerTestCase CreateTestCase(DirectoryInfo testDir)
{
FileInfo[] inputFiles = testDir.GetFiles("*.p");
string testName = new Uri(Constants.TestDirectory + Path.DirectorySeparatorChar)
.MakeRelativeUri(new Uri(testDir.FullName))
.ToString();
ICompilerTestRunner runner;
ITestResultsValidator validator;
CompilerOutput output = CompilerOutput.C;
runner = new CompileOnlyRunner(output, inputFiles);
// TODO: validate information about the particular kind of compiler error
bool isStaticError = testName.Contains("/StaticError/");
validator = isStaticError
? (ITestResultsValidator) new StaticErrorValidator()
: new CompileSuccessValidator();
DirectoryInfo tempDirName =
Directory.CreateDirectory(Path.Combine(testTempBaseDir.FullName, output.ToString(), testName));
return(new CompilerTestCase(tempDirName, runner, validator));
}
public static void Main(string[] args)
{
DirectoryInfo debugDirectoryInfo = Directory.GetParent(Directory.GetCurrentDirectory());
string workingDirectory = debugDirectoryInfo.Parent.Parent.Parent.Parent.FullName;
string filename = "Branch.sol";
string solcPath = workingDirectory + "\\Tool\\solc.exe";
string filePath = workingDirectory + "\\Test\\regression\\" + filename;
SolidityCompiler compiler = new SolidityCompiler();
CompilerOutput compilerOutput = compiler.Compile(solcPath, filePath);
SoliditySourceFile soliditySourceFile = compilerOutput.Sources[filename];
ASTNode root = soliditySourceFile.Ast;
Debug.Assert(root.GetType() == typeof(SourceUnit));
foreach (ASTNode decl in ((SourceUnit)root).Nodes)
{
if (decl is ContractDefinition)
{
ContractDefinition contract = (ContractDefinition)decl;
Console.WriteLine("contract " + contract.Name);
foreach (ASTNode node in contract.Nodes)
{
if (node is FunctionDefinition)
{
FunctionDefinition func = (FunctionDefinition)node;
Console.WriteLine("function " + func.Name);
Test(func);
}
}
}
}
Console.ReadLine();
}
public void OnCompilationSucceededAction(CompilerOutput output)
{
//for (int i = 0; i < output.Warnings.Count; i++)
// Debug.LogWarning(output.Warnings[i]);
_lastCompilationSucceeded = true;
}
private static void GetTargetLanguage(FileInfo fullPathName, ref CompilerOutput outputLanguage, ref bool generateSourceMaps)
{
XElement projectXML = XElement.Load(fullPathName.FullName);
if (projectXML.Elements("Target").Any())
{
switch (projectXML.Element("Target").Value.ToLowerInvariant())
{
case "c":
outputLanguage = CompilerOutput.C;
// check for generate source maps attribute
try
{
if (projectXML.Element("Target").Attributes("sourcemaps").Any())
{
generateSourceMaps = bool.Parse(projectXML.Element("Target").Attribute("sourcemaps").Value);
}
}
catch (Exception)
{
CommandlineOutput.WriteMessage($"Expected true or false, received {projectXML.Element("Target").Attribute("sourcemaps").Value}", SeverityKind.Error);
Environment.Exit(1);
}
break;
case "coyote":
outputLanguage = CompilerOutput.Coyote;
break;
default:
outputLanguage = CompilerOutput.C;
break;
}
}
}
//Method of type Action<CompilerOutput> that will be executed on succesfull compilation(without errors)
//Outputs warnings occured during compilation to editor console
public void OnCompilationSucceededAction(CompilerOutput output)
{
for (int i = 0; i < output.Warnings.Count; i++)
{
Debug.LogWarning(output.Warnings[i]);
}
}
public InputOptions()
{
SolutionXml = "";
Rebuild = false;
Relink = false;
Output = CompilerOutput.CSharp;
ProjectName = "";
}
/// <summary>
/// Logs the build result.
/// </summary>
/// <param name="output">The result of the build.</param>
public override void LogResult(CompilerOutput output)
{
if (Verbosity >= LoggerVerbosity.Quiet)
{
TextWriter w = output.Succeeded ? Console.Out : Console.Error;
w.WriteLine(output.ToString());
}
}
/// <summary>
/// Save a compiled application into a byte array.
/// </summary>
/// <param name="compiled">Compiled application to save.</param>
/// <returns>Saved queue.</returns>
public static byte[] SaveApplication(CompilerOutput compiled)
{
using (var ms = new MemoryStream())
{
var bf = new BinaryFormatter();
bf.Serialize(ms, compiled);
return ms.ToArray();
}
}
public void OnCompilationFailedAction(CompilerOutput output)
{
////Uncomment this to acquire additional information
//for (int i = 0; i < output.Errors.Count; i++)
// Debug.LogError(output.Errors[i]);
//for (int i = 0; i < output.Warnings.Count; i++)
// Debug.LogWarning(output.Warnings[i]);
_lastCompilationSucceeded = false;
}
/// <summary>
/// Logs the build result.
/// </summary>
/// <param name="output">The result of the build.</param>
public override void LogResult(CompilerOutput output)
{
if (Verbosity >= LoggerVerbosity.Quiet)
{
if (output.Succeeded)
Debug.WriteLine(output);
else
Debug.Fail("Build failed.", output.ToString());
}
}
// This method runs within a thread to compile code
static void threadedFunction(string code)
{
//Thread.Sleep(1000);
try{
compilerOutput_global = evaluateCode(code);
}catch (Exception ex) {
//System.Console.WriteLine("Caught: " + ex.ToString());
}
}
/// <summary>
/// Box a test case from the given directory and parsed Prt run configuration
/// </summary>
/// <param name="testDir">The directory containing P source files</param>
/// <param name="output">The desired output language</param>
/// <returns>The test case in a runnable state.</returns>
public CompilerTestCase CreateTestCase(DirectoryInfo testDir, CompilerOutput output)
{
var inputFiles = testDir.GetFiles("*.p");
var testName = new Uri(Constants.TestDirectory + Path.DirectorySeparatorChar)
.MakeRelativeUri(new Uri(testDir.FullName))
.ToString();
ICompilerTestRunner runner;
ITestResultsValidator validator;
string expectedOutput;
if (output.Equals(CompilerOutput.C))
{
var nativeFiles = testDir.GetFiles("*.c");
runner = new PrtRunner(inputFiles, nativeFiles);
expectedOutput =
File.ReadAllText(Path.Combine(testDir.FullName, "Prt", Constants.CorrectOutputFileName));
}
else if (output.Equals(CompilerOutput.PSharp))
{
var nativeFiles = testDir.GetFiles("*.cs");
runner = new PSharpRunner(inputFiles, nativeFiles);
var prtGoldenOutputFile = Path.Combine(testDir.FullName, "Prt", Constants.CorrectOutputFileName);
var prtSharpGoldenOutputFile =
Path.Combine(testDir.FullName, "PrtSharp", Constants.CorrectOutputFileName);
if (File.Exists(prtSharpGoldenOutputFile))
{
expectedOutput = File.ReadAllText(prtSharpGoldenOutputFile);
}
else
{
expectedOutput = File.ReadAllText(prtGoldenOutputFile);
}
}
else
{
throw new ArgumentOutOfRangeException();
}
// TODO: fix golden outputs for dynamic error assertions (79 tests)
ParseExpectedOutput(expectedOutput, out var stdout, out var stderr, out var exitCode);
if (testName.Contains("/DynamicError/") || output.Equals(CompilerOutput.PSharp))
{
stdout = null;
stderr = null;
}
validator = new ExecutionOutputValidator(exitCode, stdout, stderr);
var tempDirName =
Directory.CreateDirectory(Path.Combine(testTempBaseDir.FullName, output.ToString(), testName));
return(new CompilerTestCase(tempDirName, runner, validator));
}
//Method of type Action<CompilerOutput> that will be executed on failed compilation(with errors)
//Outputs errors occured during compilation to editor console
public void OnCompilationFailedAction(CompilerOutput output)
{
for (int i = 0; i < output.Errors.Count; i++)
{
Debug.LogError(output.Errors[i]);
}
for (int i = 0; i < output.Warnings.Count; i++)
{
Debug.LogWarning(output.Warnings[i]);
}
}
/// <summary>
/// Parse the P Project file
/// </summary>
/// <param name="projectFile">Path to the P project file</param>
/// <param name="job">out parameter of P compilation job, after parsing the project file</param>
/// <returns></returns>
public bool ParseProjectFile(string projectFile, out CompilationJob job)
{
job = null;
try
{
if (!IsLegalPProjFile(projectFile, out FileInfo projectFilePath))
{
throw new CommandlineParsingError($"Illegal P project file name {projectFile} or file {projectFilePath?.FullName} not found");
}
CommandlineOutput.WriteInfo($"----------------------------------------");
CommandlineOutput.WriteInfo($"==== Loading project file: {projectFile}");
CompilerOutput outputLanguage = CompilerOutput.C;
List <FileInfo> inputFiles = new List <FileInfo>();
bool generateSourceMaps = false;
List <string> projectDependencies = new List <string>();
// get all project dependencies and the input files
var dependencies = GetAllProjectDependencies(projectFilePath);
inputFiles.AddRange(dependencies.inputFiles);
projectDependencies.AddRange(dependencies.projectDependencies);
if (inputFiles.Count == 0)
{
throw new CommandlineParsingError("At least one .p file must be provided as input files, no input files found after parsing the project file");
}
// get project name
string projectName = GetProjectName(projectFilePath);
// get output directory
DirectoryInfo outputDirectory = GetOutputDirectory(projectFilePath);
// get target language
GetTargetLanguage(projectFilePath, ref outputLanguage, ref generateSourceMaps);
job = new CompilationJob(output: new DefaultCompilerOutput(outputDirectory), outputDirectory, outputLanguage: outputLanguage, inputFiles: inputFiles, projectName: projectName, projectFilePath.Directory, generateSourceMaps: generateSourceMaps, projectDependencies);
CommandlineOutput.WriteInfo($"----------------------------------------");
return(true);
}
catch (CommandlineParsingError ex)
{
CommandlineOutput.WriteError($"<Error parsing project file>:\n {ex.Message}");
return(false);
}
catch (Exception other)
{
CommandlineOutput.WriteError($"<Internal Error>:\n {other.Message}\n <Please report to the P team ([email protected]) or create a issue on GitHub, Thanks!>");
return(false);
}
}
public BatchExeResult Execute(string filename, out string expected, out string current)
{
BatchExeResult result = BatchExeResult.SolcError;
string filePath = Path.Combine(testDirectory, filename);
// compile the program
SolidityCompiler compiler = new SolidityCompiler();
CompilerOutput compilerOutput = compiler.Compile(solcPath, filePath);
if (compilerOutput.ContainsError())
{
compilerOutput.PrintErrorsToConsole();
throw new SystemException("Compilation Error");
}
// build the Solidity AST from solc output
AST solidityAST = new AST(compilerOutput, Path.GetDirectoryName(filePath));
// translate Solidity to Boogie
try
{
BoogieTranslator translator = new BoogieTranslator();
var translatorFlags = new TranslatorFlags();
translatorFlags.GenerateInlineAttributes = false;
BoogieAST boogieAST = translator.Translate(solidityAST, new HashSet <Tuple <string, string> >(), translatorFlags);
// dump the Boogie program to a file
using (var outWriter = new StreamWriter(outFile))
{
outWriter.WriteLine(boogieAST.GetRoot());
}
} catch (Exception e)
{
Console.WriteLine($"VeriSol translation error: {e.Message}");
result = BatchExeResult.SolToBoogieError;
expected = current = null;
return(result);
}
// read the corral configuration from Json
string configJsonPath = Path.Combine(configDirectory, Path.GetFileNameWithoutExtension(filename) + ".json");
string jsonString = File.ReadAllText(configJsonPath);
CorralConfiguration corralConfig = JsonConvert.DeserializeObject <CorralConfiguration>(jsonString);
string corralOutput = RunCorral(corralConfig);
expected = corralConfig.ExpectedResult;
current = corralOutput;
result = CompareCorralOutput(corralConfig.ExpectedResult, corralOutput);
return(result);
}
public CompilationJob(ICompilerOutput output, CompilerOutput outputLanguage, IReadOnlyList <FileInfo> inputFiles,
string projectName = null, bool generateSourceMaps = false)
{
if (!inputFiles.Any())
{
throw new ArgumentException("Must supply at least one input file", nameof(inputFiles));
}
Output = output;
InputFiles = inputFiles;
ProjectName = projectName ?? Path.GetFileNameWithoutExtension(inputFiles[0].FullName);
LocationResolver = new DefaultLocationResolver();
Handler = new DefaultTranslationErrorHandler(LocationResolver);
Backend = TargetLanguage.GetCodeGenerator(outputLanguage);
GenerateSourceMaps = generateSourceMaps;
}
/// <summary>
/// Box a test case from the given directory and parsed Prt run configuration
/// </summary>
/// <param name="testDir">The directory containing P source files</param>
/// <param name="output">The desired output language</param>
/// <returns>The test case in a runnable state.</returns>
public CompilerTestCase CreateTestCase(DirectoryInfo testDir, CompilerOutput output)
{
FileInfo[] inputFiles = testDir.GetFiles("*.p");
string testName = new Uri(Constants.TestDirectory + Path.DirectorySeparatorChar)
.MakeRelativeUri(new Uri(testDir.FullName))
.ToString();
ICompilerTestRunner runner;
ITestResultsValidator validator;
int expectedExitCode;
if (testName.Contains("/DynamicError/") || testName.Contains("/DynamicErrorCoyoteRuntime/"))
{
expectedExitCode = 1;
}
else if (testName.Contains("/Correct/") || testName.Contains("/CorrectCoyoteRuntime/"))
{
expectedExitCode = 0;
}
else
{
throw new CompilerTestException(TestCaseError.UnrecognizedTestCaseType);
}
if (output.Equals(CompilerOutput.C))
{
FileInfo[] nativeFiles = testDir.GetFiles("*.c");
runner = new PrtRunner(inputFiles, nativeFiles);
}
else if (output.Equals(CompilerOutput.Coyote))
{
FileInfo[] nativeFiles = testDir.GetFiles("*.cs");
runner = new CoyoteRunner(inputFiles, nativeFiles);
}
else
{
throw new ArgumentOutOfRangeException();
}
validator = new ExecutionOutputValidator(expectedExitCode);
DirectoryInfo tempDirName =
Directory.CreateDirectory(Path.Combine(testTempBaseDir.FullName, output.ToString(), testName));
return(new CompilerTestCase(tempDirName, runner, validator));
}
public void UpdateSolution(Solution solution)
{
solution.State = StateId;
solution.RunTime = RunTimeMs;
solution.UsingMemoryMb = UsingMemoryMb;
solution.CompilerOutput = CompilerOutput?.Substring(0, Math.Min(Solution.CompilerOutputLimit, CompilerOutput.Length));
if (WrongAnswer != null)
{
var wrongAnswer = solution.WrongAnswer ?? new SolutionWrongAnswer();
{
wrongAnswer.QuestionDataId = WrongAnswerInputId;
wrongAnswer.Output = WrongAnswer?.Substring(0, Math.Min(SolutionWrongAnswer.WrongAnswerLimit, WrongAnswer.Length));
}
solution.WrongAnswer = wrongAnswer;
}
solution.Lock = null;
}
// This method evaluates the given code and returns a CompilerOutput object
public static CompilerOutput evaluateCode(string code)
{
CompilerOutput compilerOutput = new CompilerOutput();
/*
* var compilerContext = new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter());
*
* var evaluator = new Evaluator(compilerContext);
*/
var reportWriter = new StringWriter();
var settings = new CompilerSettings();
var printer = new ConsoleReportPrinter(reportWriter);
var compilerContext = new CompilerContext(settings, printer);
var reports = new Report(compilerContext, printer);
var evaluator = new Evaluator(compilerContext);
var myString = "";
originalConsoleOut_global = Console.Out; // preserve the original stream
using (var writer = new StringWriter())
{
Console.SetOut(writer);
evaluator.Run(code);
evaluator.Run("MainClass m1 = new MainClass(); m1.Main();");
//bConsole.WriteLine ("after executing code");
if (reports.Errors > 0)
{
Console.WriteLine("reportWriter.ToString: \n" + reportWriter.ToString());
compilerOutput.errors = reportWriter.ToString();
}
writer.Flush(); // make sure everything is written out of consule
myString = writer.GetStringBuilder().ToString();
compilerOutput.consoleOut = myString;
}
Console.SetOut(originalConsoleOut_global); // restore Console.Out
return(compilerOutput);
}
// This method evaluates the given code and returns a CompilerOutput object
public static CompilerOutput evaluateCode(string code)
{
CompilerOutput compilerOutput = new CompilerOutput ();
/*
var compilerContext = new CompilerContext(new CompilerSettings(), new ConsoleReportPrinter());
var evaluator = new Evaluator(compilerContext);
*/
var reportWriter = new StringWriter();
var settings = new CompilerSettings();
var printer = new ConsoleReportPrinter(reportWriter);
var compilerContext = new CompilerContext (settings, printer);
var reports = new Report(compilerContext, printer);
var evaluator = new Evaluator(compilerContext);
var myString = "";
originalConsoleOut_global = Console.Out; // preserve the original stream
using(var writer = new StringWriter())
{
Console.SetOut(writer);
evaluator.Run (code);
evaluator.Run ("MainClass m1 = new MainClass(); m1.Main();");
//bConsole.WriteLine ("after executing code");
if (reports.Errors > 0) {
Console.WriteLine ("reportWriter.ToString: \n" + reportWriter.ToString ());
compilerOutput.errors = reportWriter.ToString ();
}
writer.Flush(); // make sure everything is written out of consule
myString = writer.GetStringBuilder().ToString();
compilerOutput.consoleOut = myString;
}
Console.SetOut(originalConsoleOut_global); // restore Console.Out
return compilerOutput;
}
/**
* Runs solidity conversion function
*/
private bool runSolidityToBoogieConversion()
{
Console.WriteLine("Starting Solidity Compiler.");
// compile the program
Console.WriteLine($"Running Compiler on {contractName}.");
SolidityCompiler compiler = new SolidityCompiler();
CompilerOutput compilerOutput = compiler.Compile(solidityCompilerPath, solidityFilePath);
if (compilerOutput.ContainsError())
{
compilerOutput.PrintErrorsToConsole();
throw new SystemException("Compilation Error");
}
// build the Solidity AST from solc output
AST solidityAST = new AST(compilerOutput, Path.GetDirectoryName(solidityFilePath));
// translate Solidity to Boogie
try
{
// if application reaches this stage, compilation of the program was successful
// The application now attemps to convert the solidity code to Boogie through the use of collection and syntax trees.
ConversionToBoogie_Main translator = new ConversionToBoogie_Main();
Console.WriteLine($"\nAttempting Conversion to Boogie.");
BoogieAST boogieAST = translator.Translate(solidityAST, ignoreMethods, translatorFlags);
// dump the Boogie program to a file
var outFilePath = Path.Combine(solidityFileDir, boogieRepresentationOfSolContract);
using (var outWriter = new StreamWriter(boogieRepresentationOfSolContract))
{
outWriter.WriteLine(boogieAST.GetRoot());//get all AST components
}
}
catch (Exception e)
{
Console.WriteLine($"OverSight translation error: {e.Message}");
return(false);
}
return(true);
}
private static bool ParseProjectFile(string projectFile, out CompilationJob job)
{
job = null;
if (!IsLegalPProjFile(projectFile, out FileInfo projectFilePath))
{
CommandlineOutput.WriteMessage(
$"Illegal P project file name {projectFile} or file {projectFilePath?.FullName} not found", SeverityKind.Error);
return(false);
}
CommandlineOutput.WriteMessage($".... Parsing the project file: {projectFile}", SeverityKind.Info);
CompilerOutput outputLanguage = CompilerOutput.C;
List <FileInfo> inputFiles = new List <FileInfo>();
bool generateSourceMaps = false;
List <string> projectDependencies = new List <string>();
// get all project dependencies and the input files
var dependencies = GetAllProjectDependencies(projectFilePath);
inputFiles.AddRange(dependencies.inputFiles);
projectDependencies.AddRange(dependencies.projectDependencies);
if (inputFiles.Count == 0)
{
CommandlineOutput.WriteMessage("At least one .p file must be provided as input files", SeverityKind.Error);
return(false);
}
// get project name
string projectName = GetProjectName(projectFilePath);
// get output directory
DirectoryInfo outputDirectory = GetOutputDirectory(projectFilePath);
// get target language
GetTargetLanguage(projectFilePath, ref outputLanguage, ref generateSourceMaps);
job = new CompilationJob(output: new DefaultCompilerOutput(outputDirectory), outputLanguage: outputLanguage, inputFiles: inputFiles, projectName: projectName, generateSourceMaps: generateSourceMaps, projectDependencies);
return(true);
}
// This method accepts a string which contains CSharp code then calls another functions to evaluate and execute the code
// Output of this function is a string in JSON format
public string compileCode(string code)
{
CompilerOutput result = new CompilerOutput();
if (isDangerousCode(code))
{
result.errors = "Possible dangerous code";
}
else if (code.Length >= code_input_limit_global)
{
result.errors = "Due to server limits, we have restricted code size to " + code_input_limit_global + " characters.";
}
else
{
result = run(code);
}
string jsontmp = toJSON(result);
return(jsontmp);
}
private bool ExecuteSolToBoogie()
{
// compile the program
Console.WriteLine($"\n----- Running Solc on {SpecFilePath}....");
SolidityCompiler compiler = new SolidityCompiler();
CompilerOutput compilerOutput = compiler.Compile(SolcPath, SpecFilePath);
if (compilerOutput.ContainsError())
{
compilerOutput.PrintErrorsToConsole();
throw new SystemException("Compilation Error");
}
// build the Solidity AST from solc output
AST solidityAST = new AST(compilerOutput, Path.GetDirectoryName(SpecFilePath));
// translate Solidity to Boogie
try
{
BoogieTranslator translator = new BoogieTranslator();
Console.WriteLine($"\n----- Running SolToBoogie....");
var translatorFlags = new TranslatorFlags();
translatorFlags.GenerateInlineAttributes = true;
BoogieAST boogieAST = translator.Translate(solidityAST, ignoreMethods, translatorFlags);
// dump the Boogie program to a file
var outFilePath = Path.Combine(SpecFileDir, outFileName);
using (var outWriter = new StreamWriter(outFileName))
{
outWriter.WriteLine(boogieAST.GetRoot());
}
}
catch (Exception e)
{
Console.WriteLine($"VeriSol translation error: {e.Message}");
return(false);
}
return(true);
}
public CompilationJob(ICompilerOutput output, DirectoryInfo outputDir, CompilerOutput outputLanguage, IReadOnlyList <FileInfo> inputFiles,
string projectName, DirectoryInfo projectRoot = null, bool generateSourceMaps = false, IReadOnlyList <string> projectDependencies = null,
DirectoryInfo aspectjOutputDir = null)
{
if (!inputFiles.Any())
{
throw new ArgumentException("Must supply at least one input file", nameof(inputFiles));
}
Output = output;
OutputDirectory = outputDir;
AspectjOutputDirectory = aspectjOutputDir;
InputFiles = inputFiles;
ProjectName = projectName ?? Path.GetFileNameWithoutExtension(inputFiles[0].FullName);
ProjectRootPath = projectRoot;
LocationResolver = new DefaultLocationResolver();
Handler = new DefaultTranslationErrorHandler(LocationResolver);
OutputLanguage = outputLanguage;
Backend = TargetLanguage.GetCodeGenerator(outputLanguage);
GenerateSourceMaps = generateSourceMaps;
ProjectDependencies = projectDependencies ?? new List <string>();
}
private void GetTargetLanguage(FileInfo fullPathName, ref CompilerOutput outputLanguage, ref bool generateSourceMaps)
{
XElement projectXml = XElement.Load(fullPathName.FullName);
if (!projectXml.Elements("Target").Any())
{
return;
}
switch (projectXml.Element("Target")?.Value.ToLowerInvariant())
{
case "c":
outputLanguage = CompilerOutput.C;
// check for generate source maps attribute
try
{
if (projectXml.Element("Target")?.Attributes("sourcemaps").Any() != null)
{
generateSourceMaps = bool.Parse(projectXml.Element("Target")?.Attribute("sourcemaps")?.Value ?? string.Empty);
}
}
catch (Exception)
{
throw new CommandlineParsingError($"Expected true or false, received {projectXml.Element("Target")?.Attribute("sourcemaps")?.Value}");
}
break;
case "csharp":
outputLanguage = CompilerOutput.CSharp;
break;
case "rvm":
outputLanguage = CompilerOutput.Rvm;
break;
default:
throw new CommandlineParsingError($"Expected C or CSharp as target, received {projectXml.Element("Target")?.Value}");
}
}
public static CommandLineParseResult ParseArguments(IEnumerable <string> args, out CompilationJob job)
{
job = null;
CompilerOutput outputLanguage = CompilerOutput.C;
DirectoryInfo outputDirectory = null;
List <string> commandLineFileNames = new List <string>();
List <FileInfo> inputFiles = new List <FileInfo>();
string targetName = null;
bool generateSourceMaps = false;
// enforce the argument prority
// proj takes priority over everything else and no other arguments should be passed
if (args.Where(a => a.ToLowerInvariant().Contains("-proj:")).Any() && args.Count() > 1)
{
CommandlineOutput.WriteMessage("-proj cannot be combined with other commandline options", SeverityKind.Error);
return(Failure);
}
foreach (string x in args)
{
string arg = x;
string colonArg = null;
if (arg[0] == '-')
{
int colonIndex = arg.IndexOf(':');
if (colonIndex >= 0)
{
arg = x.Substring(0, colonIndex);
colonArg = x.Substring(colonIndex + 1);
}
switch (arg.Substring(1).ToLowerInvariant())
{
case "t":
case "target":
if (colonArg == null)
{
CommandlineOutput.WriteMessage("Missing target name", SeverityKind.Error);
}
else if (targetName == null)
{
targetName = colonArg;
}
else
{
CommandlineOutput.WriteMessage("Only one target must be specified", SeverityKind.Error);
}
break;
case "g":
case "generate":
switch (colonArg?.ToLowerInvariant())
{
case null:
CommandlineOutput.WriteMessage(
"Missing generation argument, expecting generate:[C,Coyote]", SeverityKind.Error);
return(Failure);
case "c":
outputLanguage = CompilerOutput.C;
break;
case "coyote":
outputLanguage = CompilerOutput.Coyote;
break;
default:
CommandlineOutput.WriteMessage(
$"Unrecognized generate option '{colonArg}', expecting C or Coyote",
SeverityKind.Error);
return(Failure);
}
break;
case "o":
case "outputdir":
if (colonArg == null)
{
CommandlineOutput.WriteMessage("Must supply path for output directory",
SeverityKind.Error);
return(Failure);
}
outputDirectory = Directory.CreateDirectory(colonArg);
break;
case "proj":
if (colonArg == null)
{
CommandlineOutput.WriteMessage("Must supply project file for compilation",
SeverityKind.Error);
return(Failure);
}
else
{
// Parse the project file and generate the compilation job, ignore all other arguments passed
if (ParseProjectFile(colonArg, out job))
{
return(Success);
}
else
{
return(Failure);
}
}
case "s":
case "sourcemaps":
switch (colonArg?.ToLowerInvariant())
{
case null:
case "true":
generateSourceMaps = true;
break;
case "false":
generateSourceMaps = false;
break;
default:
CommandlineOutput.WriteMessage(
"sourcemaps argument must be either 'true' or 'false'", SeverityKind.Error);
return(Failure);
}
break;
case "h":
case "help":
case "-help":
return(HelpRequested);
default:
commandLineFileNames.Add(arg);
CommandlineOutput.WriteMessage($"Unknown Command {arg.Substring(1)}", SeverityKind.Error);
return(Failure);
}
}
else
{
commandLineFileNames.Add(arg);
}
}
// We are here so no project file supplied lets create a compilation job with other arguments
// Each command line file name must be a legal P file name
foreach (string inputFileName in commandLineFileNames)
{
if (IsLegalPFile(inputFileName, out FileInfo fullPathName))
{
inputFiles.Add(fullPathName);
}
else
{
CommandlineOutput.WriteMessage(
$"Illegal P file name {inputFileName} or file {fullPathName.FullName} not found", SeverityKind.Error);
}
}
if (inputFiles.Count == 0)
{
CommandlineOutput.WriteMessage("At least one .p file must be provided", SeverityKind.Error);
return(Failure);
}
string projectName = targetName ?? Path.GetFileNameWithoutExtension(inputFiles[0].FullName);
if (!IsLegalUnitName(projectName))
{
CommandlineOutput.WriteMessage($"{projectName} is not a legal project name", SeverityKind.Error);
return(Failure);
}
if (outputDirectory == null)
{
outputDirectory = new DirectoryInfo(Directory.GetCurrentDirectory());
}
job = new CompilationJob(output: new DefaultCompilerOutput(outputDirectory), outputLanguage: outputLanguage, inputFiles: inputFiles, projectName: projectName, generateSourceMaps: generateSourceMaps);
return(Success);
}
private static bool ParseProjectFile(string projectFile, out CompilationJob job)
{
job = null;
if (!IsLegalPProjFile(projectFile, out FileInfo fullPathName))
{
CommandlineOutput.WriteMessage(
$"Illegal P project file name {projectFile} or file {fullPathName?.FullName} not found", SeverityKind.Error);
return(false);
}
CommandlineOutput.WriteMessage($".... Parsing the project file: {projectFile}", SeverityKind.Info);
CompilerOutput outputLanguage = CompilerOutput.C;
DirectoryInfo outputDirectory = null;
List <FileInfo> inputFiles = new List <FileInfo>();
string targetName = null;
bool generateSourceMaps = false;
XElement projectXML = XElement.Load(fullPathName.FullName);
// get all files to be compiled
foreach (XElement inputs in projectXML.Elements("InputFiles"))
{
foreach (XElement inputFileName in inputs.Elements("PFile"))
{
var pFiles = new List <string>();
if (Directory.Exists(inputFileName.Value))
{
foreach (var files in Directory.GetFiles(inputFileName.Value, "*.p"))
{
pFiles.Add(files);
}
}
else
{
pFiles.Add(inputFileName.Value);
}
foreach (var pFile in pFiles)
{
if (IsLegalPFile(pFile, out FileInfo pFilePathName))
{
CommandlineOutput.WriteMessage($"....... project includes: {pFilePathName.FullName}", SeverityKind.Info);
inputFiles.Add(pFilePathName);
}
else
{
CommandlineOutput.WriteMessage(
$"Illegal P file name {pFile} or file {pFilePathName?.FullName} not found", SeverityKind.Error);
}
}
}
}
if (inputFiles.Count == 0)
{
CommandlineOutput.WriteMessage("At least one .p file must be provided as input files", SeverityKind.Error);
return(false);
}
// get target file name
if (projectXML.Elements("TargetFileName").Any())
{
targetName = projectXML.Element("TargetFileName").Value;
if (!IsLegalUnitName(targetName))
{
CommandlineOutput.WriteMessage($"{targetName} is not a legal target file name", SeverityKind.Error);
return(false);
}
}
string projectName = targetName ?? Path.GetFileNameWithoutExtension(inputFiles[0].FullName);
// get output directory
outputDirectory = projectXML.Elements("OutputDir").Any() ? Directory.CreateDirectory(projectXML.Element("OutputDir").Value) : new DirectoryInfo(Directory.GetCurrentDirectory());
// get target language
if (projectXML.Elements("Target").Any())
{
switch (projectXML.Element("Target").Value.ToLowerInvariant())
{
case "c":
outputLanguage = CompilerOutput.C;
// check for generate source maps attribute
try
{
if (projectXML.Element("Target").Attributes("sourcemaps").Any())
{
generateSourceMaps = bool.Parse(projectXML.Element("Target").Attribute("sourcemaps").Value);
}
}
catch (Exception)
{
CommandlineOutput.WriteMessage($"Expected true or false, received {projectXML.Element("Target").Attribute("sourcemaps").Value}", SeverityKind.Error);
}
break;
case "p#":
outputLanguage = CompilerOutput.PSharp;
break;
default:
outputLanguage = CompilerOutput.C;
break;
}
}
job = new CompilationJob(output: new DefaultCompilerOutput(outputDirectory), outputLanguage: outputLanguage, inputFiles: inputFiles, projectName: projectName, generateSourceMaps: generateSourceMaps);
return(true);
}
/// <summary>
/// Parse the commandline arguments to construct the compilation job
/// </summary>
/// <param name="args">Commandline arguments</param>
/// <param name="job">Generated Compilation job</param>
/// <returns></returns>
internal bool ParseCommandLineOptions(IEnumerable <string> args, out CompilationJob job)
{
string targetName = null;
CompilerOutput outputLanguage = CompilerOutput.CSharp;
DirectoryInfo outputDirectory = null;
List <FileInfo> inputFiles = new List <FileInfo>();
job = null;
try
{
foreach (string x in args)
{
string arg = x;
string colonArg = null;
if (arg[0] == '-')
{
int colonIndex = arg.IndexOf(':');
if (colonIndex >= 0)
{
arg = x.Substring(0, colonIndex);
colonArg = x.Substring(colonIndex + 1);
}
switch (arg.Substring(1).ToLowerInvariant())
{
case "t":
case "target":
if (colonArg == null)
{
throw new CommandlineParsingError("Missing target project name (-t:<project name>)");
}
else if (targetName == null)
{
targetName = colonArg;
}
else
{
throw new CommandlineParsingError("Only one target must be specified with (-t)");
}
break;
case "g":
case "generate":
switch (colonArg?.ToLowerInvariant())
{
case null:
throw new CommandlineParsingError("Missing generation argument, expecting generate:[C,CSharp,RVM]");
case "c":
outputLanguage = CompilerOutput.C;
break;
case "csharp":
outputLanguage = CompilerOutput.CSharp;
break;
case "rvm":
outputLanguage = CompilerOutput.Rvm;
break;
default:
throw new CommandlineParsingError($"Unrecognized generate option '{colonArg}', expecting C or CSharp");
}
break;
case "o":
case "outputdir":
if (colonArg == null)
{
throw new CommandlineParsingError("Must supply path for output directory (-o:<output directory>)");
}
outputDirectory = Directory.CreateDirectory(colonArg);
break;
default:
CommandLineOptions.PrintUsage();
throw new CommandlineParsingError($"Illegal Command {arg.Substring(1)}");
}
}
else
{
if (IsLegalPFile(arg, out FileInfo fullPathName))
{
inputFiles.Add(fullPathName);
}
else
{
throw new CommandlineParsingError($"Illegal P file name {arg} or file {fullPathName.FullName} not found");
}
}
}
if (inputFiles.Count == 0)
{
commandlineOutput.WriteError("At least one .p file must be provided");
return(false);
}
string projectName = targetName ?? Path.GetFileNameWithoutExtension(inputFiles[0].FullName);
if (!IsLegalProjectName(projectName))
{
commandlineOutput.WriteError($"{projectName} is not a legal project name");
return(false);
}
if (outputDirectory == null)
{
outputDirectory = new DirectoryInfo(Directory.GetCurrentDirectory());
}
job = new CompilationJob(output: new DefaultCompilerOutput(outputDirectory), outputDirectory, outputLanguage: outputLanguage, inputFiles: inputFiles, projectName: projectName, outputDirectory);
commandlineOutput.WriteInfo($"----------------------------------------");
return(true);
}
catch (CommandlineParsingError ex)
{
commandlineOutput.WriteError($"<Error parsing commandline>:\n {ex.Message}");
return(false);
}
catch (Exception other)
{
commandlineOutput.WriteError($"<Internal Error>:\n {other.Message}\n <Please report to the P team ([email protected]) or create an issue on GitHub, Thanks!>");
return(false);
}
}
public static ICodeGenerator GetCodeGenerator(CompilerOutput languageName)
{
return(BackendMap[languageName]);
}
private static void RegisterCodeGenerator(CompilerOutput name, ICodeGenerator generator)
{
BackendMap[name] = generator;
}
/// <summary>
/// Box a new compile runner
/// </summary>
/// <param name="compilerOutput"></param>
/// <param name="inputFiles">The P source files to compile</param>
public CompileOnlyRunner(CompilerOutput compilerOutput, IReadOnlyList <FileInfo> inputFiles)
{
this.inputFiles = inputFiles;
this.compilerOutput = compilerOutput;
}
private int TestPc(
TestConfig config,
TextWriter tmpWriter,
DirectoryInfo workDirectory,
string activeDirectory,
CompilerOutput outputLanguage)
{
List <string> pFiles = workDirectory.EnumerateFiles("*.p").Select(pFile => pFile.FullName).ToList();
if (!pFiles.Any())
{
throw new Exception("no .p file found in test directory");
}
string inputFileName = pFiles.First();
string linkFileName = Path.ChangeExtension(inputFileName, ".4ml");
var compilerOutput = new CompilerTestOutputStream(tmpWriter);
var compileArgs = new CommandLineOptions
{
inputFileNames = new List <string>(pFiles),
shortFileNames = true,
outputDir = workDirectory.FullName,
unitName = linkFileName,
//liveness = LivenessOption.None,
liveness = outputLanguage == CompilerOutput.Zing && config.Arguments.Contains("/liveness")
? LivenessOption.Standard
: LivenessOption.None,
compilerOutput = outputLanguage
};
// Compile
if (!PCompiler.Value.Compile(compilerOutput, compileArgs))
//if (!PCompilerService.Value.Compile(compilerOutput, compileArgs))
{
tmpWriter.WriteLine("EXIT: -1");
return(-1);
}
//(TODO)Skip the link step if outputLanguage == CompilerOutput.CSharp?
// Link
compileArgs.dependencies.Add(linkFileName);
compileArgs.inputFileNames.Clear();
if (config.Link != null)
{
compileArgs.inputFileNames.Add(Path.Combine(activeDirectory, config.Link));
}
if (!PCompiler.Value.Link(compilerOutput, compileArgs))
//if(!PCompilerService.Value.Link(compilerOutput, compileArgs))
{
tmpWriter.WriteLine("EXIT: -1");
return(-1);
}
else
{
tmpWriter.WriteLine("EXIT: 0");
}
return(0);
}
// This method runs within a thread to compile code
static void threadedFunction(string code)
{
//Thread.Sleep(1000);
try{
compilerOutput_global = evaluateCode (code);
}catch(Exception ex){
//System.Console.WriteLine("Caught: " + ex.ToString());
}
}
public static void Main(string[] args)
{
if (args.Length < 3)
{
Console.WriteLine("Usage: SolToBoogie <relative path to filename.sol> <workingdir> <relative path to outfile.bpl> [options]");
Console.WriteLine("\t Options:");
Console.WriteLine("\t\t /break: Opens the debugger");
Console.WriteLine("\t\t /ignoreMethod:<method>@<contract>: Ignores translation of the method within contract, and only generates a declaration");
Console.WriteLine("\t\t\t\t multiple such pairs can be specified, ignored set is the union");
Console.WriteLine("\t\t\t\t a wild card '*' can be used for method, would mean all the methods of the contract");
Console.WriteLine("\t\t /noInlineAttrs: do not generate any {:inline x} attributes, to speed Corral");
return;
}
string filePath = Path.Combine(Directory.GetCurrentDirectory(), args[0]);
string workingDirectory = args[1];
string outFile = Path.Combine(Directory.GetCurrentDirectory(), args[2]);
string solcName = GetSolcNameByOSPlatform();
string solcPath = Path.Combine(workingDirectory, "Tool", solcName);
SolidityCompiler compiler = new SolidityCompiler();
CompilerOutput compilerOutput = compiler.Compile(solcPath, filePath);
HashSet <Tuple <string, string> > ignoredMethods = new HashSet <Tuple <string, string> >();
// Issue with run_verisol_win.cmd it passes "/ignoreMethod:a@b /ignoreMethod:c@d .." as a single string
var splitArgs = new List <string>();
args.Select(arg => arg.Split(" "))
.ToList()
.ForEach(a => a.ToList().ForEach(b => splitArgs.Add(b)));
if (splitArgs.Any(x => x.Equals("/break")))
{
Debugger.Launch();
}
foreach (var arg in splitArgs.Where(x => x.StartsWith("/ignoreMethod:")))
{
Debug.Assert(arg.Contains("@"), $"Error: incorrect use of /ignoreMethod in {arg}");
Debug.Assert(arg.LastIndexOf("@") == arg.IndexOf("@"), $"Error: incorrect use of /ignoreMethod in {arg}");
var str = arg.Substring("/ignoreMethod:".Length);
var method = str.Substring(0, str.IndexOf("@"));
var contract = str.Substring(str.IndexOf("@") + 1);
ignoredMethods.Add(Tuple.Create(method, contract));
}
Console.WriteLine($"Ignored method/contract pairs ==> \n\t {string.Join(",", ignoredMethods.Select(x => x.Item1 + "@" + x.Item2))}");
bool genInlineAttributesInBpl = true;
if (splitArgs.Any(x => x.Equals("/noInlineAttrs")))
{
genInlineAttributesInBpl = false;
}
if (compilerOutput.ContainsError())
{
PrintErrors(compilerOutput.Errors);
throw new SystemException("Compilation Error");
}
else
{
AST solidityAST = new AST(compilerOutput, Path.GetDirectoryName(filePath));
try
{
BoogieTranslator translator = new BoogieTranslator();
BoogieAST boogieAST = translator.Translate(solidityAST, ignoredMethods, genInlineAttributesInBpl);
using (var outWriter = new StreamWriter(outFile))
{
outWriter.WriteLine(boogieAST.GetRoot());
}
}
catch (Exception e)
{
Console.WriteLine($"Verisol translation exception: {e.Message}");
}
}
}
// This method accepts a string which contains CSharp code then calls another functions to evaluate and execute the code
// Output of this function is a string in JSON format
public string compileCode(string code)
{
CompilerOutput result = new CompilerOutput();
if (isDangerousCode (code)) {
result.errors = "Possible dangerous code";
} else if (code.Length >= code_input_limit_global) {
result.errors = "Due to server limits, we have restricted code size to " + code_input_limit_global + " characters.";
}else {
result = run (code);
}
string jsontmp = toJSON (result);
return jsontmp;
}
