public static void DiffTest(ptr <testing.T> _addr_t, diff.ComputeEdits compute)
{
ref testing.T t = ref _addr_t.val;
// Shortcircuit finds situations where branch directions
// are always correlated and rewrites the CFG to take
// advantage of that fact.
// This optimization is useful for compiling && and || expressions.
private static void shortcircuit(ptr <Func> _addr_f)
{
ref Func f = ref _addr_f.val;
public Iovec(ref ptr <byte> Base = default, uint Len = default)
{
this.Base = Base;
this.Len = Len;
}
public arrayType(CommonType CommonType = default, typeId Elem = default, long Len = default)
{
this.m_CommonTypeRef = new ptr <CommonType>(CommonType);
this.Elem = Elem;
this.Len = Len;
}
// SetMaxStringLength sets the maximum size of a HeaderField name or
// value string. If a string exceeds this length (even after any
// decompression), Write will return ErrStringLength.
// A value of 0 means unlimited and is the default from NewDecoder.
private static void SetMaxStringLength(this ptr <Decoder> _addr_d, long n)
{
ref Decoder d = ref _addr_d.val;
private static token.Pos pos(this ptr <fakeFileSet> _addr_s, @string file, long line, long column)
{
ref fakeFileSet s = ref _addr_s.val;
public Response(@string ServiceMethod = default, ulong Seq = default, @string Error = default, ref ptr <Response> next = default)
{
this.ServiceMethod = ServiceMethod;
this.Seq = Seq;
this.Error = Error;
this.next = next;
}
// TODO(gri) consider making this part of the parser code
// checkBranches checks correct use of labels and branch
// statements (break, continue, goto) in a function body.
// It catches:
// - misplaced breaks and continues
// - bad labeled breaks and continues
// - invalid, unused, duplicate, and missing labels
// - gotos jumping over variable declarations and into blocks
private static void checkBranches(ptr <BlockStmt> _addr_body, ErrorHandler errh)
{
ref BlockStmt body = ref _addr_body.val;
// Accept4 wraps syscall.Accept4. private static (long, syscall.Sockaddr, error) Accept4(this ptr <Switch> _addr_sw, long s, long flags) => func((defer, _, __) =>
public PtraceIoDesc(int Op = default, ref ptr <byte> Offs = default, ref ptr <byte> Addr = default, ulong Len = default)
{
this.Op = Op;
this.Offs = Offs;
this.Addr = Addr;
this.Len = Len;
}
public Progs(ref ptr <obj.Prog> Text = default, ref ptr <obj.Prog> next = default, long pc = default, src.XPos pos = default, ref ptr <Node> curfn = default, slice <obj.Prog> progcache = default, long cacheidx = default)
{
this.Text = Text;
this.next = next;
this.pc = pc;
this.pos = pos;
this.curfn = curfn;
this.progcache = progcache;
this.cacheidx = cacheidx;
}
public jsonPackage(@string ImportPath = default, @string Dir = default, @string Name = default, @string Export = default, slice <@string> GoFiles = default, slice <@string> CompiledGoFiles = default, slice <@string> CFiles = default, slice <@string> CgoFiles = default, slice <@string> CXXFiles = default, slice <@string> MFiles = default, slice <@string> HFiles = default, slice <@string> FFiles = default, slice <@string> SFiles = default, slice <@string> SwigFiles = default, slice <@string> SwigCXXFiles = default, slice <@string> SysoFiles = default, slice <@string> Imports = default, map <@string, @string> ImportMap = default, slice <@string> Deps = default, ref ptr <Module> Module = default, slice <@string> TestGoFiles = default, slice <@string> TestImports = default, slice <@string> XTestGoFiles = default, slice <@string> XTestImports = default, @string ForTest = default, bool DepOnly = default, ref ptr <jsonPackageError> Error = default)
{
this.ImportPath = ImportPath;
this.Dir = Dir;
this.Name = Name;
this.Export = Export;
this.GoFiles = GoFiles;
this.CompiledGoFiles = CompiledGoFiles;
this.CFiles = CFiles;
this.CgoFiles = CgoFiles;
this.CXXFiles = CXXFiles;
this.MFiles = MFiles;
this.HFiles = HFiles;
this.FFiles = FFiles;
this.SFiles = SFiles;
this.SwigFiles = SwigFiles;
this.SwigCXXFiles = SwigCXXFiles;
this.SysoFiles = SysoFiles;
this.Imports = Imports;
this.ImportMap = ImportMap;
this.Deps = Deps;
this.Module = Module;
this.TestGoFiles = TestGoFiles;
this.TestImports = TestImports;
this.XTestGoFiles = XTestGoFiles;
this.XTestImports = XTestImports;
this.ForTest = ForTest;
this.DepOnly = DepOnly;
this.Error = Error;
}
public Config(ref ptr <token.FileSet> Fset = default, parser.Mode ParserMode = default, types.Config TypeChecker = default, Func <@string, bool> TypeCheckFuncBodies = default, ref ptr <build.Context> Build = default, @string Cwd = default, Func <@string, @string> DisplayPath = default, bool AllowErrors = default, slice <PkgSpec> CreatePkgs = default, map <@string, bool> ImportPkgs = default, Func <ptr <build.Context>, @string, @string, build.ImportMode, (ptr <build.Package>, error)> FindPackage = default, Action <ptr <PackageInfo>, slice <ptr <ast.File> > > AfterTypeCheck = default)
// Callee returns the named target of a function call, if any:
// a function, method, builtin, or variable.
public static types.Object Callee(ptr <types.Info> _addr_info, ptr <ast.CallExpr> _addr_call)
{
ref types.Info info = ref _addr_info.val;
private static readonly ulong funcValueOffset = (ulong)0x1000UL; // TODO(neelance): make function addresses play nice with heap addresses
// TODO(neelance): make function addresses play nice with heap addresses
private static void gentext(ptr <ld.Link> _addr_ctxt)
{
ref ld.Link ctxt = ref _addr_ctxt.val;
public label(ref ptr <block> parent = default, ref ptr <LabeledStmt> lstmt = default, bool used = default)
{
this.parent = parent;
this.lstmt = lstmt;
this.used = used;
}
public serverHandshakeState(ref ptr <Conn> c = default, ref ptr <clientHelloMsg> clientHello = default, ref ptr <serverHelloMsg> hello = default, ref ptr <cipherSuite> suite = default, bool ecdheOk = default, bool ecSignOk = default, bool rsaDecryptOk = default, bool rsaSignOk = default, ref ptr <sessionState> sessionState = default, finishedHash finishedHash = default, slice <byte> masterSecret = default, ref ptr <Certificate> cert = default)
{
this.c = c;
this.clientHello = clientHello;
this.hello = hello;
this.suite = suite;
this.ecdheOk = ecdheOk;
this.ecSignOk = ecSignOk;
this.rsaDecryptOk = rsaDecryptOk;
this.rsaSignOk = rsaSignOk;
this.sessionState = sessionState;
this.finishedHash = finishedHash;
this.masterSecret = masterSecret;
this.cert = cert;
}
{ // for linkname
//go:linkname sysctl syscall.sysctl
private static error sysctl(slice <int> mib, ptr <byte> old, ptr <System.UIntPtr> oldlen, ptr <byte> @new, System.UIntPtr newlen)
;
public unresolvedSymKey(ref ptr <sym.Symbol> from = default, ref ptr <sym.Symbol> to = default)
{
this.from = from;
this.to = to;
}
public commaListFlag(ref ptr <slice <@string> > vals = default)
{
this.vals = vals;
}
private static @string String(this ptr <MethodSet> _addr_s)
{
ref MethodSet s = ref _addr_s.val;
public Pass(ref ptr <Analyzer> Analyzer = default, ref ptr <token.FileSet> Fset = default, slice <ptr <ast.File> > Files = default, slice <@string> OtherFiles = default, ref ptr <types.Package> Pkg = default, ref ptr <types.Info> TypesInfo = default, types.Sizes TypesSizes = default, Action <Diagnostic> Report = default, Func <types.Object, Fact, bool> ImportObjectFact = default, Func <ptr <types.Package>, Fact, bool> ImportPackageFact = default, Action <types.Object, Fact> ExportObjectFact = default, Action <Fact> ExportPackageFact = default, Func <slice <PackageFact> > AllPackageFacts = default, Func <slice <ObjectFact> > AllObjectFacts = default, slice <types.Error> typeErrors = default)
{
this.Analyzer = Analyzer;
this.Fset = Fset;
this.Files = Files;
this.OtherFiles = OtherFiles;
this.Pkg = Pkg;
this.TypesInfo = TypesInfo;
this.TypesSizes = TypesSizes;
this.Report = Report;
this.ImportObjectFact = ImportObjectFact;
this.ImportPackageFact = ImportPackageFact;
this.ExportObjectFact = ExportObjectFact;
this.ExportPackageFact = ExportPackageFact;
this.AllPackageFacts = AllPackageFacts;
this.AllObjectFacts = AllObjectFacts;
this.typeErrors = typeErrors;
}
ref buffer b = ref heap(out ptr <buffer> _addr_b);
public arrayType(NilType _)
{
this.m_CommonTypeRef = new ptr <CommonType>(new CommonType(nil));
this.Elem = default;
this.Len = default;
}
// SendFile wraps the sendfile system call.
// SendFile wraps the sendfile system call.
public static (long, error) SendFile(ptr <FD> _addr_dstFD, long src, long remain) => func((defer, _, __) =>
public importInfo(@string path = default, ref ptr <PackageInfo> info = default, channel <object> complete = default)
{
this.path = path;
this.info = info;
this.complete = complete;
}
public __Siginfo(int Signo = default, int Errno = default, int Code = default, int Pid = default, uint Uid = default, int Status = default, ref ptr <byte> Addr = default, array <byte> Value = default, array <byte> _ = default)
{
this.Signo = Signo;
this.Errno = Errno;
this.Code = Code;
this.Pid = Pid;
this.Uid = Uid;
this.Status = Status;
this.Addr = Addr;
this.Value = Value;
this._ = _;
}
public iimporterAndOffset(ref ptr <iimporter> p = default, ulong off = default)
{
this.p = p;
this.off = off;
}
public structField(name name = default, ref ptr <rtype> typ = default, System.UIntPtr offsetEmbed = default)
{
this.name = name;
this.typ = typ;
this.offsetEmbed = offsetEmbed;
}
public void PtrMoved(int x, int y, ptr val)
{
string log = "Auxilary pointer moved";
Debug.Log(log);
SendPack(x, y, (int)val, 0);
receiveToBytes();
}
// Preorder visits all the nodes of the files supplied to New in // depth-first order. It calls f(n) for each node n before it visits // n's children. // // The types argument, if non-empty, enables type-based filtering of // events. The function f if is called only for nodes whose type // matches an element of the types slice. private static void Preorder(this ptr <Inspector> _addr_@in, slice <ast.Node> types, Action <ast.Node> f)
