// FormatMediaType serializes mediatype t and the parameters
// param as a media type conforming to RFC 2045 and RFC 2616.
// The type and parameter names are written in lower-case.
// When any of the arguments result in a standard violation then
// FormatMediaType returns the empty string.
public static @string FormatMediaType(@string t, map <@string, @string> param)
{
strings.Builder b = default;
{
var slash = strings.IndexByte(t, '/');
if (slash == -1L)
{
if (!isToken(t))
{
return("");
}
b.WriteString(strings.ToLower(t));
}
else
{
var major = t[..slash];
private static void concurrentMapWrites()
{
map m = /* TODO: Fix this in ScannerBase_Expression::ExitCompositeLit */ new map <long, long> {
};
var c = make_channel <object>();
go_(() => () =>
{
{
long i__prev1 = i;
for (long i = 0L; i < 10000L; i++)
{
m[5L] = 0L;
runtime.Gosched();
}
i = i__prev1;
}
c.Send(/* TODO: Fix this in ScannerBase_Expression::ExitCompositeLit */ struct {} {});
public objTool(sync.Mutex mu = default, map <@string, ptr <objfile.Disasm> > disasmCache = default)
{
this.mu = mu;
this.disasmCache = disasmCache;
}
public scope(ref ptr <scope> outer = default, map <@string, ptr <object> > objects = default)
{
this.outer = outer;
this.objects = objects;
}
public annotationAnalysisResult(map <ulong, ptr <taskDesc> > tasks = default, map <regionTypeID, slice <regionDesc> > regions = default, slice <ptr <trace.Event> > gcEvents = default)
{
this.tasks = tasks;
this.regions = regions;
this.gcEvents = gcEvents;
}
public ipv6ZoneCache(sync.RWMutex RWMutex = default, time.Time lastFetched = default, map <@string, long> toIndex = default, map <long, @string> toName = default)
{
this.m_RWMutexRef = new ptr <sync.RWMutex>(RWMutex);
this.lastFetched = lastFetched;
this.toIndex = toIndex;
this.toName = toName;
}
public Package(@string PackageName = default, @string PackagePath = default, long PtrSize = default, long IntSize = default, slice <@string> GccOptions = default, bool GccIsClang = default, map <@string, slice <@string> > CgoFlags = default, map <@string, bool> Written = default, map <@string, ref Name> Name = default, slice <ref ExpFunc> ExpFunc = default, slice <ast.Decl> Decl = default, slice <@string> GoFiles = default, slice <@string> GccFiles = default, @string Preamble = default)
public traceParams(trace.ParseResult parsed = default, traceviewMode mode = default, long startTime = default, long endTime = default, ulong maing = default, map <ulong, bool> gs = default, slice <ptr <taskDesc> > tasks = default)
{
this.parsed = parsed;
this.mode = mode;
this.startTime = startTime;
this.endTime = endTime;
this.maing = maing;
this.gs = gs;
this.tasks = tasks;
}
public TypeConfig(map <@string, ptr <Type> > Type = default, map <@string, @string> Var = default, map <@string, @string> Func = default, map <@string, @string> External = default)
{
this.Type = Type;
this.Var = Var;
this.Func = Func;
this.External = External;
}
// pprofMatchingGoroutines parses the goroutine type id string (i.e. pc)
// and returns the ids of goroutines of the matching type and its interval.
// If the id string is empty, returns nil without an error.
private static (map <ulong, slice <interval> >, error) pprofMatchingGoroutines(@string id, slice <ptr <trace.Event> > events)
{
map <ulong, slice <interval> > _p0 = default;
error _p0 = default !;
public unusedInspector(ref ptr <scope> scope = default, map <token.Pos, bool> unused = default, ref ptr <object> defining = default)
{
this.scope = scope;
this.unused = unused;
this.defining = defining;
}
public nssConf(error err = default, map <@string, slice <nssSource> > sources = default)
{
this.err = err;
this.sources = sources;
}
public frameNode(long id = default, map <ulong, frameNode> children = default)
{
this.id = id;
this.children = children;
}
public M(map <long, long> value) => m_value = value;
private static void Main()
{
flag.Usage = usage;
flag.Parse();
sort.Sort(byDate(fixes));
if (allowedRewrites != "".val)
{
allowed = make_map <@string, bool>();
{
var f__prev1 = f;
foreach (var(_, __f) in strings.Split(allowedRewrites.val, ","))
{
f = __f;
allowed[f] = true;
}
f = f__prev1;
}
}
if (forceRewrites != "".val)
{
force = make_map <@string, bool>();
{
var f__prev1 = f;
foreach (var(_, __f) in strings.Split(forceRewrites.val, ","))
{
f = __f;
force[f] = true;
}
f = f__prev1;
}
}
if (flag.NArg() == 0L)
{
{
var err__prev2 = err;
var err = processFile("standard input", true);
if (err != null)
{
report(err);
}
err = err__prev2;
}
os.Exit(exitCode);
}
for (long i = 0L; i < flag.NArg(); i++)
{
var path = flag.Arg(i);
{
var err__prev1 = err;
var(dir, err) = os.Stat(path);
if (err != null)
{
report(err);
}
else if (dir.IsDir())
{
walkDir(path);
}
else
{
var err__prev1 = err;
err = processFile(path, false);
if (err != null)
{
report(err);
}
err = err__prev1;
}
err = err__prev1;
}
}
os.Exit(exitCode);
}
public B(common common = default, @string importPath = default, ref ptr <benchContext> context = default, long N = default, long previousN = default, time.Duration previousDuration = default, Action <ptr <B> > benchFunc = default, benchTimeFlag benchTime = default, long bytes = default, bool missingBytes = default, bool timerOn = default, bool showAllocResult = default, BenchmarkResult result = default, long parallelism = default, ulong startAllocs = default, ulong startBytes = default, ulong netAllocs = default, ulong netBytes = default, map <@string, double> extra = default)
{
this.common = common;
this.importPath = importPath;
this.context = context;
this.N = N;
this.previousN = previousN;
this.previousDuration = previousDuration;
this.benchFunc = benchFunc;
this.benchTime = benchTime;
this.bytes = bytes;
this.missingBytes = missingBytes;
this.timerOn = timerOn;
this.showAllocResult = showAllocResult;
this.result = result;
this.parallelism = parallelism;
this.startAllocs = startAllocs;
this.startBytes = startBytes;
this.netAllocs = netAllocs;
this.netBytes = netBytes;
this.extra = extra;
}
public BenchmarkResult(long N = default, time.Duration T = default, long Bytes = default, ulong MemAllocs = default, ulong MemBytes = default, map <@string, double> Extra = default)
{
this.N = N;
this.T = T;
this.Bytes = Bytes;
this.MemAllocs = MemAllocs;
this.MemBytes = MemBytes;
this.Extra = Extra;
}
public File(ref ptr <ast.File> AST = default, slice <ptr <ast.CommentGroup> > Comments = default, @string Package = default, @string Preamble = default, slice <ptr <Ref> > Ref = default, slice <ptr <Call> > Calls = default, slice <ptr <ExpFunc> > ExpFunc = default, map <@string, ptr <Name> > Name = default, map <ptr <Name>, token.Pos> NamePos = default, ref ptr <edit.Buffer> Edit = default)
{
this.AST = AST;
this.Comments = Comments;
this.Package = Package;
this.Preamble = Preamble;
this.Ref = Ref;
this.Calls = Calls;
this.ExpFunc = ExpFunc;
this.Name = Name;
this.NamePos = NamePos;
this.Edit = Edit;
}
public Package(@string PackageName = default, @string PackagePath = default, long PtrSize = default, long IntSize = default, slice <@string> GccOptions = default, bool GccIsClang = default, map <@string, slice <@string> > CgoFlags = default, map <@string, bool> Written = default, map <@string, ptr <Name> > Name = default, slice <ptr <ExpFunc> > ExpFunc = default, slice <ast.Decl> Decl = default, slice <@string> GoFiles = default, slice <@string> GccFiles = default, @string Preamble = default, map <@string, bool> typedefs = default, slice <typedefInfo> typedefList = default)
{
this.PackageName = PackageName;
this.PackagePath = PackagePath;
this.PtrSize = PtrSize;
this.IntSize = IntSize;
this.GccOptions = GccOptions;
this.GccIsClang = GccIsClang;
this.CgoFlags = CgoFlags;
this.Written = Written;
this.Name = Name;
this.ExpFunc = ExpFunc;
this.Decl = Decl;
this.GoFiles = GoFiles;
this.GccFiles = GccFiles;
this.Preamble = Preamble;
this.typedefs = typedefs;
this.typedefList = typedefList;
}
public FlagSet(Action Usage = default, @string name = default, bool parsed = default, map <@string, ptr <Flag> > actual = default, map <@string, ptr <Flag> > formal = default, slice <@string> args = default, ErrorHandling errorHandling = default, io.Writer output = default)
{
this.Usage = Usage;
this.name = name;
this.parsed = parsed;
this.actual = actual;
this.formal = formal;
this.args = args;
this.errorHandling = errorHandling;
this.output = output;
}
public Walker(ref ptr <build.Context> context = default, @string root = default, slice <@string> scope = default, ref ptr <types.Package> current = default, map <@string, bool> features = default, map <@string, ptr <types.Package> > imported = default, slice <@string> stdPackages = default, map <@string, map <@string, @string> > importMap = default, map <@string, @string> importDir = default)
{
this.context = context;
this.root = root;
this.scope = scope;
this.current = current;
this.features = features;
this.imported = imported;
this.stdPackages = stdPackages;
this.importMap = importMap;
this.importDir = importDir;
}
public typeConv(map <dwarf.Type, ref Type> m = default, map <dwarf.Type, slice <ref Type> > ptrs = default, slice <dwarf.Type> ptrKeys = default, map <@string, bool> getTypeIDs = default, ast.Expr @bool = default, ast.Expr @byte = default, ast.Expr int8 = default, ast.Expr int16 = default, ast.Expr int32 = default, ast.Expr int64 = default, ast.Expr uint8 = default, ast.Expr uint16 = default, ast.Expr uint32 = default, ast.Expr uint64 = default, ast.Expr uintptr = default, ast.Expr float32 = default, ast.Expr float64 = default, ast.Expr complex64 = default, ast.Expr complex128 = default, ast.Expr @void = default, ast.Expr @string = default, ast.Expr goVoid = default, ast.Expr goVoidPtr = default, long ptrSize = default, long intSize = default)
public Package(io.Writer writer = default, @string name = default, @string userPath = default, ref ptr <ast.Package> pkg = default, ref ptr <ast.File> file = default, ref ptr <doc.Package> doc = default, ref ptr <build.Package> build = default, map <ptr <doc.Value>, bool> typedValue = default, map <ptr <doc.Func>, bool> constructor = default, ref ptr <token.FileSet> fs = default, pkgBuffer buf = default)
{
this.writer = writer;
this.name = name;
this.userPath = userPath;
this.pkg = pkg;
this.file = file;
this.doc = doc;
this.build = build;
this.typedValue = typedValue;
this.constructor = constructor;
this.fs = fs;
this.buf = buf;
}
public mmapper(sync.Mutex Mutex = default, map <ptr <byte>, slice <byte> > active = default, Func <System.UIntPtr, System.UIntPtr, long, long, long, long, (System.UIntPtr, error)> mmap = default, Func <System.UIntPtr, System.UIntPtr, error> munmap = default)
public listImports(slice <@string> stdPackages = default, map <@string, @string> importDir = default, map <@string, map <@string, @string> > importMap = default)
{
this.stdPackages = stdPackages;
this.importDir = importDir;
this.importMap = importMap;
}
public M(map <@string, long> value) => m_value = value;
public moduledata(slice <byte> pclntable = default, slice <functab> ftab = default, slice <uint> filetab = default, System.UIntPtr findfunctab = default, System.UIntPtr minpc = default, System.UIntPtr maxpc = default, System.UIntPtr text = default, System.UIntPtr etext = default, System.UIntPtr noptrdata = default, System.UIntPtr enoptrdata = default, System.UIntPtr data = default, System.UIntPtr edata = default, System.UIntPtr bss = default, System.UIntPtr ebss = default, System.UIntPtr noptrbss = default, System.UIntPtr enoptrbss = default, System.UIntPtr end = default, System.UIntPtr gcdata = default, System.UIntPtr gcbss = default, System.UIntPtr types = default, System.UIntPtr etypes = default, slice <textsect> textsectmap = default, slice <int> typelinks = default, slice <ptr <itab> > itablinks = default, slice <ptabEntry> ptab = default, @string pluginpath = default, slice <modulehash> pkghashes = default, @string modulename = default, slice <modulehash> modulehashes = default, byte hasmain = default, bitvector gcdatamask = default, bitvector gcbssmask = default, map <typeOff, ptr <_type> > typemap = default, bool bad = default, ref ptr <moduledata> next = default)
{
this.pclntable = pclntable;
this.ftab = ftab;
this.filetab = filetab;
this.findfunctab = findfunctab;
this.minpc = minpc;
this.maxpc = maxpc;
this.text = text;
this.etext = etext;
this.noptrdata = noptrdata;
this.enoptrdata = enoptrdata;
this.data = data;
this.edata = edata;
this.bss = bss;
this.ebss = ebss;
this.noptrbss = noptrbss;
this.enoptrbss = enoptrbss;
this.end = end;
this.gcdata = gcdata;
this.gcbss = gcbss;
this.types = types;
this.etypes = etypes;
this.textsectmap = textsectmap;
this.typelinks = typelinks;
this.itablinks = itablinks;
this.ptab = ptab;
this.pluginpath = pluginpath;
this.pkghashes = pkghashes;
this.modulename = modulename;
this.modulehashes = modulehashes;
this.hasmain = hasmain;
this.gcdatamask = gcdatamask;
this.gcbssmask = gcbssmask;
this.typemap = typemap;
this.bad = bad;
this.next = next;
}
public allTasks(map <ulong, ptr <taskDesc> > value) => m_value = value;
public typeConv(map <@string, ptr <Type> > m = default, map <@string, slice <ptr <Type> > > ptrs = default, slice <dwarf.Type> ptrKeys = default, map <@string, bool> getTypeIDs = default, ast.Expr @bool = default, ast.Expr @byte = default, ast.Expr int8 = default, ast.Expr int16 = default, ast.Expr int32 = default, ast.Expr int64 = default, ast.Expr uint8 = default, ast.Expr uint16 = default, ast.Expr uint32 = default, ast.Expr uint64 = default, ast.Expr uintptr = default, ast.Expr float32 = default, ast.Expr float64 = default, ast.Expr complex64 = default, ast.Expr complex128 = default, ast.Expr @void = default, ast.Expr @string = default, ast.Expr goVoid = default, ast.Expr goVoidPtr = default, long ptrSize = default, long intSize = default)
{
this.m = m;
this.ptrs = ptrs;
this.ptrKeys = ptrKeys;
this.getTypeIDs = getTypeIDs;
this.@bool = @bool;
this.@byte = @byte;
this.int8 = int8;
this.int16 = int16;
this.int32 = int32;
this.int64 = int64;
this.uint8 = uint8;
this.uint16 = uint16;
this.uint32 = uint32;
this.uint64 = uint64;
this.uintptr = uintptr;
this.float32 = float32;
this.float64 = float64;
this.complex64 = complex64;
this.complex128 = complex128;
this.@void = @void;
this.@string = @string;
this.goVoid = goVoid;
this.goVoidPtr = goVoidPtr;
this.ptrSize = ptrSize;
this.intSize = intSize;
}
public Type(long Size = default, long Align = default, ref ptr <TypeRepr> C = default, ast.Expr Go = default, map <@string, long> EnumValues = default, @string Typedef = default, bool BadPointer = default)
{
this.Size = Size;
this.Align = Align;
this.C = C;
this.Go = Go;
this.EnumValues = EnumValues;
this.Typedef = Typedef;
this.BadPointer = BadPointer;
}
