fishi

type AST = syntax.AST

type CodegenOptions struct {
	// DumpPreFormat will dump the generated code before it is formatted.
	DumpPreFormat bool

	// TemplateFiles is a map of template names to a path to a custom template
	// file for that template. If entries are detected under the key of one of
	// the ComponentX constants, the path in it is parsed as a template file and
	// used for outputting the generated code for that component instead of the
	// default embedded template.
	TemplateFiles map[string]string

	// IRType is the fully-qualified type of the intermediate representation in
	// the frontend. This is used to make the Frontend function return a
	// specific type instead of requiring an explicit type instantiation when
	// called.
	IRType string

	// PreserveBinarySource is whether to keep the source files for any
	// generated binary after the binary has been successfully
	// compiled/executed. Normally, these files are removed, but preserving them
	// allows for diagnostics on the generated source.
	PreserveBinarySource bool
}

type DiagBinParams struct {
	// Parser is the built parser of the frontend to be validated.
	Parser parse.Parser

	// HooksPkgDir is the path to the directory containing the hooks package.
	HooksPkgDir string

	// HooksExpr is the expression to use to get the hooks map. This can be a
	// function call, constant name, or var name.
	HooksExpr string

	// PathPrefix is a prefix to apply to the paths of generated source files.
	// If empty, the current directory will be used.
	PathPrefix string

	// Opts are options for code generation. This must be set and its IRType
	// field is required to be set, but all other fields within it are optional.
	Opts CodegenOptions

	// LocalIctiobusSource is used to specify a local path to ictiobus to use
	// instead of the currently published latest version. This is useful for
	// debugging while developing ictiobus itself.
	LocalIctiobusSource string

	// FormatPkgDir is the path to the directory containing the format package.
	// It is completely optional; if not set, the generated main will not
	// contain any pre-formatting code and will assume files are directly ready
	// to be fed into the frontend. Must be set if FormatCall is set.
	FormatPkgDir string

	// FormatCall is the name of a function within the package specified by
	// FormatPkgDir that gets an io.Reader that will run any required
	// pre-formatting on an input io.Reader to get code that can be analyzed by
	// the frontend. Is is optional; if not set, the generated main will not
	// contain any pre-formatting code and will assume files are directly ready
	// to be fed into the frontend. Must be set if FormatPkgDir is set.
	FormatCall string

	// FrontendPkgName is the name of the package to place generated frontend
	// code in.
	FrontendPkgName string

	// BinPath is the path to the binary to create.
	BinPath string
}

type GeneratedCodeInfo struct {
	// MainFile is the path to the main executable file, relative to Path.
	MainFile string

	// Path is the location of the root of the generated code.
	Path string
}

type Options struct {
	LexerTrace  bool
	ParserTrace bool
	SDTSTrace   bool
}

type Pattern struct {
	// Regex is the regular expression that is used to match the token.
	Regex *regexp.Regexp

	// Action is the action that the lexer should take when it matches the
	// token.
	Action lex.Action

	// Priority is the priority of the pattern. 0 is the lowest priority, and
	// higher numbers will take precedence over lower numbers.
	Priority int
}

type Results struct {
	AST  *AST
	Tree *parse.Tree
}

type SDD struct {
	// Attribute is the reference to the attribute that this SDD will set. If
	// this is RelHead, then the attribute will be set on the head of the
	// relation and it is a synthesized attribute; otherwise, this is an
	// inherited attribute.
	Attribute trans.AttrRef

	// Rule is the grammar haed and production that this SDD is for. This will
	// have exactly one production in it, as opposed to Rule structs stored in
	// the grammar, which contain *all* productions for a given head symbol.
	Rule grammar.Rule

	// Hook is the name of the hook that is called to get the value to set on
	// the attribute.
	Hook string

	// Args is the list of arguments to the hook.
	Args []trans.AttrRef
}

type SimulatedInputParams struct {
	// Parser is the built parser of the frontend to be validated.
	Parser parse.Parser

	// HooksPkgDir is the path to the directory containing the hooks package.
	HooksPkgDir string

	// HooksExpr is the expression to use to get the hooks map. This can be a
	// function call, constant name, or var name.
	HooksExpr string

	// PathPrefix is a prefix to apply to the paths of generated source files.
	// If empty, the current directory will be used.
	PathPrefix string

	// LocalIctiobusSource is used to specify a local path to ictiobus to use
	// instead of the currently published latest version. This is useful for
	// debugging while developing ictiobus itself.
	LocalIctiobusSource string

	// Opts are options for code generation. This must be set and its IRType
	// field is required to be set, but all other fields within it are optional.
	Opts CodegenOptions

	// ValidationOpts are options for executing the validation itself. This can
	// be nil and if so will be treated as an empty struct.
	ValidationOpts *trans.ValidationOptions

	// WarningHandler is the current warning handler and is queried to see which
	// warning fatal/suppression options should be passed to the simulation
	// binary.
	WarningHandler *WarnHandler

	// QuietMode is whether quiet mode should be enabled in the simulation
	// execution.
	QuietMode bool
}

type Spec struct {
	// Tokens is all of the tokens that are used in the language.
	Tokens []lex.TokenClass

	// Patterns is a map of state names to the lexer patterns that are used
	// while in that state.
	Patterns map[string][]Pattern

	// Grammar is the syntactical specification of the language.
	Grammar grammar.CFG

	// TranslationScheme outlines the Syntax-Directed Translation Scheme for the
	// language by giving the instructions for each attribute.
	TranslationScheme []SDD
}

type SpecMetadata struct {
	// Language is name of the language.
	Language string

	// Version is the version of the language.
	Version string

	// InvocationArgs are the arguments
	InvocationArgs string
}

type WarnHandler struct {

	// Output is the writer that output is sent to. By default this will be
	// os.Stderr in newly-created WarnHandlers, but this can be changed by
	// setting Output to a different io.Writer.
	Output io.Writer

	// ErrorPrefix is the string to prepend error messages written to Output
	// with.
	ErrorPrefix string

	// WarnPrefix is the string to prepend error messages written to Output
	// with.
	WarnPrefix string
	// contains filtered or unexported fields
}

type WarnHandling int

type WarnType int

type Warning struct {
	Type    WarnType
	Message string
}