// ----- Statements -------------------------------------------------------------
protected override void EmitPrintStmt(TargetWriter wr, Expression arg)
{
wr.Indent();
wr.Write("process.stdout.write(");
TrParenExpr(arg, wr, false);
wr.WriteLine(".toString());");
}
protected override void EmitMemberSelect(MemberDecl member, bool isLValue, TargetWriter wr)
{
if (isLValue && member is ConstantField)
{
wr.Write("._{0}", member.CompileName);
}
else if (member is DatatypeDestructor dtor)
{
if (dtor.EnclosingClass is TupleTypeDecl)
{
wr.Write("[{0}]", dtor.Name);
}
else
{
wr.Write(".{0}", IdName(member));
}
}
else if (!isLValue && member is SpecialField sf)
{
string compiledName, preStr, postStr;
GetSpecialFieldInfo(sf.SpecialId, sf.IdParam, out compiledName, out preStr, out postStr);
if (compiledName.Length != 0)
{
wr.Write(".{0}", compiledName);
}
else
{
// this member selection is handled by some kind of enclosing function call, so nothing to do here
}
}
else
{
wr.Write(".{0}", IdName(member));
}
}
protected override BlockTargetWriter CreateInternalClass(TargetWriter wr, string className)
{
var w = wr.NewBlock("{0}:", className);
w.Footer = ",";
return(w);
}
protected override BlockTargetWriter /*?*/ CreateMethod(Method m, bool createBody, TargetWriter wr)
{
if (!createBody)
{
return(null);
}
wr.Indent();
wr.Write("{0}{1}(", m.IsStatic ? "static " : "", IdName(m));
int nIns = WriteFormals("", m.Ins, wr);
var w = wr.NewBlock(")");
if (!m.IsStatic)
{
w.Indent(); w.WriteLine("let _this = this;");
}
if (m.IsTailRecursive)
{
w.Indent();
w = w.NewBlock("TAIL_CALL_START: while (true)");
}
var r = new TargetWriter(w.IndentLevel);
EmitReturn(m.Outs, r);
w.BodySuffix = r.ToString();
return(w);
}
// ----- Statements -------------------------------------------------------------
protected override void EmitPrintStmt(TargetWriter wr, Expression arg)
{
wr.Indent();
wr.Write("console.log(");
TrExpr(arg, wr, false);
wr.WriteLine(");");
}
/// <inheritdoc />
public override void Write(string value)
{
if (!string.IsNullOrEmpty(value))
{
TargetWriter.Write(value);
}
}
public void Dispose()
{
if (SourceReader != null)
{
SourceReader.Close();
SourceReader.Dispose();
}
if (TargetWriter != null)
{
TargetWriter.Flush();
TargetWriter.Close();
TargetWriter.Dispose();
}
if (SourceStream != null)
{
SourceStream.Close();
SourceStream.Dispose();
}
if (TargetStream != null)
{
TargetStream.Close();
TargetStream.Dispose();
}
}
protected override BlockTargetWriter CreateMethod(TargetWriter wrx, Method m)
{
var wr = wrx.NewBlock("");
wr.SetBraceStyle(BlockTargetWriter.BraceStyle.Newline, BlockTargetWriter.BraceStyle.Newline);
var dllSw = new StringWriter();
var hasDllImportAttribute = ProcessDllImport(m, dllSw);
wr.AppendHeader(dllSw.ToString());
string targetReturnTypeReplacement = null;
if (hasDllImportAttribute)
{
wr.AppendHeader(wrx.IndentString);
foreach (var p in m.Outs)
{
if (!p.IsGhost)
{
if (targetReturnTypeReplacement == null)
{
targetReturnTypeReplacement = TypeName(p.Type, wr, p.tok);
}
else if (targetReturnTypeReplacement != null)
{
// there's more than one out-parameter, so bail
targetReturnTypeReplacement = null;
break;
}
}
}
}
var sw = new StringWriter();
sw.Write("public {0}{1}{3} @{2}", m.IsStatic ? "static " : "", hasDllImportAttribute ? "extern " : "", m.CompileName, targetReturnTypeReplacement ?? "void");
if (m.TypeArgs.Count != 0)
{
sw.Write("<{0}>", TypeParameters(m.TypeArgs));
}
sw.Write("(");
int nIns = WriteFormals("", m.Ins, sw);
if (targetReturnTypeReplacement == null)
{
WriteFormals(nIns == 0 ? "" : ", ", m.Outs, sw);
}
sw.Write(")");
wr.AppendHeader(sw.ToString());
if (hasDllImportAttribute)
{
wr.DropBody();
wr.SetBraceStyle(BlockTargetWriter.BraceStyle.Nothing, BlockTargetWriter.BraceStyle.Newline);
}
return(wr);
}
protected override BlockTargetWriter CreateModule(string moduleName, TargetWriter wr)
{
var w = wr.NewBigBlock(string.Format("let {0} = (function()", moduleName), ")(); // end of module " + moduleName);
w.Indent();
w.WriteLine("let $module = {};");
w.BodySuffix = string.Format("{0}return $module;{1}", w.IndentString, w.NewLine);
return(w);
}
public static void Save(Pack pack, TargetWriter target)
{
var schema = pack.Schema ?? new Schema();
schema.SetValue("pack", pack.Id);
schema.SetValues("deps", pack.Deps.Select(x => x.Id));
schema.SetValues("dist", pack.Dist);
schema.Save(target);
}
private void AddPrimaryKey(TargetWriter writer)
{
if (writer.Source is NewReader newReader)
{
writer.PrimaryKey = newReader.PrimaryKey;
newReader.PrimaryKey = null;
writer.ForeignJoins.AddRange(newReader.Joins);
newReader.Joins.Clear();
}
}
/// <inheritdoc />
public override void Write([NotNull] char[] buffer, int index, int count)
{
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (count < 0 || (buffer.Length - index < count))
{
throw new ArgumentOutOfRangeException(nameof(count));
}
TargetWriter.Write(buffer, index, count);
}
public static void Save(Conf conf, TargetWriter target)
{
var schema = conf.Schema ?? new Schema();
foreach (var entry in conf.Entries)
{
var key = entry.Key;
var values = entry.Value;
schema.SetValues(key, values);
}
schema.Save(target);
}
protected override void EmitArraySelect(List <string> indices, TargetWriter wr)
{
if (indices.Count == 1)
{
wr.Write("[{0}]", indices[0]);
}
else
{
wr.Write(".elmts");
foreach (var index in indices)
{
wr.Write("[{0}]", index);
}
}
}
protected override void EmitReturn(List <Formal> outParams, TargetWriter wr)
{
wr.Indent();
if (outParams.Count == 0)
{
wr.WriteLine("return;");
}
else if (outParams.Count == 1)
{
wr.WriteLine("return {0};", IdName(outParams[0]));
}
else
{
wr.WriteLine("return [{0}];", Util.Comma(outParams, IdName));
}
}
protected override void EmitHeader(Program program, TargetWriter wr)
{
wr.WriteLine("// Dafny program {0} compiled into JavaScript", program.Name);
wr.WriteLine(@"
let _dafny = (function() {
let $module = {};
$module.Tuple = class Tuple extends Array {
constructor(...elems) {
super(...elems);
}
toString() {
return ""("" + this.join("", "") + "")"";
}
}
$module.Seq = class Seq extends Array {
constructor(...elems) {
super(...elems);
}
toString() {
return ""["" + this.join("", "") + ""]"";
}
}
$module.areEqual = function() {
return false; // TODO
}
$module.seqUpdate = function(s, i, v) {
let t = s.slice();
t[i] = v;
return t;
}
$module.newArray = function(initValue, ...dims) {
return { dims: dims, elmts: buildArray(initValue, ...dims) };
}
return $module;
function buildArray(initValue, ...dims) {
if (dims.length === 0) {
return initValue;
} else {
let a = Array(dims[0]);
let b = Array.from(a, (x) => buildArray(initValue, ...dims.slice(1)));
return b;
}
}
})();
");
}
protected override BlockTargetWriter CreateClass(TargetWriter wr, ClassDecl cl)
{
var w = wr.NewBlock("public partial class @{0}", cl.CompileName);
if (cl.TypeArgs.Count != 0)
{
w.AppendHeader("<{0}>", TypeParameters(cl.TypeArgs));
}
string sep = " : ";
foreach (var trait in cl.TraitsTyp)
{
w.AppendHeader("{0}{1}", sep, TypeName(trait, w, cl.tok));
sep = ", ";
}
return(w);
}
protected override void EmitHeader(Program program, TargetWriter wr)
{
wr.WriteLine("// Dafny program {0} compiled into C#", program.Name);
wr.WriteLine("// To recompile, use 'csc' with: /r:System.Numerics.dll");
wr.WriteLine("// and choosing /target:exe or /target:library");
wr.WriteLine("// You might also want to include compiler switches like:");
wr.WriteLine("// /debug /nowarn:0164 /nowarn:0219 /nowarn:1717 /nowarn:0162 /nowarn:0168");
wr.WriteLine();
wr.WriteLine("using System;");
wr.WriteLine("using System.Numerics;");
EmitDafnySourceAttribute(program, wr);
if (!DafnyOptions.O.UseRuntimeLib)
{
ReadRuntimeSystem(wr);
}
}
public void Serialize(SchemaFile file, TargetWriter target)
{
using (target)
{
var writer = target.GetWriter();
var items = file.GetItems();
Func <int, bool> indentFunction = index => false;
for (var i = 0; i < items.Length; i++)
{
var item = items[i];
var indent = indentFunction.Invoke(i);
if (indent)
{
writer.Write(" ");
}
if (item.IsComment)
{
writer.Write("#");
writer.WriteLine(item.Text);
}
else if (item.IsValue)
{
writer.WriteLine((item.Text == null) ? "(null)" : item.Text);
}
else
{
writer.WriteLine(item.Text);
}
if (item.IsProperty)
{
var values = file.GetValues(item.Text);
var lastItem = values.LastOrDefault() ?? item;
var lastIndex = file.IndexOf(lastItem);
indentFunction = index => index <= lastIndex;
}
}
writer.Flush();
}
}
/// <inheritdoc />
public override Task WriteAsync(char[] buffer, int index, int count)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (count < 0 || (buffer.Length - index < count))
{
throw new ArgumentOutOfRangeException(nameof(count));
}
return(TargetWriter.WriteAsync(buffer, index, count));
}
private void AddChildKey(ListResult result, TargetWriter writer)
{
IList <IReference> references = this.GetChildReferences(writer.Source.Metadata).ToList();
KeyReader childKey = references.Select(r => this.FindChildKey(writer.Source, r)).NotNull().FirstOrDefault();
if (childKey != null && this.IsValidJoinKey(childKey, throwOnInvalid: true))
{
this.InitializeKey(childKey);
}
if (childKey == null && this.RequiresReference(writer.Source.Metadata))
{
throw BindingException.NoReferenceFound(writer.Source.Metadata);
}
writer.List = this.GetListTarget(result, writer.Source.Metadata, childKey);
writer.Join = this.GetJoinTarget(result, childKey);
}
/// <inheritdoc />
public override void Write(char[] buffer, int index, int count)
{
if (buffer == null)
{
throw new ArgumentNullException(nameof(buffer));
}
if (index < 0)
{
throw new ArgumentOutOfRangeException(nameof(index));
}
if (count < 0 || (index + count > buffer.Length))
{
throw new ArgumentOutOfRangeException(nameof(count));
}
TargetWriter.Write(buffer, index, count);
}
public static void Save(Credentials credentials, TargetWriter target)
{
using (target)
{
var writer = target.GetWriter();
foreach (var entry in credentials)
{
var uri = entry.Key;
var token = entry.Value;
var encryptedData = token.GetEncriptedData();
var line = uri + ' ' + encryptedData;
writer.WriteLine(line);
}
writer.Flush();
}
}
private void AddWriters(ListResult result, NodeTree nodeTree)
{
foreach (Node node in nodeTree.Items.Where(n => this.IsWriterList(n.Metadata)).OrderByDescending(n => n.Depth))
{
TargetWriter writer = new TargetWriter()
{
Source = this.CreateReader(result, node),
};
this.AddPrimaryKey(writer);
this.AddChildKey(result, writer);
result.Writers.Add(writer);
}
TargetWriter resultWriter = result.Writers.FirstOrDefault(w => w.Source.Metadata.Relation.Depth == 0);
TargetWriter resultItemWriter = result.Writers.FirstOrDefault(w => w.Source.Metadata.Relation.Depth == 1);
if (resultWriter != null && resultItemWriter != null)
{
result.Writers.Remove(resultWriter);
}
}
/// <inheritdoc />
public override void Write(char value)
{
TargetWriter.Write(value);
}
/// <inheritdoc />
public override Task WriteLineAsync()
{
return(TargetWriter.WriteLineAsync());
}
/// <inheritdoc />
public override Task WriteLineAsync(string value)
{
return(TargetWriter.WriteLineAsync(value));
}
/// <inheritdoc />
public override Task WriteLineAsync(char[] value, int start, int offset)
{
return(TargetWriter.WriteLineAsync(value, start, offset));
}
/// <inheritdoc />
public override void WriteLine(string value)
{
TargetWriter.WriteLine(value);
}
/// <inheritdoc />
public override void WriteLine()
{
TargetWriter.WriteLine();
}
