// ----- 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(); }