Skip to content

ddkwork/app

Repository files navigation

app document table

  ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  │Path                                                                                                │Func                                                                                                                                                                                              │Method                                                                                                                                              
  ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
  │root (102)                                                                                          │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───ExtractIcon2Png_windows.go (5)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ExtractIcon2Png_windows.go                                                                   │ExtractIcon2Image(filename string) (image image.Image, ok bool)                                                                                                                                   │                                                                                                                                                    
  │   ├───ExtractIcon2Png_windows.go                                                                   │ExtractIconToImageByExt(filename string) (img image.Image, okk bool)                                                                                                                              │                                                                                                                                                    
  │   ├───ExtractIcon2Png_windows.go                                                                   │ExtractIconToImage(filename string) (img image.Image, okk bool)                                                                                                                                   │                                                                                                                                                    
  │   ├───ExtractIcon2Png_windows.go                                                                   │ExtractPrivateExtractIcons(filename string, w, h int32) (img image.Image, okk bool)                                                                                                               │                                                                                                                                                    
  │   └───ExtractIcon2Png_windows.go                                                                   │CreateDIBSection(hdc win32.HDC, pbmi *win32.BITMAPINFO, usage win32.DIB_USAGE, ppvBits *unsafe.Pointer, hSection win32.HANDLE, offset uint32) ( win32.HBITMAP,  win32.WIN32_ERROR)                │                                                                                                                                                    
  ├───app.go (2)                                                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───app.go                                                                                       │Run(title string, layoutCallback func(w *unison.Window))                                                                                                                                          │                                                                                                                                                    
  │   └───app.go                                                                                       │RunWithIco(title string, ico byte, layoutCallback func(w *unison.Window))                                                                                                                         │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\cmd\root.go                                                            │Execute() ( error)                                                                                                                                                                                │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\entity\w32api.go (0)                                          │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\logger\logger.go (4)                                          │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\logger\logger.go                                          │New() ( Logger)                                                                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\logger\logger.go                                          │NewCustom(level string) ( Logger)                                                                                                                                                                 │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\logger\logger.go                                          │NewWithZap(l *zap.Logger) ( Logger)                                                                                                                                                               │                                                                                                                                                    
  │   └───bindgen\astCC\winsdk2json\internal\logger\logger.go                                          │NewForTest() ( Logger,  *observer.ObservedLogs)                                                                                                                                                   │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\parser\api.go (1)                                             │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───bindgen\astCC\winsdk2json\internal\parser\api.go                                             │ParseAPI(apiPrototype string) ( API)                                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\parser\datatype.go (3)                                        │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\parser\datatype.go                                        │InitBuiltInTypes()                                                                                                                                                                                │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\parser\datatype.go                                        │InitCustomTypes(winStructs Struct)                                                                                                                                                                │                                                                                                                                                    
  │   └───bindgen\astCC\winsdk2json\internal\parser\datatype.go                                        │ParseTypedefs(data byte)                                                                                                                                                                          │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\parser\functionptr.go                                         │ParseFunctionPointers(data string) ( string)                                                                                                                                                      │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\parser\minify.go (2)                                          │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\parser\minify.go                                          │MinifyAPIs(apis , customHookHHandlerAPIs string) ( )                                                                                                                                              │                                                                                                                                                    
  │   └───bindgen\astCC\winsdk2json\internal\parser\minify.go                                          │MinifyStructAndUnions(winStructs Struct) ( StructUnionMini)                                                                                                                                       │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\parser\struct.go (2)                                          │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\parser\struct.go                                          │GetAllStructs(data byte) ( string,  Struct)                                                                                                                                                       │                                                                                                                                                    
  │   └───bindgen\astCC\winsdk2json\internal\parser\struct.go                                          │UnionSize(members StructMember, is64 bool) ( uint8)                                                                                                                                               │                                                                                                                                                    
  ├───bindgen\astCC\winsdk2json\internal\utils\utils.go (19)                                           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │WriteStrSliceToFile(filename string, data string) ( int,  error)                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │ReadLines(path string) (lines string, err error)                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │Exists(name string) ( bool)                                                                                                                                                                       │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │StringInSlice(a string, list string) ( bool)                                                                                                                                                      │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │RegSubMatchToMapString(regEx, s string) (paramsMap )                                                                                                                                              │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │StandardizeSpaces(s string) ( string)                                                                                                                                                             │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │SpaceFieldsJoin(s string) ( string)                                                                                                                                                               │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │StripComments(s string) ( string)                                                                                                                                                                 │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │FindClosingBracket(text byte, openPos int) ( int)                                                                                                                                                 │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │FindClosingParenthesis(text byte, openPos int) ( int)                                                                                                                                             │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │FindClosingSemicolon(text byte, pos int) ( int)                                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │KeepOnlyParenthesis(s string) ( string)                                                                                                                                                           │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │IsValid(s string) ( bool)                                                                                                                                                                         │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │ReadAll(filePath string) ( byte,  error)                                                                                                                                                          │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │WalkAllFilesInDir(dir string) ( string,  error)                                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │WriteBytesFile(filename string, r io.Reader) ( int,  error)                                                                                                                                       │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │RemoveAnnotations(apiPrototype string) ( string)                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │Standardize(s string) ( string)                                                                                                                                                                   │                                                                                                                                                    
  │   └───bindgen\astCC\winsdk2json\internal\utils\utils.go                                            │GetDLLName(file, apiname, sdkpath string) ( string,  error)                                                                                                                                       │                                                                                                                                                    
  ├───bindgen\bindlib\bitcast.go (4)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\bindlib\bitcast.go                                                                   │ReadBitcast(p unsafe.Pointer) ( T)                                                                                                                                                                │                                                                                                                                                    
  │   ├───bindgen\bindlib\bitcast.go                                                                   │WriteBitcast(p unsafe.Pointer, value T)                                                                                                                                                           │                                                                                                                                                    
  │   ├───bindgen\bindlib\bitcast.go                                                                   │MarshallSyscall(data T) ( uintptr)                                                                                                                                                                │                                                                                                                                                    
  │   └───bindgen\bindlib\bitcast.go                                                                   │UnmarshallSyscall(ptr uintptr) (res T)                                                                                                                                                            │                                                                                                                                                    
  ├───bindgen\bindlib\lib.go (1)                                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───bindgen\bindlib\lib.go                                                                       │NewLibrary(name string) ( *Library)                                                                                                                                                               │                                                                                                                                                    
  ├───bindgen\bindlib\lib_unix.go (4)                                                                  │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\bindlib\lib_unix.go                                                                  │                                                                                                                                                                                                  │func (solib) Lookup(name string) ( uintptr)                                                                                                         
  │   ├───bindgen\bindlib\lib_unix.go                                                                  │LoadLibrary(name string) ( LoadedLibrary,  error)                                                                                                                                                 │                                                                                                                                                    
  │   ├───bindgen\bindlib\lib_unix.go                                                                  │FindLibrary(name string) ( LoadedLibrary,  error)                                                                                                                                                 │                                                                                                                                                    
  │   └───bindgen\bindlib\lib_unix.go                                                                  │LoadLibraryEmbed(data byte) ( LoadedLibrary,  error)                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\bindlib\lib_win32.go (4)                                                                 │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\bindlib\lib_win32.go                                                                 │                                                                                                                                                                                                  │func (windll) Lookup(name string) ( uintptr)                                                                                                        
  │   ├───bindgen\bindlib\lib_win32.go                                                                 │LoadLibrary(name string) ( LoadedLibrary,  error)                                                                                                                                                 │                                                                                                                                                    
  │   ├───bindgen\bindlib\lib_win32.go                                                                 │FindLibrary(name string) ( LoadedLibrary,  error)                                                                                                                                                 │                                                                                                                                                    
  │   └───bindgen\bindlib\lib_win32.go                                                                 │LoadLibraryEmbed(data byte) ( LoadedLibrary,  error)                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\bindlib\proc.go (27)                                                                     │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall0(proc uintptr) ( uintptr)                                                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall1(proc uintptr, a uintptr) ( uintptr)                                                                                                                                                        │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall2(proc uintptr, a, b uintptr) ( uintptr)                                                                                                                                                     │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall3(proc uintptr, a, b, c uintptr) ( uintptr)                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall4(proc uintptr, a, b, c, d uintptr) ( uintptr)                                                                                                                                               │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall5(proc uintptr, a, b, c, d, e uintptr) ( uintptr)                                                                                                                                            │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall6(proc uintptr, a, b, c, d, e, f uintptr) ( uintptr)                                                                                                                                         │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall7(proc uintptr, a, b, c, d, e, f, g uintptr) ( uintptr)                                                                                                                                      │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall8(proc uintptr, a, b, c, d, e, f, g, h uintptr) ( uintptr)                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall9(proc uintptr, a, b, c, d, e, f, g, h, i uintptr) ( uintptr)                                                                                                                                │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall10(proc uintptr, a, b, c, d, e, f, g, h, i, j uintptr) ( uintptr)                                                                                                                            │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall11(proc uintptr, a, b, c, d, e, f, g, h, i, j, k uintptr) ( uintptr)                                                                                                                         │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │CCall12(proc uintptr, a, b, c, d, e, f, g, h, i, j, k, l uintptr) ( uintptr)                                                                                                                      │                                                                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Addr() ( uintptr)                                                                                                                
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call0() (r1 uintptr)                                                                                                             
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call1(a uintptr) (r1 uintptr)                                                                                                    
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call2(a, b uintptr) (r1 uintptr)                                                                                                 
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call3(a, b, c uintptr) (r1 uintptr)                                                                                              
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call4(a, b, c, d uintptr) (r1 uintptr)                                                                                           
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call5(a, b, c, d, e uintptr) (r1 uintptr)                                                                                        
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call6(a, b, c, d, e, f uintptr) (r1 uintptr)                                                                                     
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call7(a, b, c, d, e, f, g uintptr) (r1 uintptr)                                                                                  
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call8(a, b, c, d, e, f, g, h uintptr) (r1 uintptr)                                                                               
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call9(a, b, c, d, e, f, g, h, i uintptr) (r1 uintptr)                                                                            
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call10(a, b, c, d, e, f, g, h, i, j uintptr) (r1 uintptr)                                                                        
  │   ├───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call11(a, b, c, d, e, f, g, h, i, j, k uintptr) (r1 uintptr)                                                                     
  │   └───bindgen\bindlib\proc.go                                                                      │                                                                                                                                                                                                  │func (PreloadProc) Call12(a, b, c, d, e, f, g, h, i, j, k, l uintptr) (r1 uintptr)                                                                  
  ├───bindgen\bindlib\validator.go                                                                     │Validate(ptrToStruct any, size, align uintptr, fields ...any)                                                                                                                                     │                                                                                                                                                    
  ├───bindgen\c2go\c2go.go (1)                                                                         │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───bindgen\c2go\c2go.go                                                                         │Run(pkgname, infile string, flags int, conf *Config)                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\c2go\cl\blockctx.go (0)                                                                  │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\cl\codebuild.go (0)                                                                 │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\cl\compile.go (3)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\cl\compile.go                                                                   │SetDebug(flags int)                                                                                                                                                                               │                                                                                                                                                    
  │   ├───bindgen\c2go\cl\compile.go                                                                   │                                                                                                                                                                                                  │func (Package) IsValid() ( bool)                                                                                                                    
  │   └───bindgen\c2go\cl\compile.go                                                                   │NewPackage(pkgPath, pkgName string, file *ast.Node, conf *Config) (pkg Package, err error)                                                                                                        │                                                                                                                                                    
  ├───bindgen\c2go\cl\internal\libc\libc.go                                                            │Printf(fmt *int8, args ...)                                                                                                                                                                       │                                                                                                                                                    
  ├───bindgen\c2go\cl\multifiles.go (0)                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\cl\pkginfo.go (3)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\cl\pkginfo.go                                                                   │                                                                                                                                                                                                  │func (Package) InitDependencies()                                                                                                                   
  │   ├───bindgen\c2go\cl\pkginfo.go                                                                   │                                                                                                                                                                                                  │func (Package) WriteDepTo(dst io.Writer) ( error)                                                                                                   
  │   └───bindgen\c2go\cl\pkginfo.go                                                                   │                                                                                                                                                                                                  │func (Package) WriteDepFile(file string) ( error)                                                                                                   
  ├───bindgen\c2go\cl\stmtchk.go (0)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\clang\ast\ast.go (0)                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\clang\cmod\imp.go (3)                                                               │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\cmod\imp.go                                                               │LoadDeps(dir string, deps string) (pkgs *Package, err error)                                                                                                                                      │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\cmod\imp.go                                                               │Imports(mod *Module, pkgPaths string) (pkgs *Package, err error)                                                                                                                                  │                                                                                                                                                    
  │   └───bindgen\c2go\clang\cmod\imp.go                                                               │Import(mod *Module, pkgPath string) (p *Package, err error)                                                                                                                                       │                                                                                                                                                    
  ├───bindgen\c2go\clang\parser\pages.go (1)                                                           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───bindgen\c2go\clang\parser\pages.go                                                           │NewPagedWriter() ( *PagedWriter)                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\clang\parser\parse.go (3)                                                           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\parser\parse.go                                                           │DumpAST(filename string, conf *Config) (result byte, warning byte, err error)                                                                                                                     │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\parser\parse.go                                                           │ParseFileEx(filename string, mode Mode, conf *Config) (file *ast.Node, warning byte, err error)                                                                                                   │                                                                                                                                                    
  │   └───bindgen\c2go\clang\parser\parse.go                                                           │ParseFile(filename string, mode Mode) (file *ast.Node, warning byte, err error)                                                                                                                   │                                                                                                                                                    
  ├───bindgen\c2go\clang\pathutil\pathutil.go                                                          │Canonical(baseDir string, uri string) ( string)                                                                                                                                                   │                                                                                                                                                    
  ├───bindgen\c2go\clang\preprocessor\preprocessor.go (2)                                              │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\preprocessor\preprocessor.go                                              │SetDebug(flags int)                                                                                                                                                                               │                                                                                                                                                    
  │   └───bindgen\c2go\clang\preprocessor\preprocessor.go                                              │Do(infile, outfile string, conf *Config) (err error)                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\c2go\clang\types\parser\parser.go (2)                                                    │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\types\parser\parser.go                                                    │IsArrayWithoutLen(err error) ( bool)                                                                                                                                                              │                                                                                                                                                    
  │   └───bindgen\c2go\clang\types\parser\parser.go                                                    │ParseType(qualType string, conf *Config) (t types.Type, kind int, err error)                                                                                                                      │                                                                                                                                                    
  ├───bindgen\c2go\clang\types\scanner\scanner.go (0)                                                  │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\clang\types\types.go (6)                                                            │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\types\types.go                                                            │NotVoid(t types.Type) ( bool)                                                                                                                                                                     │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\types\types.go                                                            │MangledName(tag, name string) ( string)                                                                                                                                                           │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\types\types.go                                                            │NewFunc(params, results *types.Tuple, variadic bool) ( *types.Signature)                                                                                                                          │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\types\types.go                                                            │NewPointer(typ types.Type) ( types.Type)                                                                                                                                                          │                                                                                                                                                    
  │   ├───bindgen\c2go\clang\types\types.go                                                            │IsFunc(typ types.Type) ( bool)                                                                                                                                                                    │                                                                                                                                                    
  │   └───bindgen\c2go\clang\types\types.go                                                            │Identical(typ1, typ2 types.Type) ( bool)                                                                                                                                                          │                                                                                                                                                    
  ├───bindgen\c2go\cmd\c2go\impl\c2go.go                                                               │Main(flag *flag.FlagSet, args string)                                                                                                                                                             │                                                                                                                                                    
  ├───bindgen\c2go\proj.go (0)                                                                         │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───bindgen\c2go\testdata\libc\libc.go (5)                                                           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\c2go\testdata\libc\libc.go                                                           │C(s string) ( *int8)                                                                                                                                                                              │                                                                                                                                                    
  │   ├───bindgen\c2go\testdata\libc\libc.go                                                           │X__builtin___memcpy_chk(dst unsafe.Pointer, src unsafe.Pointer, n c.SizeT, elem c.SizeT) ( unsafe.Pointer)                                                                                        │                                                                                                                                                    
  │   ├───bindgen\c2go\testdata\libc\libc.go                                                           │X__builtin_object_size( unsafe.Pointer,  int32) ( c.SizeT)                                                                                                                                        │                                                                                                                                                    
  │   ├───bindgen\c2go\testdata\libc\libc.go                                                           │X__builtin_bswap32(v uint32) ( uint32)                                                                                                                                                            │                                                                                                                                                    
  │   └───bindgen\c2go\testdata\libc\libc.go                                                           │X__builtin_bswap64(v uint64) ( uint64)                                                                                                                                                            │                                                                                                                                                    
  ├───bindgen\c2go\testdata\printf\libc.go                                                             │C(s string) ( *int8)                                                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\c2go\testdata\qsort\libc.go                                                              │C(s string) ( *int8)                                                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\c2go\testdata\strlen\libc.go                                                             │C(s string) ( *int8)                                                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\c2go\testdata\vaexpr\libc.go                                                             │C(s string) ( *int8)                                                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\clang\ast_parse.go (7)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\clang\ast_parse.go                                                                   │First(n Node) (res T)                                                                                                                                                                             │                                                                                                                                                    
  │   ├───bindgen\clang\ast_parse.go                                                                   │All(n Node) (res T)                                                                                                                                                                               │                                                                                                                                                    
  │   ├───bindgen\clang\ast_parse.go                                                                   │Visit(n Node, f func( T)  bool)                                                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\clang\ast_parse.go                                                                   │RegisterNode()                                                                                                                                                                                    │                                                                                                                                                    
  │   ├───bindgen\clang\ast_parse.go                                                                   │ParseAST(data byte) (node Node, err error)                                                                                                                                                        │                                                                                                                                                    
  │   ├───bindgen\clang\ast_parse.go                                                                   │Fprint(w io.Writer, n Node) ( error)                                                                                                                                                              │                                                                                                                                                    
  │   └───bindgen\clang\ast_parse.go                                                                   │Print(n Node) ( error)                                                                                                                                                                            │                                                                                                                                                    
  ├───bindgen\clang\invoke.go (3)                                                                      │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\clang\invoke.go                                                                      │CreateAST(opt *Options) ( byte,  error)                                                                                                                                                           │                                                                                                                                                    
  │   ├───bindgen\clang\invoke.go                                                                      │CreateLayoutMap(opt *Options) ( byte,  error)                                                                                                                                                     │                                                                                                                                                    
  │   └───bindgen\clang\invoke.go                                                                      │Parse(opt *Options) (ast Node, layout *LayoutMap, err error)                                                                                                                                      │                                                                                                                                                    
  ├───bindgen\clang\layout_parse.go (2)                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\clang\layout_parse.go                                                                │                                                                                                                                                                                                  │func (layout) UnmarshalString(data string) ( error)                                                                                                 
  │   └───bindgen\clang\layout_parse.go                                                                │ParseLayoutMap(data byte) ( *LayoutMap,  error)                                                                                                                                                   │                                                                                                                                                    
  ├───bindgen\gengo\convention.go                                                                      │ConvertCase(s string, into NameConvention) ( string)                                                                                                                                              │                                                                                                                                                    
  ├───bindgen\gengo\generate.go (7)                                                                    │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) EmitEnum(n *clang.EnumDecl)                                                                                                           
  │   ├───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) TryEmitNaturalStruct(n *clang.RecordDecl, layout *clang.RecordLayout, ty TypeRef, fl *dst.FieldList, vld *initTypeValidation) ( bool) 
  │   ├───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) EmitSyntheticStruct(n *clang.RecordDecl, layout *clang.RecordLayout, ty TypeRef, fl *dst.FieldList, vld *initTypeValidation)          
  │   ├───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) EmitStruct(n *clang.RecordDecl, layouts *clang.LayoutMap, deferred *deferred, vld *initTypeValidation)                                
  │   ├───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) EmitFunction(n *clang.FunctionDecl)                                                                                                   
  │   ├───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) EmitTypedef(n *clang.TypedefDecl)                                                                                                     
  │   └───bindgen\gengo\generate.go                                                                    │                                                                                                                                                                                                  │func (Module) EmitFrom(ast clang.Node, layouts *clang.LayoutMap)                                                                                    
  ├───bindgen\gengo\identifier.go (3)                                                                  │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\gengo\identifier.go                                                                  │                                                                                                                                                                                                  │func (RelaxedIdentifier) Ref() ( *dst.Ident)                                                                                                        
  │   ├───bindgen\gengo\identifier.go                                                                  │                                                                                                                                                                                                  │func (RelaxedIdentifier) String() ( string)                                                                                                         
  │   └───bindgen\gengo\identifier.go                                                                  │                                                                                                                                                                                                  │func (RelaxedIdentifier) Rename(k string)                                                                                                           
  ├───bindgen\gengo\package.go (11)                                                                    │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\gengo\package.go                                                                     │NewPackageWithProvider(name string, prov Provider) ( *Package)                                                                                                                                    │                                                                                                                                                    
  │   ├───bindgen\gengo\package.go                                                                     │NewPackage(name string, opts ...BaseProviderOption) ( *Package)                                                                                                                                   │                                                                                                                                                    
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (stdoutCloser) Close() ( error)                                                                                                                
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) AddType(tc TypeClass, name string, decl dst.Expr) ( TypeRef)                                                                          
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) Go() ( *ast.File,  error)                                                                                                             
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) Fprint(w io.Writer)                                                                                                                   
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) String() ( string)                                                                                                                    
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) Print()                                                                                                                               
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) GetInitFunc() ( *dst.FuncDecl)                                                                                                        
  │   ├───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) AddInitFunc() ( *dst.FuncDecl)                                                                                                        
  │   └───bindgen\gengo\package.go                                                                     │                                                                                                                                                                                                  │func (Module) OnInit(stmts ...dst.Stmt)                                                                                                             
  ├───bindgen\gengo\provider.go (4)                                                                    │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───bindgen\gengo\provider.go                                                                    │WithRemovePrefix(prefixes ...string) ( BaseProviderOption)                                                                                                                                        │                                                                                                                                                    
  │   ├───bindgen\gengo\provider.go                                                                    │WithInferredMethods(rules MethodInferenceRule) ( BaseProviderOption)                                                                                                                              │                                                                                                                                                    
  │   ├───bindgen\gengo\provider.go                                                                    │WithForcedSynthetic(names ...string) ( BaseProviderOption)                                                                                                                                        │                                                                                                                                                    
  │   └───bindgen\gengo\provider.go                                                                    │NewBaseProvider(opt ...BaseProviderOption) ( *BaseProvider)                                                                                                                                       │                                                                                                                                                    
  ├───bindgen\project\demo\tmp\libdemo.go                                                              │Hello()                                                                                                                                                                                           │                                                                                                                                                    
  ├───bindgen\project\scanner.go                                                                       │ScanComments(path string) (ok bool)                                                                                                                                                               │                                                                                                                                                    
  ├───bindgen\project\zydis\tmp\ok.go                                                                  │Ok(status uint32) ( bool)                                                                                                                                                                         │                                                                                                                                                    
  ├───ms\DecodeTableByDisassembly.go (5)                                                               │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\DecodeTableByDisassembly.go                                                               │DecodeTableByDisassembly()                                                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\DecodeTableByDisassembly.go                                                               │ZwDeviceIoControlFile(info *xed.FilterInfo)                                                                                                                                                       │                                                                                                                                                    
  │   ├───ms\DecodeTableByDisassembly.go                                                               │KiServiceInternal(info *xed.FilterInfo)                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\DecodeTableByDisassembly.go                                                               │KiSystemServiceStart(info *xed.FilterInfo) (syscall *SysCall, ok bool)                                                                                                                            │                                                                                                                                                    
  │   └───ms\DecodeTableByDisassembly.go                                                               │NewSysCall(kernelBase int64) ( *SysCall)                                                                                                                                                          │                                                                                                                                                    
  ├───ms\DecodeTableByDll.go (2)                                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\DecodeTableByDll.go                                                                       │DecodeTableByDll()                                                                                                                                                                                │                                                                                                                                                    
  │   └───ms\DecodeTableByDll.go                                                                       │DecodeNtApi(filename string) (ntApis NtApi)                                                                                                                                                       │                                                                                                                                                    
  ├───ms\IopXxxControlFile.go (2)                                                                      │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\IopXxxControlFile.go                                                                      │NtDeviceIoControlFile()                                                                                                                                                                           │                                                                                                                                                    
  │   └───ms\IopXxxControlFile.go                                                                      │IopXxxControlFile(info *xed.FilterInfo)                                                                                                                                                           │                                                                                                                                                    
  ├───ms\driverTool\driver\driver_windows.go (2)                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\driverTool\driver\driver_windows.go                                                       │NewObject(deviceName, driverPath string) ( *Object)                                                                                                                                               │                                                                                                                                                    
  │   └───ms\driverTool\driver\driver_windows.go                                                       │New() ( Interface)                                                                                                                                                                                │                                                                                                                                                    
  ├───ms\driverTool\environment\Environment_windows.go (1)                                             │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\driverTool\environment\Environment_windows.go                                             │New() ( *object)                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\driverTool\environment\RapidEnvironmentEditor\RapidEnvironmentEditor_windows.go (2)           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\driverTool\environment\RapidEnvironmentEditor\RapidEnvironmentEditor_windows.go           │Layout() ( unison.Paneler)                                                                                                                                                                        │                                                                                                                                                    
  │   └───ms\driverTool\environment\RapidEnvironmentEditor\RapidEnvironmentEditor_windows.go           │                                                                                                                                                                                                  │func (kind) String() ( string)                                                                                                                      
  ├───ms\driverTool\environment\bashrc\bash.go (1)                                                     │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\driverTool\environment\bashrc\bash.go                                                     │New() ( Interface)                                                                                                                                                                                │                                                                                                                                                    
  ├───ms\driverTool\main.go (2)                                                                        │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\driverTool\main.go                                                                        │New() ( widget.API)                                                                                                                                                                               │                                                                                                                                                    
  │   └───ms\driverTool\main.go                                                                        │WalkAllDriverPath(root string) (drivers string)                                                                                                                                                   │                                                                                                                                                    
  ├───ms\hardwareIndo\cpuid\cpuid.go (5)                                                               │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\hardwareIndo\cpuid\cpuid.go                                                               │HasFeature(feature uint64) ( bool)                                                                                                                                                                │                                                                                                                                                    
  │   ├───ms\hardwareIndo\cpuid\cpuid.go                                                               │HasExtendedFeature(feature uint64) ( bool)                                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\hardwareIndo\cpuid\cpuid.go                                                               │HasExtraFeature(feature uint64) ( bool)                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\hardwareIndo\cpuid\cpuid.go                                                               │HasAMDMemEncryptFeature(feature uint32) ( bool)                                                                                                                                                   │                                                                                                                                                    
  │   └───ms\hardwareIndo\cpuid\cpuid.go                                                               │HasThermalAndPowerFeature(feature uint32) ( bool)                                                                                                                                                 │                                                                                                                                                    
  ├───ms\hardwareIndo\cpuid_amd64.go (0)                                                               │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\hardwareIndo\hardwareIndo_windows.go (1)                                                      │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\hardwareIndo\hardwareIndo_windows.go                                                      │New() ( *object)                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\hardwareIndo\mac.go (2)                                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\hardwareIndo\mac.go                                                                       │GetMacAddress() (macAddrs string)                                                                                                                                                                 │                                                                                                                                                    
  │   └───ms\hardwareIndo\mac.go                                                                       │GetIPs() (ips string)                                                                                                                                                                             │                                                                                                                                                    
  ├───ms\hardwareIndo\nvme_windows.go (1)                                                              │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\hardwareIndo\nvme_windows.go                                                              │                                                                                                                                                                                                  │func (HDiskInfo) String()                                                                                                                           
  ├───ms\hardwareIndo\ssd\ssd.go (0)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\hardwareIndo\ssd_windows.go (1)                                                               │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\hardwareIndo\ssd_windows.go                                                               │Struct(s ) ( byte)                                                                                                                                                                                │                                                                                                                                                    
  ├───ms\hardwareIndo\windef.c.i.go (0)                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\hook\win64api.go (4)                                                                          │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\hook\win64api.go                                                                          │GetServices()                                                                                                                                                                                     │                                                                                                                                                    
  │   ├───ms\hook\win64api.go                                                                          │StartService()                                                                                                                                                                                    │                                                                                                                                                    
  │   ├───ms\hook\win64api.go                                                                          │InstalledSoftwareList()                                                                                                                                                                           │                                                                                                                                                    
  │   └───ms\hook\win64api.go                                                                          │ProcessList()                                                                                                                                                                                     │                                                                                                                                                    
  ├───ms\hook\winver\systeminfo_windows.go (1)                                                         │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\hook\winver\systeminfo_windows.go                                                         │GetNativeSystemInfo() ( *SystemInfo,  error)                                                                                                                                                      │                                                                                                                                                    
  ├───ms\hook\winver\under_8.1version_windows.go (1)                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\hook\winver\under_8.1version_windows.go                                                   │GetVersionExW() ( OSVersionInfoExA,  error)                                                                                                                                                       │                                                                                                                                                    
  ├───ms\hook\winver\winnt.go (0)                                                                      │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\hook\winver\winver.go                                                                         │WindowVersion() (v string)                                                                                                                                                                        │                                                                                                                                                    
  ├───ms\packer\packer.go                                                                              │DumpPe()                                                                                                                                                                                          │                                                                                                                                                    
  ├───ms\packer\sigs.go (2)                                                                            │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\packer\sigs.go                                                                            │IsHTMLApp(data byte) ( bool)                                                                                                                                                                      │                                                                                                                                                    
  │   └───ms\packer\sigs.go                                                                            │IsWsf(data byte) ( bool)                                                                                                                                                                          │                                                                                                                                                    
  ├───ms\pdbfetch\pkg\pe\flags.go (7)                                                                  │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\flags.go                                                                  │BTYPE(t uint16) ( uint16)                                                                                                                                                                         │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\flags.go                                                                  │ISPTR(t uint16) ( bool)                                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\flags.go                                                                  │ISFCN(t uint16) ( bool)                                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\flags.go                                                                  │ISARY(t uint16) ( bool)                                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\flags.go                                                                  │ISTAG(c int8) ( bool)                                                                                                                                                                             │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\flags.go                                                                  │INCREF(x uint16) ( uint16)                                                                                                                                                                        │                                                                                                                                                    
  │   └───ms\pdbfetch\pkg\pe\flags.go                                                                  │DECREF(x uint16) ( uint16)                                                                                                                                                                        │                                                                                                                                                    
  ├───ms\pdbfetch\pkg\pe\guid.go (8)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │GuidFromArray(b []byte) ( GUID)                                                                                                                                                                   │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │                                                                                                                                                                                                  │func (GUID) ToArray() ( []byte)                                                                                                                     
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │GuidFromWindowsArray(b []byte) ( GUID)                                                                                                                                                            │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │                                                                                                                                                                                                  │func (GUID) ToWindowsArray() ( []byte)                                                                                                              
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │                                                                                                                                                                                                  │func (GUID) ToString(format string) ( string,  error)                                                                                               
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │                                                                                                                                                                                                  │func (GUID) String() ( string)                                                                                                                      
  │   ├───ms\pdbfetch\pkg\pe\guid.go                                                                   │GuidFromString(s string) ( GUID,  error)                                                                                                                                                          │                                                                                                                                                    
  │   └───ms\pdbfetch\pkg\pe\guid.go                                                                   │                                                                                                                                                                                                  │func (GUID) MarshalText() ( byte,  error)                                                                                                           
  ├───ms\pdbfetch\pkg\pe\ordlookup.go                                                                  │OrdLookup(libname string, ord uint64, makeName bool) ( string)                                                                                                                                    │                                                                                                                                                    
  ├───ms\pdbfetch\pkg\pe\parse_import_directory.go (0)                                                 │                                                                                                                                                                                                  │                                                                                                                                                    
  ├───ms\pdbfetch\pkg\pe\pe.go (5)                                                                     │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\pe.go                                                                     │PE(filename string) (pe *PEFile, err error)                                                                                                                                                       │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\pe.go                                                                     │OBJ(filename string) (pe *PEFile, err error)                                                                                                                                                      │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\pe.go                                                                     │                                                                                                                                                                                                  │func (ByVAddr) Len() ( int)                                                                                                                         
  │   ├───ms\pdbfetch\pkg\pe\pe.go                                                                     │                                                                                                                                                                                                  │func (ByVAddr) Swap(i, j int)                                                                                                                       
  │   └───ms\pdbfetch\pkg\pe\pe.go                                                                     │                                                                                                                                                                                                  │func (ByVAddr) Less(i, j int) ( bool)                                                                                                               
  ├───ms\pdbfetch\pkg\pe\structures.go (37)                                                            │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewDosHeader(fileOffset int) (header *DosHeader)                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewNTHeader(fileOffset int) (header *NTHeader)                                                                                                                                                    │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewFileHeader(fileOffset int) (header *FileHeader)                                                                                                                                                │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewOptionalHeader32(fileOffset int) (header *OptionalHeader32)                                                                                                                                    │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewOptionalHeader64(fileOffset int) (header *OptionalHeader64)                                                                                                                                    │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewDataDirectory(fileOffset int) (header *DataDirectory)                                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewSectionHeader(fileOffset int) (header *SectionHeader)                                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewSymbol(fileOffset int) (header *Symbol)                                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewRelocation(fileOffset int) (header *Relocation)                                                                                                                                                │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewBaseRelocation(fileOffset int) (header *BaseRelocation)                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewBaseRelocationEntry(fileOffset int) (header *BaseRelocationEntry)                                                                                                                              │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewImportDescriptor(fileOffset int) (header *ImportDescriptor)                                                                                                                                    │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │                                                                                                                                                                                                  │func (ImportData32) String() ( string)                                                                                                              
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │                                                                                                                                                                                                  │func (ImportData64) String() ( string)                                                                                                              
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewDelayImportDescriptor(fileOffset int) (header *DelayImportDescriptor)                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewExportDirectory(fileOffset int) (header *ExportDirectory)                                                                                                                                      │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │                                                                                                                                                                                                  │func (ExportData) String() ( string)                                                                                                                
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewResourceDirectory(fileOffset int) (header *ResourceDirectory)                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewResourceDirectoryEntry(fileOffset int) (header *ResourceDirectoryEntry)                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewResourceDataEntry(fileOffset int) (header *ResourceDataEntry)                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewVSVersionInfo(fileOffset int) (header *VSVersionInfo)                                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewVSFixedFileInfo(fileOffset int) (header *VSFixedFileInfo)                                                                                                                                      │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewStringFileInfo(fileOffset int) (header *StringFileInfo)                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewStringTable(fileOffset int) (header *VSStringTable)                                                                                                                                            │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewString(fileOffset int) (header *String)                                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewVar(fileOffset int) (header *Var)                                                                                                                                                              │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewThunkData32(fileOffset int) (header *ThunkData32)                                                                                                                                              │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewThunkData64(fileOffset int) (header *ThunkData64)                                                                                                                                              │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewDebugDirectory(fileOffset int) (header *DebugDirectory)                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewTLSDirectory(fileOffset int) (header *TLSDirectory32)                                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewTLSDirectory64(fileOffset int) (header *TLSDirectory64)                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewLoadConfigDirectory32(fileOffset int) (header *LoadConfigDirectory32)                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewLoadConfigDirectory64(fileOffset int) (header *LoadConfigDirectory64)                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewBoundImportDescriptor(fileOffset int) (header *BoundImportDescriptor)                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │NewBoundForwarderRef(fileOffset int) (header *BoundForwarderRef)                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\structures.go                                                             │EmptyStruct(iface ) ( bool)                                                                                                                                                                       │                                                                                                                                                    
  │   └───ms\pdbfetch\pkg\pe\structures.go                                                             │SetFlags(flagMap , charMap , flags uint32)                                                                                                                                                        │                                                                                                                                                    
  ├───ms\pdbfetch\pkg\pe\util.go (12)                                                                  │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │MaxInt(x, y int) ( int)                                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │MinInt(x, y int) ( int)                                                                                                                                                                           │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │MaxInt32(x, y int32) ( int32)                                                                                                                                                                     │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │MinInt32(x, y int32) ( int32)                                                                                                                                                                     │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │MaxUInt32(x, y uint32) ( uint32)                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │MinUInt32(x, y uint32) ( uint32)                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │PowerOfTwo(val uint32) ( bool)                                                                                                                                                                    │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │AlignDownUInt32(x, align uint32) ( uint32)                                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │AlignUpUInt32(x, align uint32) ( uint32)                                                                                                                                                          │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │AlignDownUInt64(x, align uint64) ( uint64)                                                                                                                                                        │                                                                                                                                                    
  │   ├───ms\pdbfetch\pkg\pe\util.go                                                                   │AlignUpUInt64(x, align uint64) ( uint64)                                                                                                                                                          │                                                                                                                                                    
  │   └───ms\pdbfetch\pkg\pe\util.go                                                                   │MemsetRepeat(a byte, v byte)                                                                                                                                                                      │                                                                                                                                                    
  ├───ms\pte.go (4)                                                                                    │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\pte.go                                                                                    │MiGetPteAddress()                                                                                                                                                                                 │                                                                                                                                                    
  │   ├───ms\pte.go                                                                                    │MmFreeNonCachedMemory(info *xed.FilterInfo)                                                                                                                                                       │                                                                                                                                                    
  │   ├───ms\pte.go                                                                                    │MmReturnChargesToLockPagedPool()                                                                                                                                                                  │                                                                                                                                                    
  │   └───ms\pte.go                                                                                    │MmFreeMappingAddress()                                                                                                                                                                            │                                                                                                                                                    
  ├───ms\windef\windef_windows.go                                                                      │CTL_CODE(deviceType, function, method, access uint32) ( uint32)                                                                                                                                   │                                                                                                                                                    
  ├───ms\xed\binarySearch.go (2)                                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\xed\binarySearch.go                                                                       │DecodeTableByBinarySearchFunc()                                                                                                                                                                   │                                                                                                                                                    
  │   └───ms\xed\binarySearch.go                                                                       │BinarySearchFunc(data byte, Pattern string) (index int, ok bool)                                                                                                                                  │                                                                                                                                                    
  ├───ms\xed\pe.go                                                                                     │ParserPe(filename string) (file *pe.File)                                                                                                                                                         │                                                                                                                                                    
  ├───ms\xed\xed.go (2)                                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───ms\xed\xed.go                                                                                │NewNewFilterInfo(opcodeData byte, baseFunctionRVA uint32) ( *FilterInfo)                                                                                                                          │                                                                                                                                                    
  │   └───ms\xed\xed.go                                                                                │New(data T) (x *)                                                                                                                                                                                 │                                                                                                                                                    
  ├───widget\CodeEditor.go (1)                                                                         │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\CodeEditor.go                                                                         │NewCodeEditor(filePath string) ( *CodeEditor)                                                                                                                                                     │                                                                                                                                                    
  ├───widget\CodeView.go (1)                                                                           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\CodeView.go                                                                           │NewCodeView(path string) ( *CodeView)                                                                                                                                                             │                                                                                                                                                    
  ├───widget\ContextMenuItems.go (2)                                                                   │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\ContextMenuItems.go                                                                   │NewContextMenuItems(panel unison.Paneler, DefaultMouseDown MouseDownCallbackType, items ...ContextMenuItem) ( *ContextMenuItems)                                                                  │                                                                                                                                                    
  │   └───widget\ContextMenuItems.go                                                                   │InsertCmdContextMenuItem(panel *unison.Panel, title string, cmdID int, id *int, cm unison.Menu)                                                                                                   │                                                                                                                                                    
  ├───widget\Explorer.go (1)                                                                           │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\Explorer.go                                                                           │NewExplorer(walkDir string) ( unison.Paneler)                                                                                                                                                     │                                                                                                                                                    
  ├───widget\Split.go (6)                                                                              │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\Split.go                                                                              │NewDockContainerClose(dock *TabClose) ( *unison.DockContainer)                                                                                                                                    │                                                                                                                                                    
  │   ├───widget\Split.go                                                                              │NewDockContainer(dock *Tab) ( *unison.DockContainer)                                                                                                                                              │                                                                                                                                                    
  │   ├───widget\Split.go                                                                              │NewHSplitCloser(left, right *TabClose, scale float32) ( *HSplitCloser)                                                                                                                            │                                                                                                                                                    
  │   ├───widget\Split.go                                                                              │NewVSplitCloser(Top, Bottom *TabClose, scale float32) ( *VSplitCloser)                                                                                                                            │                                                                                                                                                    
  │   ├───widget\Split.go                                                                              │NewHSplit(left, right *Tab, scale float32) ( *HSplit)                                                                                                                                             │                                                                                                                                                    
  │   └───widget\Split.go                                                                              │NewVSplit(Top, Bottom *Tab, scale float32) ( *VSplit)                                                                                                                                             │                                                                                                                                                    
  ├───widget\Tab.go (6)                                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\Tab.go                                                                                │NewTabCloseWithTable(table *, header *, title string, tooltip string) ( *TabClose)                                                                                                                │                                                                                                                                                    
  │   ├───widget\Tab.go                                                                                │NewTabCloses(tabContents ...TabContent) ( *TabClose)                                                                                                                                              │                                                                                                                                                    
  │   ├───widget\Tab.go                                                                                │NewTabClose(title string, tooltip string, panel unison.Paneler) ( *TabClose)                                                                                                                      │                                                                                                                                                    
  │   ├───widget\Tab.go                                                                                │NewTabWithTable(table *, header *, title string, tooltip string) ( *Tab)                                                                                                                          │                                                                                                                                                    
  │   ├───widget\Tab.go                                                                                │NewTab(title string, tooltip string, panel unison.Paneler) ( *Tab)                                                                                                                                │                                                                                                                                                    
  │   └───widget\Tab.go                                                                                │NewTabs(tabContents ...TabContent) ( *Tab)                                                                                                                                                        │                                                                                                                                                    
  ├───widget\Widget.go (23)                                                                            │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │LabelStyle(label *unison.Label)                                                                                                                                                                   │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewPanel() ( *Panel)                                                                                                                                                                              │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │PanelSetBorder(panel unison.Paneler)                                                                                                                                                              │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │SetScrollLayout(paneler unison.Paneler, Columns int)                                                                                                                                              │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewScrollPanelFill(content unison.Paneler) ( *unison.ScrollPanel)                                                                                                                                 │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewScrollPanelHintedFill(content unison.Paneler) ( *unison.ScrollPanel)                                                                                                                           │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewToolBar(buttons ...*unison.Button) ( unison.Paneler)                                                                                                                                           │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewSeparator() ( *unison.Separator)                                                                                                                                                               │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewImageButton(tooltip string, imageBuf T, clickCallback func()) ( *unison.Button)                                                                                                                │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewButton(Text string, ClickCallback func()) ( *unison.Button)                                                                                                                                    │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │CreatePopupMenu(parent *unison.Panel, p *, selectIndex int, tooltip string, titles ...string) ( *)                                                                                                │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewLogView() ( *unison.Field)                                                                                                                                                                     │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewStructViewPanel() ( *StructViewPanel)                                                                                                                                                          │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │AddRowForStructViewPanel(s *StructViewPanel, key, tooltip string, value T)                                                                                                                        │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewStructView(data T, marshal func(data T) values CellData) (view *, kvPanel *unison.Panel)                                                                                                       │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │                                                                                                                                                                                                  │func (structField) SetTooltip() ( string)                                                                                                           
  │   ├───widget\Widget.go                                                                             │NewFieldContextMenuItems(filed *unison.Field)                                                                                                                                                     │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewApplyCancelButtonPanel(parent *unison.Panel, applyCallback, cancelCallback func())                                                                                                             │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewButtonsPanel(titles string, callbacks ...func()) ( *unison.Panel)                                                                                                                              │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewVSpacer() ( *unison.Panel)                                                                                                                                                                     │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewFieldLeftAlign(kvt KeyValueToolTip) ( *unison.Field)                                                                                                                                           │                                                                                                                                                    
  │   ├───widget\Widget.go                                                                             │NewKeyValuePanel() ( *unison.Panel)                                                                                                                                                               │                                                                                                                                                    
  │   └───widget\Widget.go                                                                             │NewLabelRightAlign(kvt KeyValueToolTip) ( *unison.Label)                                                                                                                                          │                                                                                                                                                    
  ├───widget\container_conversion.go (5)                                                               │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\container_conversion.go                                                               │InstallContainerConversionHandlers(paneler unison.Paneler, table *)                                                                                                                               │                                                                                                                                                    
  │   ├───widget\container_conversion.go                                                               │CanConvertToContainer(table *) ( bool)                                                                                                                                                            │                                                                                                                                                    
  │   ├───widget\container_conversion.go                                                               │CanConvertToNonContainer(table *) ( bool)                                                                                                                                                         │                                                                                                                                                    
  │   ├───widget\container_conversion.go                                                               │ConvertToContainer(table *)                                                                                                                                                                       │                                                                                                                                                    
  │   └───widget\container_conversion.go                                                               │ConvertToNonContainer(table *)                                                                                                                                                                    │                                                                                                                                                    
  ├───widget\field.go (2)                                                                              │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\field.go                                                                              │NewField() ( *Field)                                                                                                                                                                              │                                                                                                                                                    
  │   └───widget\field.go                                                                              │NewMultiLineField() ( *Field)                                                                                                                                                                     │                                                                                                                                                    
  ├───widget\godoc.go (1)                                                                              │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\godoc.go                                                                              │NewGodoc(libDir string) ( *Godoc)                                                                                                                                                                 │                                                                                                                                                    
  ├───widget\table.go (10)                                                                             │                                                                                                                                                                                                  │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewTableScrollPanel(table *, header *) ( *unison.Panel)                                                                                                                                           │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewTableScroll(data T, ctx ) ( *unison.Panel)                                                                                                                                                     │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewUUID() ( uuid.UUID)                                                                                                                                                                            │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewNode(data T) (child *)                                                                                                                                                                         │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewContainerNode(typeKey string, data T) (container *)                                                                                                                                            │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewContainerNodes(typeKeys string, objects ...T) (containerNodes *)                                                                                                                               │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │NewTable(data T, ctx ) (table *, header *)                                                                                                                                                        │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │InstallDropSupport(t *, dragKey string, shouldMoveDataCallback func(from, to *)  bool, willDropCallback func(from, to *, move bool)  *, didDropCallback func(undo *, from, to *, move bool)) ( *) │                                                                                                                                                    
  │   ├───widget\table.go                                                                              │CountTableRows(rows *) ( int)                                                                                                                                                                     │                                                                                                                                                    
  │   └───widget\table.go                                                                              │RowContainsRow(ancestor, descendant *) ( bool)                                                                                                                                                    │                                                                                                                                                    
  ├───widget\table_column_header.go (1)                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\table_column_header.go                                                                │NewTableColumnHeader(title, tooltip string) ( *)                                                                                                                                                  │                                                                                                                                                    
  ├───widget\table_drag_drawable.go (1)                                                                │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\table_drag_drawable.go                                                                │NewTableDragDrawable(data *, svg *unison.SVG, singularName, pluralName string) ( unison.Drawable)                                                                                                 │                                                                                                                                                    
  ├───widget\table_drop.go (0)                                                                         │                                                                                                                                                                                                  │                                                                                                                                                    
  └───widget\table_header.go (1)                                                                       │                                                                                                                                                                                                  │                                                                                                                                                    
  │   └───widget\table_header.go                                                                       │NewTableHeader(table *, columnHeaders ...) ( *)                                                                                                                                                   │                                                                                                                                                    

About

No description, website, or topics provided.

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

 
 
 

Languages