// Generated by Lisette bindgen
// Source: debug/gosym (Go stdlib)
// Go: 1.25.10
// Lisette: 0.2.1

/// NewLineTable returns a new PC/line table
/// corresponding to the encoded data.
/// Text must be the start address of the
/// corresponding text segment, with the exact
/// value stored in the 'runtime.text' symbol.
/// This value may differ from the start
/// address of the text segment if
/// binary was built with cgo enabled.
pub fn NewLineTable(data: Slice<byte>, text: uint64) -> Ref<LineTable>

/// NewTable decodes the Go symbol table (the ".gosymtab" section in ELF),
/// returning an in-memory representation.
/// Starting with Go 1.3, the Go symbol table no longer includes symbol data.
pub fn NewTable(symtab: Slice<byte>, pcln: Ref<LineTable>) -> Result<Ref<Table>, error>

/// DecodingError represents an error during the decoding of
/// the symbol table.
pub type DecodingError

/// A Func collects information about a single function.
pub struct Func {
  pub Entry: uint64,
  pub Sym: Option<Ref<Sym>>,
  pub End: uint64,
  pub Params: Slice<Option<Ref<Sym>>>,
  pub Locals: Slice<Option<Ref<Sym>>>,
  pub FrameSize: int,
  pub LineTable: Option<Ref<LineTable>>,
  pub Obj: Option<Ref<Obj>>,
}

/// A LineTable is a data structure mapping program counters to line numbers.
/// 
/// In Go 1.1 and earlier, each function (represented by a [Func]) had its own LineTable,
/// and the line number corresponded to a numbering of all source lines in the
/// program, across all files. That absolute line number would then have to be
/// converted separately to a file name and line number within the file.
/// 
/// In Go 1.2, the format of the data changed so that there is a single LineTable
/// for the entire program, shared by all Funcs, and there are no absolute line
/// numbers, just line numbers within specific files.
/// 
/// For the most part, LineTable's methods should be treated as an internal
/// detail of the package; callers should use the methods on [Table] instead.
pub struct LineTable {
  pub Data: Slice<byte>,
  pub PC: uint64,
  pub Line: int,
}

/// An Obj represents a collection of functions in a symbol table.
/// 
/// The exact method of division of a binary into separate Objs is an internal detail
/// of the symbol table format.
/// 
/// In early versions of Go each source file became a different Obj.
/// 
/// In Go 1 and Go 1.1, each package produced one Obj for all Go sources
/// and one Obj per C source file.
/// 
/// In Go 1.2, there is a single Obj for the entire program.
pub struct Obj {
  pub Funcs: Slice<Func>,
  pub Paths: Slice<Sym>,
}

/// A Sym represents a single symbol table entry.
pub struct Sym {
  pub Value: uint64,
  pub Type: byte,
  pub Name: string,
  pub GoType: uint64,
  pub Func: Option<Ref<Func>>,
}

/// Table represents a Go symbol table. It stores all of the
/// symbols decoded from the program and provides methods to translate
/// between symbols, names, and addresses.
pub struct Table {
  pub Syms: Slice<Sym>,
  pub Funcs: Slice<Func>,
  pub Files: Map<string, Option<Ref<Obj>>>,
  pub Objs: Slice<Obj>,
}

/// UnknownFileError represents a failure to find the specific file in
/// the symbol table.
pub struct UnknownFileError(string)

/// UnknownLineError represents a failure to map a line to a program
/// counter, either because the line is beyond the bounds of the file
/// or because there is no code on the given line.
pub struct UnknownLineError {
  pub File: string,
  pub Line: int,
}

impl DecodingError {
  fn Error(self: Ref<DecodingError>) -> string
}

impl Func {
  /// BaseName returns the symbol name without the package or receiver name.
  fn BaseName(self: Ref<Func>) -> string

  /// PackageName returns the package part of the symbol name,
  /// or the empty string if there is none.
  fn PackageName(self: Ref<Func>) -> string

  /// ReceiverName returns the receiver type name of this symbol,
  /// or the empty string if there is none.  A receiver name is only detected in
  /// the case that s.Name is fully-specified with a package name.
  fn ReceiverName(self: Ref<Func>) -> string

  /// Static reports whether this symbol is static (not visible outside its file).
  fn Static(self: Ref<Func>) -> bool
}

impl LineTable {
  /// LineToPC returns the program counter for the given line number,
  /// considering only program counters before maxpc.
  /// 
  /// Deprecated: Use Table's LineToPC method instead.
  fn LineToPC(self: Ref<LineTable>, line: int, maxpc: uint64) -> uint64

  /// PCToLine returns the line number for the given program counter.
  /// 
  /// Deprecated: Use Table's PCToLine method instead.
  fn PCToLine(self: Ref<LineTable>, pc: uint64) -> int
}

impl Sym {
  /// BaseName returns the symbol name without the package or receiver name.
  fn BaseName(self: Ref<Sym>) -> string

  /// PackageName returns the package part of the symbol name,
  /// or the empty string if there is none.
  fn PackageName(self: Ref<Sym>) -> string

  /// ReceiverName returns the receiver type name of this symbol,
  /// or the empty string if there is none.  A receiver name is only detected in
  /// the case that s.Name is fully-specified with a package name.
  fn ReceiverName(self: Ref<Sym>) -> string

  /// Static reports whether this symbol is static (not visible outside its file).
  fn Static(self: Ref<Sym>) -> bool
}

impl Table {
  /// LineToPC looks up the first program counter on the given line in
  /// the named file. It returns [UnknownFileError] or [UnknownLineError] if
  /// there is an error looking up this line.
  fn LineToPC(self: Ref<Table>, file: string, line: int) -> Result<(uint64, Ref<Func>), error>

  /// LookupFunc returns the text, data, or bss symbol with the given name,
  /// or nil if no such symbol is found.
  fn LookupFunc(self: Ref<Table>, name: string) -> Option<Ref<Func>>

  /// LookupSym returns the text, data, or bss symbol with the given name,
  /// or nil if no such symbol is found.
  fn LookupSym(self: Ref<Table>, name: string) -> Option<Ref<Sym>>

  /// PCToFunc returns the function containing the program counter pc,
  /// or nil if there is no such function.
  fn PCToFunc(self: Ref<Table>, pc: uint64) -> Option<Ref<Func>>

  /// PCToLine looks up line number information for a program counter.
  /// If there is no information, it returns fn == nil.
  fn PCToLine(self: Ref<Table>, pc: uint64) -> (string, int, Ref<Func>)

  /// SymByAddr returns the text, data, or bss symbol starting at the given address.
  fn SymByAddr(self: Ref<Table>, addr: uint64) -> Option<Ref<Sym>>
}

impl UnknownFileError {
  fn Error(self) -> string
}

impl UnknownLineError {
  fn Error(self: Ref<UnknownLineError>) -> string
}
