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