public Index <BitMaskInfo> Emit(FS.FilePath dst)
{
var flow = Wf.EmittingTable <BitMaskInfo>(dst);
var masks = Load();
Emit(masks.View, dst);
return(masks);
}
public EmitEnumsStep(IWfRuntime wf, WfHost host, ClrAssemblyAdapter src)
{
Wf = wf;
Host = host;
Source = src;
Target = Wf.Db().Table(ClrEnumRecord.TableId, Source.Part);
Records = default;
}
public Index <ApiCatalogEntry> RebaseMembers(ApiMembers src, FS.FilePath dst)
{
var flow = Wf.EmittingTable <ApiCatalogEntry>(dst);
var records = rebase(src.BaseAddress, src.View);
var count = Tables.emit <ApiCatalogEntry>(records.View, dst);
Wf.EmittedTable <ApiCatalogEntry>(flow, count, dst);
return(records);
}
public ReadOnlySpan <SymLiteral> EmitApiClasses(FS.FilePath dst)
{
var flow = Wf.EmittingTable <SymLiteral>(dst);
var literals = Query.ApiClassLiterals();
var count = Tables.emit(literals, dst);
Wf.EmittedTable(flow, count);
return(literals);
}
public uint Load(FS.FilePath src, List <ApiExtractBlock> dst)
{
var lines = src.ReadLines().View;
var count = lines.Length;
var flow = Wf.Running(string.Format("Reading extracts from {0}", src.ToUri()));
var counter = 0u;
for (var i = 1u; i < count; i++)
{
ref readonly var line = ref skip(lines, i);
public ExecToken Emit(ReadOnlySpan <BitMaskInfo> src, FS.FilePath dst)
{
var flow = Wf.EmittingTable <BitMaskInfo>(dst);
var count = src.Length;
using var writer = dst.Writer();
writer.WriteLine(Formatter.HeaderText);
for (var i = 0u; i < count; i++)
{
writer.WriteLine(Formatter.Format(skip(src, i)));
}
return(Wf.EmittedTable <BitMaskInfo>(flow, count, dst));
}
public Index <ClrEnumRecord> EmitEnumRecords(ClrAssemblyAdapter src, FS.FilePath dst)
{
var records = Enums.records(src);
if (records.Length != 0)
{
var t = default(ClrEnumRecord);
var formatter = Tables.formatter <ClrEnumRecord>(32);
var flow = Wf.EmittingTable <ClrEnumRecord>(dst);
var counter = 0u;
Execute(records, ref counter, formatter, dst);
Wf.EmittedTable(flow, counter);
}
return(records);
}
static EnumDataset <E, T> EmitDataset <E, T>(FS.FilePath dst)
where E : unmanaged, Enum
where T : unmanaged
{
using var writer = dst.Writer();
writer.WriteLine(header <F>());
var dataset = EnumDatasets.create <E, T>();
for (var i = 0; i < dataset.EntryCount; i++)
{
writer.WriteLine(EnumDatasets.format(dataset[i]));
}
return(dataset);
}
public static EnumDataset <E, T> emit <E, T>(LiteralEmissionKind kind, FS.FilePath dst)
where E : unmanaged, Enum
where T : unmanaged
{
switch (kind)
{
case LiteralEmissionKind.EnumDataset:
return(EmitDataset <E, T>(dst));
case LiteralEmissionKind.EnumInfoset:
return(EmitInfoset <E, T>(dst));
default:
throw no <LiteralEmissionKind>();
}
}
public void Emit(Type src, FS.FilePath dst)
{
var flow = Wf.EmittingFile(dst);
using var writer = dst.Writer();
var patterns = Sources(src);
var view = patterns.View;
var count = view.Length;
for (var i = 0; i < count; i++)
{
writer.WriteLine(skip(view, i).Format());
}
Wf.EmittedFile(flow, count);
}
static EnumDataset <E, T> EmitInfoset <E, T>(FS.FilePath dst)
where E : unmanaged, Enum
where T : unmanaged
=> emit(@readonly(Enums.describe <E, T>()), dst);
public ApiCodeset(FS.FilePath location, Index <ApiCodeBlock> rows)
{
Location = location;
Blocks = rows;
}
public static ApiCodeset create(FS.FilePath location, Index <ApiCodeBlock> blocks) => new ApiCodeset(location, blocks);
public FileSplitSpec(FS.FilePath src, Count maxlines, FS.FolderPath dst)
{
SourceFile = src;
MaxLineCount = maxlines;
TargetFolder = dst;
}
public Index <ApiCodeBlock> Read(FS.FilePath src) => Wf.ApiHex().ReadBlocks(src).Where(x => x.IsNonEmpty);
void IEnumLiteralEmitter.Emit <E, T>(LiteralEmissionKind kind, FS.FilePath dst) => emit <E, T>(kind, dst);
static EnumDataset <E, T> emit <E, T>(ReadOnlySpan <EnumLiteralInfo <E, T> > src, FS.FilePath dst)
where E : unmanaged, Enum
where T : unmanaged
{
using var writer = dst.Writer();
writer.WriteLine(header <F>());
var dataset = EnumDatasets.create <E, T>();
for (var i = 0; i < src.Length; i++)
{
writer.WriteLine(EnumDatasets.format(src[i]));
}
return(dataset);
}
