dwarf

type AllSourceLines struct {
	// contains filtered or unexported fields
}

type Cartridge interface {
	GetCoProcBus() coprocessor.CartCoProcBus
}

type FunctionFilter struct {
	FunctionName string
	Function     *SourceFunction
	Lines        SortedLines
}

type SortFunctionsMethod int

type SortLinesMethod int

type SortVariablesMethod int

type SortedFunctions struct {
	Functions []*SourceFunction
	// contains filtered or unexported fields
}

type SortedLines struct {
	Lines []*SourceLine
	// contains filtered or unexported fields
}

type SortedVariables struct {
	Variables []*SourceVariable
	// contains filtered or unexported fields
}

type SortedVariablesLocal struct {
	Variables []*SourceVariableLocal
	// contains filtered or unexported fields
}

type Source struct {

	// source is compiled with optimisation
	Optimised bool

	// instructions in the source code
	Instructions map[uint64]*SourceInstruction

	// all the files in all the compile units
	Files     map[string]*SourceFile
	Filenames []string

	// as above but indexed by the file's short filename, which is sometimes
	// more useful than the full name
	//
	// short filenames also only include files that are in the same path as the
	// ROM file
	FilesByShortname map[string]*SourceFile
	ShortFilenames   []string

	// functions found in the compile units
	Functions     map[string]*SourceFunction
	FunctionNames []string

	// best guess at what the "main" function is in the program. very often
	// this function will be called "main" and will be easy to discern but
	// sometimes it is named something else and we must figure out as best we
	// can which function it is
	//
	// if no function can be found at all, MainFunction will be a stub entry
	MainFunction *SourceFunction

	// special purpose line used to collate instructions that are outside the
	// loaded ROM and are very likely instructions handled by the "driver". the
	// actual driver function is in the Functions map as normal, under the name
	// given in "const driverFunction"
	DriverSourceLine *SourceLine

	// sorted list of every function in all compile unit
	SortedFunctions SortedFunctions

	// all global variables in all compile units
	GlobalsByAddress map[uint64]*SourceVariable
	SortedGlobals    SortedVariables

	// all local variables in all compile units
	SortedLocals SortedVariablesLocal

	// the highest address of any variable (not just global variables, any
	// variable)
	HighAddress uint64

	// lines of source code found in the compile units. this is a sparse
	// coverage of the total address space
	LinesByAddress map[uint64]*SourceLine

	// sorted list of every source line in all compile units
	SortedLines SortedLines

	// every non-blank line of source code in all compile units
	AllLines AllSourceLines

	// sorted lines filtered by function name
	FunctionFilters []*FunctionFilter

	// profiling for the entire program
	Cycles profiling.Cycles

	// flag to indicate whether the execution profile has changed since it was cleared
	//
	// cheap and easy way to prevent sorting too often - rather than sort after
	// every call to execute(), we can use this flag to sort only when we need
	// to in the GUI.
	//
	// probably not scalable but sufficient for our needs of a single GUI
	// running and using the profiling data for only one reason
	ProfilingDirty bool
	// contains filtered or unexported fields
}

type SourceFile struct {
	Filename      string
	ShortFilename string
	Content       SourceFileContent

	// the source file has at least one global variable if HasGlobals is true
	HasGlobals bool
}

type SourceFileContent struct {
	Lines        []*SourceLine
	MaxLineWidth int
}

type SourceFunction struct {
	// name of function
	Name string

	// range of addresses in which function resides
	Range []SourceRange

	// first source line for each instance of the function. note that the first
	// line of a function may not have any code directly associated with it
	DeclLine *SourceLine

	// profiling for the function
	Cycles           profiling.Cycles
	CumulativeCycles profiling.Cycles
	NumCalls         profiling.Calls
	CyclesPerCall    profiling.CyclesPerCall

	// which 2600 kernel has this function executed in
	Kernel profiling.Focus

	// whether the call stack involving this function is likely inaccurate
	OptimisedCallStack bool
	// contains filtered or unexported fields
}

type SourceInstruction struct {
	// the address in memory of the instruction
	Addr uint32

	// the disassembly entry from the cartridge dissassembly. we don't deal with
	// the details of this type in the coprocessor.developer package
	Disasm coprocessor.CartCoProcDisasmEntry

	// the line of source code this diassembly entry is associated with
	Line *SourceLine
	// contains filtered or unexported fields
}

type SourceLine struct {
	// the actual file/line of the SourceLine. line numbers are counted from one
	File       *SourceFile
	LineNumber int

	// the function the line of source can be found within
	Function *SourceFunction

	// whether this line is to be found inlined elsewhere in the program
	Inlined bool

	// plain string of line
	PlainContent string

	// line divided into parts
	Fragments []SourceLineFragment

	// the list of instructions for this line. will be empty if line is not used
	// in the program (eg. a comment line)
	//
	// note that only instructions for non-inlined ranges will be collated
	Instruction []*SourceInstruction

	// what are the addresses to use for breakpoints
	BreakAddresses []uint32

	// whether this source line has been responsible for a likely bug (eg. illegal access of memory)
	Bug bool

	// profiling for the line
	Cycles profiling.Cycles

	// which 2600 kernel has this line executed in
	Kernel profiling.Focus
}

type SourceLineFragment struct {
	Type    SourceLineFragmentType
	Content string
}

type SourceLineFragmentType int

type SourceRange struct {
	Start  uint64
	End    uint64
	Inline bool
}

type SourceType struct {
	Name string

	// is a constant type
	Constant bool

	// the base type of pointer types. will be nil if type is not a pointer type
	PointerType *SourceType

	// size of values of this type (in bytes)
	Size int

	// empty if type is not a composite type. see SourceVariable.IsComposite() function
	Members []*SourceVariable

	// number of elements in the type. if count is more than zero then this
	// type is an array. see SourceVariable.IsArry() function
	ElementCount int

	// the base type of all the elements in the type
	ElementType *SourceType

	// whether to allow type level conversion of the type
	Conversion func(v uint32) (string, any)
}

type SourceVariable struct {
	// name of variable
	Name string

	// variable type (int, char, etc.)
	Type *SourceType

	// first source line for each instance of the function
	DeclLine *SourceLine

	// if Error is not nil then an error was enountered during a resolve()
	// sequence. the error will be logged when the field is first set to true
	Error error
	// contains filtered or unexported fields
}

type SourceVariableLocal struct {
	*SourceVariable

	// the address range for which the variable is valid
	Range SourceRange
}