Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

pkglint

package module

Go to main page

Versions in this module

v23

v23.4.2

May 7, 2024

v23.4.1

Apr 26, 2024

v23.4.0

Mar 18, 2024

v23.3.0

Jan 12, 2024

v23.2.5

Dec 17, 2023

v23.2.4

Sep 10, 2023

v23.2.3

Sep 7, 2023

v23.2.2

Sep 1, 2023

v23.2.1

Aug 29, 2023

v23.2.0

Jul 9, 2023

v23.1.13

Jun 18, 2023

v23.1.12

Jun 15, 2023

v23.1.11

Jun 13, 2023

v23.1.10

May 31, 2023

v23.1.9

May 17, 2023

v23.1.8

Apr 25, 2023

v23.1.7

Apr 22, 2023

v23.1.6

Apr 22, 2023

v23.1.5

Apr 22, 2023

v23.1.3

Apr 21, 2023

v23.1.2

Apr 21, 2023

Changes in this version

+ const AlwaysInScope

+ const CommandLineProvided

+ const DefinedIfInScope

+ const Guessed

+ const List

+ const NeedsRationale

+ const NoVartypeOptions

+ const NonemptyIfDefined

+ const OnePerLine

+ const PackageSettable

+ const SilentAutofixFormat

+ const SystemProvided

+ const Unique

+ const UserSettable

+ var AlnumDot = textproc.NewByteSet("A-Za-z0-9_.")

+ var AutofixLogLevel = &LogLevel

+ var BtAwkCommand = &BasicType

+ var BtBasicRegularExpression = &BasicType

+ var BtBuildlinkDepmethod = &BasicType

+ var BtCFlag = &BasicType

+ var BtCategory = &BasicType

+ var BtComment = &BasicType

+ var BtConfFiles = &BasicType

+ var BtDependencyPattern = &BasicType

+ var BtDependencyWithPath = &BasicType

+ var BtDistSuffix = &BasicType

+ var BtEmulArch = enumFromValues(machineArchValues)

+ var BtEmulOpsys = enumFromValues(emulOpsysValues)

+ var BtEmulPlatform = &BasicType

+ var BtFetchURL = &BasicType

+ var BtFileMode = &BasicType

+ var BtFilePattern = &BasicType

+ var BtFilename = &BasicType

+ var BtGccReqd = &BasicType

+ var BtGitTag = &BasicType

+ var BtGoModuleFile = &BasicType

+ var BtHomepage = &BasicType

+ var BtIdentifierDirect = &BasicType

+ var BtIdentifierIndirect = &BasicType

+ var BtInteger = &BasicType

+ var BtLdFlag = &BasicType

+ var BtLicense = &BasicType

+ var BtMachineArch = enumFromValues(machineArchValues)

+ var BtMachineGnuArch = enumFromValues(machineGnuArchValues)

+ var BtMachineGnuPlatform = &BasicType

+ var BtMachineGnuPlatformOpsys = BtEmulOpsys

+ var BtMachinePlatform = &BasicType

+ var BtMachinePlatformPattern = &BasicType

+ var BtMailAddress = &BasicType

+ var BtMakeTarget = &BasicType

+ var BtMessage = &BasicType

+ var BtOption = &BasicType

+ var BtPathPattern = &BasicType

+ var BtPathlist = &BasicType

+ var BtPathname = &BasicType

+ var BtPathnameSpace = &BasicType

+ var BtPerl5Packlist = &BasicType

+ var BtPerms = &BasicType

+ var BtPkgOptionsVar = &BasicType

+ var BtPkgname = &BasicType

+ var BtPkgpath = &BasicType

+ var BtPkgrevision = &BasicType

+ var BtPlistIdentifier = &BasicType

+ var BtPrefixPathname = &BasicType

+ var BtPythonDependency = &BasicType

+ var BtRPkgName = &BasicType

+ var BtRPkgVer = &BasicType

+ var BtRelativePkgDir = &BasicType

+ var BtRelativePkgPath = &BasicType

+ var BtRestricted = &BasicType

+ var BtSedCommands = &BasicType

+ var BtShellCommand = &BasicType

+ var BtShellCommands = &BasicType

+ var BtShellWord = &BasicType

+ var BtStage = &BasicType

+ var BtToolDependency = &BasicType

+ var BtToolName = &BasicType

+ var BtURL = &BasicType

+ var BtUnknown = &BasicType

+ var BtUserGroupName = &BasicType

+ var BtVariableName = &BasicType

+ var BtVariableNamePattern = &BasicType

+ var BtVersion = &BasicType

+ var BtWrapperReorder = &BasicType

+ var BtWrapperTransform = &BasicType

+ var BtWrkdirSubdirectory = &BasicType

+ var BtWrksrcPathPattern = &BasicType

+ var BtWrksrcSubdirectory = &BasicType

+ var BtYes = &BasicType

+ var BtYesNo = &BasicType

+ var BtYesNoIndirectly = &BasicType

+ var Error = &LogLevel

+ var G = NewPkglint(os.Stdout, os.Stderr)

+ var LowerDash = textproc.NewByteSet("a-z-")

+ var Note = &LogLevel

+ var VarbaseBytes = textproc.NewByteSet("A-Za-z_0-9-+,")

+ var VarparamBytes = textproc.NewByteSet("A-Za-z_0-9-#*+,./[")

+ var Warn = &LogLevel

+ func CheckFileAlternatives(filename CurrPath, pkg *Package)

+ func CheckFileMk(filename CurrPath, pkg *Package)

+ func CheckFileOther(filename CurrPath)

+ func CheckLinesBuildlink3Mk(mklines *MkLines)

+ func CheckLinesDescr(lines *Lines)

+ func CheckLinesDistinfo(pkg *Package, lines *Lines)

+ func CheckLinesMessage(lines *Lines, pkg *Package)

+ func CheckLinesOptionsMk(mklines *MkLines, buildlinkID string)

+ func CheckLinesPatch(lines *Lines, pkg *Package)

+ func CheckLinesPlist(pkg *Package, lines *Lines)

+ func CheckLinesTrailingEmptyLines(lines *Lines)

+ func CheckPackageDirCollision(dir CurrPath, pkgdir RelPath)

+ func CheckdirCategory(dir CurrPath, recurse bool)

+ func CheckdirToplevel(dir CurrPath)

+ func IsPrefs(filename RelPath) bool

+ func LoadsPrefs(filename RelPath) bool

+ func NewPlistLineSorter(plines []*PlistLine) *plistLineSorter

+ func SaveAutofixChanges(lines *Lines) (autofixed bool)

+ type ACLEntry struct

+ func NewACLEntry(glob string, permissions ACLPermissions) ACLEntry

+ type ACLPermissions uint8

+ func (perms ACLPermissions) Contains(subset ACLPermissions) bool

+ func (perms ACLPermissions) HumanString() string

+ func (perms ACLPermissions) String() string

+ type AlternativesChecker struct

+ func (ck *AlternativesChecker) Check(lines *Lines, pkg *Package)

+ type Autofix struct

+ func NewAutofix(line *Line) *Autofix

+ func (fix *Autofix) Apply()

+ func (fix *Autofix) Custom(fixer func(showAutofix, autofix bool))

+ func (fix *Autofix) Delete()

+ func (fix *Autofix) Describef(rawIndex int, format string, args ...interface{})

+ func (fix *Autofix) Errorf(format string, args ...interface{})

+ func (fix *Autofix) Explain(explanation ...string)

+ func (fix *Autofix) InsertAbove(text string)

+ func (fix *Autofix) InsertBelow(text string)

+ func (fix *Autofix) Notef(format string, args ...interface{})

+ func (fix *Autofix) Replace(from string, to string)

+ func (fix *Autofix) ReplaceAfter(prefix, from string, to string)

+ func (fix *Autofix) ReplaceAt(rawIndex int, textIndex int, from string, to string)

+ func (fix *Autofix) Silent()

+ func (fix *Autofix) Warnf(format string, args ...interface{})

+ type Autofixer interface

+ Autofix func() *Autofix

+ type BasicType struct

+ func (bt *BasicType) AllowedEnums() string

+ func (bt *BasicType) HasEnum(value string) bool

+ func (bt *BasicType) IsEnum() bool

+ func (bt *BasicType) NeedsQ() bool

+ type Buildlink3Checker struct

+ func (ck *Buildlink3Checker) Check()

+ type Buildlink3Data struct

+ func LoadBuildlink3Data(mklines *MkLines) *Buildlink3Data

+ type Buildlink3ID string

+ type Change struct

+ Action ChangeAction

+ Author string

+ Date string

+ Location Location

+ Pkgpath PkgsrcPath

+ func (ch *Change) IsAbove(other *Change) bool

+ func (ch *Change) SuccessorOrVersion() string

+ func (ch *Change) Target() PkgsrcPath

+ func (ch *Change) Version() string

+ type ChangeAction uint8

+ const Added

+ const Downgraded

+ const Moved

+ const Removed

+ const Renamed

+ const Updated

+ func ParseChangeAction(s string) ChangeAction

+ func (ca ChangeAction) String() string

+ type Changes struct

+ LastChange map[PkgsrcPath]*Change

+ LastFreezeEnd string

+ LastFreezeStart string

+ type CurrPath string

+ func NewCurrPath(p Path) CurrPath

+ func NewCurrPathSlash(p string) CurrPath

+ func NewCurrPathString(p string) CurrPath

+ func (p CurrPath) AsPath() Path

+ func (p CurrPath) Base() RelPath

+ func (p CurrPath) Chmod(mode os.FileMode) error

+ func (p CurrPath) Clean() CurrPath

+ func (p CurrPath) CleanDot() CurrPath

+ func (p CurrPath) CleanPath() CurrPath

+ func (p CurrPath) ContainsPath(sub Path) bool

+ func (p CurrPath) ContainsText(text string) bool

+ func (p CurrPath) Dir() CurrPath

+ func (p CurrPath) Exists() bool

+ func (p CurrPath) GoString() string

+ func (p CurrPath) HasBase(base string) bool

+ func (p CurrPath) HasPrefixPath(prefix CurrPath) bool

+ func (p CurrPath) HasSuffixPath(suffix Path) bool

+ func (p CurrPath) HasSuffixText(suffix string) bool

+ func (p CurrPath) IsAbs() bool

+ func (p CurrPath) IsDir() bool

+ func (p CurrPath) IsEmpty() bool

+ func (p CurrPath) IsFile() bool

+ func (p CurrPath) JoinClean(other RelPath) CurrPath

+ func (p CurrPath) JoinNoClean(other RelPath) CurrPath

+ func (p CurrPath) Lstat() (os.FileInfo, error)

+ func (p CurrPath) Open() (*os.File, error)

+ func (p CurrPath) Parts() []string

+ func (p CurrPath) ReadDir() ([]os.FileInfo, error)

+ func (p CurrPath) ReadPaths() []CurrPath

+ func (p CurrPath) ReadString() (string, error)

+ func (p CurrPath) Rel(rel CurrPath) RelPath

+ func (p CurrPath) Rename(newName CurrPath) error

+ func (p CurrPath) ReplaceSuffix(from string, to string) CurrPath

+ func (p CurrPath) Split() (dir CurrPath, base string)

+ func (p CurrPath) Stat() (os.FileInfo, error)

+ func (p CurrPath) String() string

+ func (p CurrPath) TrimSuffix(suffix string) CurrPath

+ func (p CurrPath) WriteString(s string) error

+ type CurrPathQueue struct

+ func (q *CurrPathQueue) Front() CurrPath

+ func (q *CurrPathQueue) IsEmpty() bool

+ func (q *CurrPathQueue) Pop() CurrPath

+ func (q *CurrPathQueue) Push(entries ...CurrPath)

+ func (q *CurrPathQueue) PushFront(entries ...CurrPath)

+ type CvsEntry struct

+ Name RelPath

+ Options string

+ Revision string

+ TagDate string

+ Timestamp string

+ type DependencyPattern struct

+ Lower string

+ LowerOp string

+ Pkgbase string

+ Upper string

+ UpperOp string

+ Wildcard string

+ type Diagnoser interface

+ Errorf func(format string, args ...interface{})

+ Explain func(explanation ...string)

+ Notef func(format string, args ...interface{})

+ Warnf func(format string, args ...interface{})

+ type FileCache struct

+ func NewFileCache(size int) *FileCache

+ func (c *FileCache) Evict(filename CurrPath)

+ func (c *FileCache) Get(filename CurrPath, options LoadOptions) *Lines

+ func (c *FileCache) Put(filename CurrPath, options LoadOptions, lines *Lines)

+ type Hash struct

+ type HomepageChecker struct

+ MkLine *MkLine

+ MkLines *MkLines

+ Timeout time.Duration

+ Value string

+ ValueNoVar string

+ func NewHomepageChecker(value string, valueNoVar string, mkline *MkLine, mklines *MkLines) *HomepageChecker

+ func (ck *HomepageChecker) Check()

+ type IncludedMap struct

+ Trace bool

+ func NewIncludedMap() IncludedMap

+ func (im *IncludedMap) FirstTime(p PackagePath) bool

+ func (im *IncludedMap) Seen(p PackagePath) bool

+ type Indentation struct

+ func NewIndentation() *Indentation

+ func (ind *Indentation) AddCheckedFile(filename PkgsrcPath)

+ func (ind *Indentation) AddVar(varname string)

+ func (ind *Indentation) Args() (string, *MkLine)

+ func (ind *Indentation) CheckFinish(filename CurrPath)

+ func (ind *Indentation) DependsOn(varname string) bool

+ func (ind *Indentation) Depth(directive string) int

+ func (ind *Indentation) HasExists(filename PkgsrcPath) bool

+ func (ind *Indentation) IsConditional() bool

+ func (ind *Indentation) IsEmpty() bool

+ func (ind *Indentation) Pop()

+ func (ind *Indentation) Push(mkline *MkLine, indent int, args string, guard bool)

+ func (ind *Indentation) RememberUsedVariables(cond *MkCond)

+ func (ind *Indentation) String() string

+ func (ind *Indentation) TrackAfter(mkline *MkLine)

+ func (ind *Indentation) TrackBefore(mkline *MkLine)

+ func (ind *Indentation) Varnames() []string

+ type InterPackage struct

+ func (ip *InterPackage) Bl3(name string, loc *Location) *Location

+ func (ip *InterPackage) Enable()

+ func (ip *InterPackage) Enabled() bool

+ func (ip *InterPackage) Hash(alg string, filename RelPath, hashBytes []byte, loc *Location) *Hash

+ func (ip *InterPackage) IsLicenseUsed(name string) bool

+ func (ip *InterPackage) UseLicense(name string)

+ type LazyStringBuilder struct

+ func NewLazyStringBuilder(expected string) LazyStringBuilder

+ func (b *LazyStringBuilder) Len() int

+ func (b *LazyStringBuilder) Reset(expected string)

+ func (b *LazyStringBuilder) String() string

+ func (b *LazyStringBuilder) Write(p []byte) (n int, err error)

+ func (b *LazyStringBuilder) WriteByte(c byte)

+ func (b *LazyStringBuilder) WriteString(s string)

+ type LicenseChecker struct

+ MkLine *MkLine

+ MkLines *MkLines

+ func (lc *LicenseChecker) Check(value string, op MkOperator)

+ type Line struct

+ Basename RelPath

+ Location Location

+ Text string

+ func NewLine(filename CurrPath, lineno int, text string, rawLine *RawLine) *Line

+ func NewLineEOF(filename CurrPath) *Line

+ func NewLineMulti(filename CurrPath, firstLine int, text string, rawLines []*RawLine) *Line

+ func NewLineWhole(filename CurrPath) *Line

+ func (*Line) Explain(explanation ...string)

+ func (line *Line) Autofix() *Autofix

+ func (line *Line) Errorf(format string, args ...interface{})

+ func (line *Line) File(rel RelPath) CurrPath

+ func (line *Line) Filename() CurrPath

+ func (line *Line) IsCvsID(prefixRe regex.Pattern) (found bool, expanded bool)

+ func (line *Line) IsMultiline() bool

+ func (line *Line) Linenos() string

+ func (line *Line) Notef(format string, args ...interface{})

+ func (line *Line) RawText(rawIndex int) string

+ func (line *Line) Rel(other CurrPath) RelPath

+ func (line *Line) RelLine(other *Line) string

+ func (line *Line) RelLocation(other Location) string

+ func (line *Line) String() string

+ func (line *Line) Warnf(format string, args ...interface{})

+ type LineChecker struct

+ func (ck LineChecker) CheckLength(maxLength int)

+ func (ck LineChecker) CheckTrailingWhitespace()

+ func (ck LineChecker) CheckValidCharacters()

+ type Lines struct

+ BaseName RelPath

+ Filename CurrPath

+ Lines []*Line

+ func Load(filename CurrPath, options LoadOptions) *Lines

+ func NewLines(filename CurrPath, lines []*Line) *Lines

+ func (ls *Lines) CheckCvsID(index int, prefixRe regex.Pattern, suggestedPrefix string) bool

+ func (ls *Lines) EOFLine() *Line

+ func (ls *Lines) LastLine() *Line

+ func (ls *Lines) Len() int

+ func (ls *Lines) SaveAutofixChanges() bool

+ func (ls *Lines) Whole() *Line

+ type LinesLexer struct

+ func NewLinesLexer(lines *Lines) *LinesLexer

+ func (llex *LinesLexer) CurrentLine() *Line

+ func (llex *LinesLexer) EOF() bool

+ func (llex *LinesLexer) NextRegexp(re regex.Pattern) []string

+ func (llex *LinesLexer) PreviousLine() *Line

+ func (llex *LinesLexer) Skip() bool

+ func (llex *LinesLexer) SkipEmptyOrNote() bool

+ func (llex *LinesLexer) SkipPrefix(prefix string) bool

+ func (llex *LinesLexer) SkipRegexp(re regex.Pattern) bool

+ func (llex *LinesLexer) SkipText(text string) bool

+ func (llex *LinesLexer) SkipTextOrWarn(text string) bool

+ func (llex *LinesLexer) Undo()

+ type LoadOptions uint8

+ const LogErrors

+ const Makefile

+ const MustSucceed

+ const NotEmpty

+ type Location struct

+ Filename CurrPath

+ func NewLocation(filename CurrPath, lineno int) Location

+ func (loc *Location) File(rel RelPath) CurrPath

+ func (loc *Location) Lineno(rawIndex int) int

+ type LogLevel struct

+ GccName string

+ TraditionalName string

+ type Logger struct

+ Opts LoggerOpts

+ func (l *Logger) Diag(line *Line, level *LogLevel, format string, args ...interface{})

+ func (l *Logger) Explain(explanation ...string)

+ func (l *Logger) FirstTime(filename CurrPath, linenos, msg string) bool

+ func (l *Logger) IsAutofix() bool

+ func (l *Logger) Logf(level *LogLevel, filename CurrPath, lineno, format, msg string)

+ func (l *Logger) Relevant(format string) bool

+ func (l *Logger) ShowSummary(args []string)

+ func (l *Logger) TechErrorf(location CurrPath, format string, args ...interface{})

+ func (l *Logger) TechFatalf(location CurrPath, format string, args ...interface{})

+ type LoggerOpts struct

+ Autofix bool

+ Explain bool

+ GccOutput bool

+ Only []string

+ Quiet bool

+ ShowAutofix bool

+ ShowSource bool

+ type MkAssignChecker struct

+ MkLine *MkLine

+ MkLines *MkLines

+ func NewMkAssignChecker(mkLine *MkLine, mkLines *MkLines) *MkAssignChecker

+ type MkCond struct

+ And []*MkCond

+ Call *MkCondCall

+ Compare *MkCondCompare

+ Defined string

+ Empty *MkVarUse

+ Not *MkCond

+ Or []*MkCond

+ Paren *MkCond

+ Term *MkCondTerm

+ func (cond *MkCond) Walk(callback *MkCondCallback)

+ type MkCondCall struct

+ Arg string

+ Name string

+ type MkCondCallback struct

+ And func(conds []*MkCond)

+ Call func(name string, arg string)

+ Compare func(left *MkCondTerm, op string, right *MkCondTerm)

+ Defined func(varname string)

+ Empty func(empty *MkVarUse)

+ Not func(cond *MkCond)

+ Paren func(cond *MkCond)

+ Var func(varuse *MkVarUse)

+ VarUse func(varuse *MkVarUse)

+ type MkCondChecker struct

+ MkLine *MkLine

+ MkLines *MkLines

+ func NewMkCondChecker(mkLine *MkLine, mkLines *MkLines) *MkCondChecker

+ func (ck *MkCondChecker) Check()

+ type MkCondCompare struct

+ Left MkCondTerm

+ Op string

+ Right MkCondTerm

+ type MkCondSimplifier struct

+ MkLine *MkLine

+ MkLines *MkLines

+ func (s *MkCondSimplifier) SimplifyVarUse(varuse *MkVarUse, fromEmpty bool, neg bool)

+ type MkCondTerm struct

+ Num string

+ Str string

+ Var *MkVarUse

+ type MkCondWalker struct

+ func (w *MkCondWalker) Walk(cond *MkCond, callback *MkCondCallback)

+ type MkLexer struct

+ func NewMkLexer(text string, diag Autofixer) *MkLexer

+ func (p *MkLexer) Autofix() *Autofix

+ func (p *MkLexer) EOF() bool

+ func (p *MkLexer) Errorf(format string, args ...interface{})

+ func (p *MkLexer) Explain(explanation ...string)

+ func (p *MkLexer) HasDiag() bool

+ func (p *MkLexer) MkToken() *MkToken

+ func (p *MkLexer) MkTokens() ([]*MkToken, string)

+ func (p *MkLexer) Notef(format string, args ...interface{})

+ func (p *MkLexer) Rest() string

+ func (p *MkLexer) VarUse() *MkVarUse

+ func (p *MkLexer) VarUseModifiers(varname string, closing byte) []MkVarUseModifier

+ func (p *MkLexer) Varname() string

+ func (p *MkLexer) Warnf(format string, args ...interface{})

+ type MkLine struct

+ func (*MkLine) WithoutMakeVariables(value string) string

+ func (mkline *MkLine) Args() string

+ func (mkline *MkLine) Comment() string

+ func (mkline *MkLine) Cond() *MkCond

+ func (mkline *MkLine) ConditionalVars() []string

+ func (mkline *MkLine) Directive() string

+ func (mkline *MkLine) DirectiveComment() string

+ func (mkline *MkLine) ExplainRelativeDirs()

+ func (mkline *MkLine) Fields() []string

+ func (mkline *MkLine) FirstLineContainsValue() bool

+ func (mkline *MkLine) ForEachUsed(action func(varUse *MkVarUse, time VucTime))

+ func (mkline *MkLine) ForEachUsedText(text string, time VucTime, action func(varUse *MkVarUse, time VucTime))

+ func (mkline *MkLine) ForEachUsedVarUse(varuse *MkVarUse, time VucTime, action func(varUse *MkVarUse, time VucTime))

+ func (mkline *MkLine) HasComment() bool

+ func (mkline *MkLine) HasElseBranch() bool

+ func (mkline *MkLine) HasRationale(keywords ...string) bool

+ func (mkline *MkLine) IncludedFile() RelPath

+ func (mkline *MkLine) IncludedFileFull() CurrPath

+ func (mkline *MkLine) Indent() string

+ func (mkline *MkLine) IsComment() bool

+ func (mkline *MkLine) IsCommentedVarassign() bool

+ func (mkline *MkLine) IsDependency() bool

+ func (mkline *MkLine) IsDirective() bool

+ func (mkline *MkLine) IsEmpty() bool

+ func (mkline *MkLine) IsInclude() bool

+ func (mkline *MkLine) IsShellCommand() bool

+ func (mkline *MkLine) IsSysinclude() bool

+ func (mkline *MkLine) IsVarassign() bool

+ func (mkline *MkLine) IsVarassignMaybeCommented() bool

+ func (mkline *MkLine) MustExist() bool

+ func (mkline *MkLine) NeedsCond() bool

+ func (mkline *MkLine) Op() MkOperator

+ func (mkline *MkLine) RelMkLine(other *MkLine) string

+ func (mkline *MkLine) ResolveVarsInRelativePath(relativePath PackagePath, pkg *Package) PackagePath

+ func (mkline *MkLine) SetConditionalVars(varnames []string)

+ func (mkline *MkLine) SetHasElseBranch(elseLine *MkLine)

+ func (mkline *MkLine) ShellCommand() string

+ func (mkline *MkLine) Sources() string

+ func (mkline *MkLine) String() string

+ func (mkline *MkLine) Targets() string

+ func (mkline *MkLine) Tokenize(text string, warn bool) []*MkToken

+ func (mkline *MkLine) UnquoteShell(str string, warn bool) string

+ func (mkline *MkLine) Value() string

+ func (mkline *MkLine) ValueAlign() string

+ func (mkline *MkLine) ValueFields(value string) []string

+ func (mkline *MkLine) ValueFieldsLiteral() []string

+ func (mkline *MkLine) ValueSplit(value string, separator string) []string

+ func (mkline *MkLine) ValueTokens() ([]*MkToken, string)

+ func (mkline *MkLine) Varcanon() string

+ func (mkline *MkLine) VariableNeedsQuoting(mklines *MkLines, varuse *MkVarUse, vartype *Vartype, vuc *VarUseContext) (needsQuoting YesNoUnknown)

+ func (mkline *MkLine) Varname() string

+ func (mkline *MkLine) Varparam() string

+ type MkLineChecker struct

+ MkLine *MkLine

+ MkLines *MkLines

+ func NewMkLineChecker(mkLines *MkLines, mkLine *MkLine) MkLineChecker

+ func (ck MkLineChecker) Check()

+ func (ck MkLineChecker) CheckRelativePath(pp PackagePath, rel RelPath, mustExist bool)

+ func (ck MkLineChecker) CheckRelativePkgdir(rel RelPath, pkgdir PackagePath)

+ func (ck MkLineChecker) CheckVartypeBasic(varname string, checker *BasicType, op MkOperator, value, comment string, ...)

+ type MkLineParser struct

+ func NewMkLineParser() MkLineParser

+ func (p MkLineParser) MatchVarassign(line *Line, text string, splitResult *mkLineSplitResult) (bool, *mkLineAssign)

+ func (p MkLineParser) Parse(line *Line) *MkLine

+ type MkLines struct

+ Tools *Tools

+ func LoadMk(filename CurrPath, pkg *Package, options LoadOptions) *MkLines

+ func NewMkLines(lines *Lines, pkg *Package, extraScope *Scope) *MkLines

+ func (mklines *MkLines) Check()

+ func (mklines *MkLines) CheckUsedBy(relativeName PkgsrcPath)

+ func (mklines *MkLines) EOFLine() *MkLine

+ func (mklines *MkLines) ExpandLoopVar(varname string) []string

+ func (mklines *MkLines) ForEach(action func(mkline *MkLine))

+ func (mklines *MkLines) ForEachEnd(action func(mkline *MkLine) bool, atEnd func(lastMkline *MkLine)) bool

+ func (mklines *MkLines) IsUnreachable(mkline *MkLine) bool

+ func (mklines *MkLines) SaveAutofixChanges()

+ func (mklines *MkLines) SplitToParagraphs() []*Paragraph

+ func (mklines *MkLines) UseVar(mkline *MkLine, varname string, time VucTime)

+ func (mklines *MkLines) Whole() *Line

+ type MkLinesLexer struct

+ func NewMkLinesLexer(mklines *MkLines) *MkLinesLexer

+ func (mlex *MkLinesLexer) CurrentMkLine() *MkLine

+ func (mlex *MkLinesLexer) PreviousMkLine() *MkLine

+ func (mlex *MkLinesLexer) SkipIf(pred func(mkline *MkLine) bool) bool

+ type MkOperator uint8

+ func NewMkOperator(op string) MkOperator

+ func (op MkOperator) String() string

+ func (op MkOperator) Time() VucTime

+ type MkParser struct

+ EmitWarnings bool

+ func NewMkParser(diag Autofixer, text string) *MkParser

+ func (p *MkParser) DependencyPattern() *DependencyPattern

+ func (p *MkParser) EOF() bool

+ func (p *MkParser) MkCond() *MkCond

+ func (p *MkParser) Op() (bool, MkOperator)

+ func (p *MkParser) PkgbasePattern() string

+ func (p *MkParser) Rest() string

+ type MkShAndOr struct

+ Ops []string

+ Pipes []*MkShPipeline

+ func NewMkShAndOr(pipeline *MkShPipeline) *MkShAndOr

+ func (andor *MkShAndOr) Add(op string, pipeline *MkShPipeline) *MkShAndOr

+ type MkShCase struct

+ Cases []*MkShCaseItem

+ Word *ShToken

+ type MkShCaseItem struct

+ Action *MkShList

+ Patterns []*ShToken

+ Separator MkShSeparator

+ Var *ShToken

+ type MkShCommand struct

+ Compound *MkShCompoundCommand

+ FuncDef *MkShFunctionDefinition

+ Redirects []*MkShRedirection

+ Simple *MkShSimpleCommand

+ type MkShCompoundCommand struct

+ Brace *MkShList

+ Case *MkShCase

+ For *MkShFor

+ If *MkShIf

+ Loop *MkShLoop

+ Subshell *MkShList

+ type MkShFor struct

+ Body *MkShList

+ Values []*ShToken

+ Varname string

+ type MkShFunctionDefinition struct

+ Body *MkShCompoundCommand

+ Name string

+ type MkShIf struct

+ Actions []*MkShList

+ Conds []*MkShList

+ Else *MkShList

+ func (cl *MkShIf) Prepend(cond *MkShList, action *MkShList)

+ type MkShList struct

+ AndOrs []*MkShAndOr

+ Separators []MkShSeparator

+ func NewMkShList() *MkShList

+ func (list *MkShList) AddAndOr(andor *MkShAndOr) *MkShList

+ func (list *MkShList) AddSeparator(separator MkShSeparator) *MkShList

+ type MkShLoop struct

+ Action *MkShList

+ Cond *MkShList

+ Until bool

+ type MkShPipeline struct

+ Cmds []*MkShCommand

+ Negated bool

+ func NewMkShPipeline(negated bool, cmds []*MkShCommand) *MkShPipeline

+ func (pipe *MkShPipeline) Add(cmd *MkShCommand) *MkShPipeline

+ type MkShRedirection struct

+ Fd int

+ Op string

+ Target *ShToken

+ type MkShSeparator uint8

+ type MkShSimpleCommand struct

+ Args []*ShToken

+ Assignments []*ShToken

+ Name *ShToken

+ Redirections []*MkShRedirection

+ type MkShWalker struct

+ Callback struct{ ... }

+ Context []MkShWalkerPathElement

+ func NewMkShWalker() *MkShWalker

+ func (w *MkShWalker) Current() MkShWalkerPathElement

+ func (w *MkShWalker) Parent(steps int) interface{}

+ func (w *MkShWalker) Walk(list *MkShList)

+ type MkShWalkerPathElement struct

+ Element interface{}

+ Index int

+ type MkToken struct

+ Text string

+ Varuse *MkVarUse

+ type MkTokensLexer struct

+ func NewMkTokensLexer(tokens []*MkToken) *MkTokensLexer

+ func (m *MkTokensLexer) EOF() bool

+ func (m *MkTokensLexer) Mark() MkTokensLexerMark

+ func (m *MkTokensLexer) NextVarUse() *MkToken

+ func (m *MkTokensLexer) Reset(mark MkTokensLexerMark)

+ func (m *MkTokensLexer) Rest() string

+ func (m *MkTokensLexer) Since(mark MkTokensLexerMark) string

+ func (m *MkTokensLexer) Skip(n int) bool

+ func (m *MkTokensLexer) SkipMixed(n int) bool

+ type MkTokensLexerMark struct

+ type MkVarUse struct

+ func NewMkVarUse(varname string, modifiers ...MkVarUseModifier) *MkVarUse

+ func ToVarUse(str string) *MkVarUse

+ func (vu *MkVarUse) HasModifier(prefix string) bool

+ func (vu *MkVarUse) IsExpression() bool

+ func (vu *MkVarUse) IsQ() bool

+ func (vu *MkVarUse) Mod() string

+ func (vu *MkVarUse) String() string

+ type MkVarUseChecker struct

+ MkLine *MkLine

+ MkLines *MkLines

+ func NewMkVarUseChecker(use *MkVarUse, mklines *MkLines, mkline *MkLine) *MkVarUseChecker

+ func (ck *MkVarUseChecker) Check(vuc *VarUseContext)

+ type MkVarUseModifier string

+ func (MkVarUseModifier) EvalSubst(s string, left bool, from string, right bool, to string, flags string) (ok bool, result string)

+ func (m MkVarUseModifier) ChangesList() bool

+ func (m MkVarUseModifier) HasPrefix(prefix string) bool

+ func (m MkVarUseModifier) IsQ() bool

+ func (m MkVarUseModifier) IsSuffixSubst() bool

+ func (m MkVarUseModifier) IsToLower() bool

+ func (m MkVarUseModifier) MatchMatch() (ok bool, positive bool, pattern string, exact bool)

+ func (m MkVarUseModifier) MatchSubst() (ok bool, regex bool, from string, to string, options string)

+ func (m MkVarUseModifier) Quoted(end string) string

+ func (m MkVarUseModifier) String() string

+ func (m MkVarUseModifier) Subst(str string) (bool, string)

+ type NetBSDProject struct

+ func NewNetBSDProject() *NetBSDProject

+ func (p NetBSDProject) Deprecated(varname string) string

+ func (p NetBSDProject) Types() *VarTypeRegistry

+ type Once struct

+ Trace bool

+ func (o *Once) FirstTime(what string) bool

+ func (o *Once) FirstTimeSlice(whats ...string) bool

+ func (o *Once) Seen(what string) bool

+ func (o *Once) SeenSlice(whats ...string) bool

+ type OptionsLinesChecker struct

+ func (ck *OptionsLinesChecker) Check()

+ type Package struct

+ DistinfoFile PackagePath

+ EffectivePkgbase string

+ EffectivePkgname string

+ EffectivePkgnameLine *MkLine

+ EffectivePkgversion string

+ Filesdir PackagePath

+ IgnoreMissingPatches bool

+ Makefile *MkLines

+ Once Once

+ Patchdir PackagePath

+ Pkgdir PackagePath

+ Pkgpath PkgsrcPath

+ Plist PlistContent

+ PlistLines *PlistLines

+ func NewPackage(dir CurrPath) *Package

+ func (pkg *Package) AutofixDistinfo(oldSha1, newSha1 string)

+ func (pkg *Package) CanFixAddInclude() bool

+ func (pkg *Package) Check()

+ func (pkg *Package) CheckVarorder(mklines *MkLines)

+ func (pkg *Package) File(relativeFileName PackagePath) CurrPath

+ func (pkg *Package) FixAddInclude(includedFile PackagePath)

+ func (pkg *Package) Includes(filename PackagePath) *MkLine

+ func (pkg *Package) Rel(filename CurrPath) PackagePath

+ type PackagePath string

+ func NewPackagePath(p RelPath) PackagePath

+ func NewPackagePathString(p string) PackagePath

+ func (p PackagePath) AsPath() Path

+ func (p PackagePath) AsRelPath() RelPath

+ func (p PackagePath) CleanPath() PackagePath

+ func (p PackagePath) ContainsPath(sub Path) bool

+ func (p PackagePath) ContainsText(contained string) bool

+ func (p PackagePath) HasPrefixPath(sub Path) bool

+ func (p PackagePath) IsEmpty() bool

+ func (p PackagePath) JoinNoClean(other RelPath) PackagePath

+ func (p PackagePath) Replace(from, to string) PackagePath

+ func (p PackagePath) String() string

+ type Paragraph struct

+ func NewParagraph(mklines *MkLines, from, to int) *Paragraph

+ func (p *Paragraph) Align()

+ func (p *Paragraph) AlignTo(column int)

+ func (p *Paragraph) FirstLine() *MkLine

+ func (p *Paragraph) ForEach(action func(mkline *MkLine))

+ func (p *Paragraph) LastLine() *MkLine

+ func (p *Paragraph) MkLines() []*MkLine

+ type ParseError struct

+ RemainingTokens []string

+ func (e *ParseError) Error() string

+ type PatchChecker struct

+ func (ck *PatchChecker) Check(pkg *Package)

+ type Path string

+ func NewPath(p string) Path

+ func (p Path) Base() RelPath

+ func (p Path) Clean() Path

+ func (p Path) CleanDot() Path

+ func (p Path) CleanPath() Path

+ func (p Path) ContainsPath(sub Path) bool

+ func (p Path) ContainsText(contained string) bool

+ func (p Path) Count() int

+ func (p Path) Dir() Path

+ func (p Path) GoString() string

+ func (p Path) HasBase(base string) bool

+ func (p Path) HasPrefixPath(prefix Path) bool

+ func (p Path) HasPrefixText(prefix string) bool

+ func (p Path) HasSuffixPath(suffix Path) bool

+ func (p Path) HasSuffixText(suffix string) bool

+ func (p Path) IsAbs() bool

+ func (p Path) IsEmpty() bool

+ func (p Path) JoinClean(s RelPath) Path

+ func (p Path) JoinNoClean(s RelPath) Path

+ func (p Path) Parts() []string

+ func (p Path) Rel(other Path) RelPath

+ func (p Path) Replace(from, to string) Path

+ func (p Path) Split() (dir Path, base string)

+ func (p Path) String() string

+ func (p Path) TrimSuffix(suffix string) Path

+ type Pkglint struct

+ CheckGlobal bool

+ DumpMakefile bool

+ Experimental bool

+ Import bool

+ Infrastructure bool

+ InterPackage InterPackage

+ Logger Logger

+ Network bool

+ Pkgsrc *Pkgsrc

+ Profiling bool

+ Project Project

+ Recursive bool

+ Testing bool

+ Todo CurrPathQueue

+ Username string

+ WarnExtra bool

+ WarnPerm bool

+ WarnQuoting bool

+ Wip bool

+ func NewPkglint(stdout io.Writer, stderr io.Writer) Pkglint

+ func (p *Pkglint) Abs(filename CurrPath) CurrPath

+ func (p *Pkglint) Check(dirent CurrPath)

+ func (p *Pkglint) Main(stdout io.Writer, stderr io.Writer, args []string) (exitCode int)

+ func (p *Pkglint) ParseCommandLine(args []string) int

+ func (p *Pkglint) Tool(mklines *MkLines, command string, time ToolTime) (tool *Tool, usable bool)

+ func (p *Pkglint) ToolByVarname(mklines *MkLines, varname string) *Tool

+ type Pkgsrc struct

+ MasterSiteURLToVar map[string]string

+ MasterSiteVarToURL map[string]string

+ PkgOptions map[string]string

+ Tools *Tools

+ UserDefinedVars Scope

+ func NewPkgsrc(dir CurrPath) *Pkgsrc

+ func (src *Pkgsrc) Deprecated(varname string) string

+ func (src *Pkgsrc) File(relativeName PkgsrcPath) CurrPath

+ func (src *Pkgsrc) FilePkg(rel PackagePath) CurrPath

+ func (src *Pkgsrc) IsBuildDef(varname string) bool

+ func (src *Pkgsrc) IsInfra(filename CurrPath) bool

+ func (src *Pkgsrc) IsInfraMain(filename CurrPath) bool

+ func (src *Pkgsrc) IsOpsysVar(varbase string) bool

+ func (src *Pkgsrc) IsWip(filename CurrPath) bool

+ func (src *Pkgsrc) Latest(category PkgsrcPath, re regex.Pattern, repl string) string

+ func (src *Pkgsrc) ListVersions(category PkgsrcPath, re regex.Pattern, repl string, errorIfEmpty bool) []string

+ func (src *Pkgsrc) Load(filename PkgsrcPath, options LoadOptions) *Lines

+ func (src *Pkgsrc) LoadInfrastructure()

+ func (src *Pkgsrc) LoadMk(filename PkgsrcPath, options LoadOptions) *MkLines

+ func (src *Pkgsrc) LoadMkExisting(filename PkgsrcPath) *MkLines

+ func (src *Pkgsrc) ReadDir(dirName PkgsrcPath) []os.FileInfo

+ func (src *Pkgsrc) Rel(filename CurrPath) PkgsrcPath

+ func (src *Pkgsrc) Relpath(from, to CurrPath) RelPath

+ func (src *Pkgsrc) SuggestedUpdates() []SuggestedUpdate

+ func (src *Pkgsrc) Types() *VarTypeRegistry

+ func (src *Pkgsrc) VariableType(mklines *MkLines, varname string) (vartype *Vartype)

+ type PkgsrcPath string

+ func NewPkgsrcPath(p Path) PkgsrcPath

+ func (p PkgsrcPath) AsPath() Path

+ func (p PkgsrcPath) AsRelPath() RelPath

+ func (p PkgsrcPath) Base() RelPath

+ func (p PkgsrcPath) Count() int

+ func (p PkgsrcPath) Dir() PkgsrcPath

+ func (p PkgsrcPath) HasPrefixPath(prefix Path) bool

+ func (p PkgsrcPath) JoinNoClean(other RelPath) PkgsrcPath

+ func (p PkgsrcPath) String() string

+ type PlistChecker struct

+ func NewPlistChecker(pkg *Package) *PlistChecker

+ func (ck *PlistChecker) Check(plainLines *Lines)

+ func (ck *PlistChecker) Load(lines *Lines) []*PlistLine

+ type PlistContent struct

+ Conditions map[string]bool

+ Files map[RelPath]*PlistLine

+ UnconditionalDirs map[RelPath]*PlistLine

+ func NewPlistContent() PlistContent

+ type PlistLine struct

+ Line *Line

+ func (pline *PlistLine) Autofix() *Autofix

+ func (pline *PlistLine) CheckDirective(cmd, arg string)

+ func (pline *PlistLine) CheckTrailingWhitespace()

+ func (pline *PlistLine) Errorf(format string, args ...interface{})

+ func (pline *PlistLine) Explain(explanation ...string)

+ func (pline *PlistLine) HasPath() bool

+ func (pline *PlistLine) HasPlainPath() bool

+ func (pline *PlistLine) Path() RelPath

+ func (pline *PlistLine) RelLine(other *Line) string

+ func (pline *PlistLine) Warnf(format string, args ...interface{})

+ type PlistLines struct

+ func NewPlistLines() *PlistLines

+ func (pl *PlistLines) Add(line *PlistLine, rank *PlistRank)

+ type PlistRank struct

+ Arch string

+ Opsys string

+ Rank int

+ Rest string

+ func NewPlistRank(basename RelPath) *PlistRank

+ func (r *PlistRank) MoreGeneric(other *PlistRank) bool

+ type Project interface

+ Deprecated func(varname string) string

+ Types func() *VarTypeRegistry

+ type RawLine struct

+ func (rline *RawLine) Orig() string

+ type RedundantScope struct

+ IsRelevant func(mkline *MkLine) bool

+ func NewRedundantScope() *RedundantScope

+ func (s *RedundantScope) Check(mklines *MkLines)

+ type RelPath string

+ func MatchMkInclude(text string) (m bool, indentation, directive string, filename RelPath)

+ func NewRelPath(p Path) RelPath

+ func NewRelPathString(p string) RelPath

+ func (p RelPath) AsPath() Path

+ func (p RelPath) Base() RelPath

+ func (p RelPath) Clean() RelPath

+ func (p RelPath) CleanDot() RelPath

+ func (p RelPath) CleanPath() RelPath

+ func (p RelPath) ContainsPath(sub Path) bool

+ func (p RelPath) ContainsText(text string) bool

+ func (p RelPath) Count() int

+ func (p RelPath) Dir() RelPath

+ func (p RelPath) HasBase(base string) bool

+ func (p RelPath) HasPrefixPath(prefix Path) bool

+ func (p RelPath) HasPrefixText(prefix string) bool

+ func (p RelPath) HasSuffixPath(suffix Path) bool

+ func (p RelPath) HasSuffixText(suffix string) bool

+ func (p RelPath) IsEmpty() bool

+ func (p RelPath) JoinNoClean(other RelPath) RelPath

+ func (p RelPath) Parts() []string

+ func (p RelPath) Rel(other Path) RelPath

+ func (p RelPath) Replace(from string, to string) RelPath

+ func (p RelPath) Split() (RelPath, string)

+ func (p RelPath) String() string

+ type Scope struct

+ func NewScope() Scope

+ func (s *Scope) Commented(varname string) *MkLine

+ func (s *Scope) Define(varname string, mkline *MkLine)

+ func (s *Scope) DefineAll(other *Scope)

+ func (s *Scope) Fallback(varname string, value string)

+ func (s *Scope) FirstDefinition(varname string) *MkLine

+ func (s *Scope) FirstUse(varname string) *MkLine

+ func (s *Scope) IsDefined(varname string) bool

+ func (s *Scope) IsDefinedSimilar(varname string) bool

+ func (s *Scope) IsUsed(varname string) bool

+ func (s *Scope) IsUsedAtLoadTime(varname string) bool

+ func (s *Scope) IsUsedSimilar(varname string) bool

+ func (s *Scope) LastDefinition(varname string) *MkLine

+ func (s *Scope) LastValue(varname string) string

+ func (s *Scope) LastValueFound(varname string) (value string, found bool, indeterminate bool)

+ func (s *Scope) Mentioned(varname string) *MkLine

+ func (s *Scope) Use(varname string, mkline *MkLine, time VucTime)

+ type SeparatorWriter struct

+ func NewSeparatorWriter(out io.Writer) *SeparatorWriter

+ func (wr *SeparatorWriter) Flush()

+ func (wr *SeparatorWriter) Separate()

+ func (wr *SeparatorWriter) Write(text string)

+ func (wr *SeparatorWriter) WriteLine(text string)

+ type ShAtom struct

+ MkText string

+ Quoting ShQuoting

+ Type ShAtomType

+ func (atom *ShAtom) ShVarname() string

+ func (atom *ShAtom) String() string

+ func (atom *ShAtom) VarUse() *MkVarUse

+ type ShAtomType uint8

+ func (t ShAtomType) IsWord() bool

+ func (t ShAtomType) String() string

+ type ShQuoting uint8

+ func (q ShQuoting) String() string

+ func (q ShQuoting) ToVarUseContext() VucQuoting

+ type ShToken struct

+ Atoms []*ShAtom

+ MkText string

+ func NewShToken(mkText string, atoms ...*ShAtom) *ShToken

+ func (token *ShToken) String() string

+ type ShTokenizer struct

+ func NewShTokenizer(diag Autofixer, text string) *ShTokenizer

+ func (p *ShTokenizer) Rest() string

+ func (p *ShTokenizer) ShAtom(quoting ShQuoting) *ShAtom

+ func (p *ShTokenizer) ShAtoms() []*ShAtom

+ func (p *ShTokenizer) ShToken() *ShToken

+ type ShellLexer struct

+ func NewShellLexer(tokens []string, rest string) *ShellLexer

+ func (lex *ShellLexer) Error(s string)

+ func (lex *ShellLexer) Lex(lval *shyySymType) (ttype int)

+ type ShellLineChecker struct

+ MkLines *MkLines

+ func NewShellLineChecker(mklines *MkLines, mkline *MkLine) *ShellLineChecker

+ func (ck *ShellLineChecker) CheckShellCommand(shellcmd string, pSetE *bool, time ToolTime)

+ func (ck *ShellLineChecker) CheckShellCommandLine(shelltext string)

+ func (ck *ShellLineChecker) CheckShellCommands(shellcmds string, time ToolTime)

+ func (ck *ShellLineChecker) CheckWord(token string, checkQuoting bool, time ToolTime)

+ func (ck *ShellLineChecker) Explain(explanation ...string)

+ func (ck *ShellLineChecker) Warnf(format string, args ...interface{})

+ type SimpleCommandChecker struct

+ func NewSimpleCommandChecker(cmd *MkShSimpleCommand, time ToolTime, mkline *MkLine, mklines *MkLines) *SimpleCommandChecker

+ func (scc *SimpleCommandChecker) Check()

+ func (scc *SimpleCommandChecker) Errorf(format string, args ...interface{})

+ func (scc *SimpleCommandChecker) Explain(explanation ...string)

+ func (scc *SimpleCommandChecker) Notef(format string, args ...interface{})

+ func (scc *SimpleCommandChecker) Warnf(format string, args ...interface{})

+ type StrCommand struct

+ Args []string

+ Assignments []string

+ Name string

+ func NewStrCommand(cmd *MkShSimpleCommand) *StrCommand

+ func (c *StrCommand) AnyArgMatches(pattern regex.Pattern) bool

+ func (c *StrCommand) HasOption(opt string) bool

+ func (c *StrCommand) String() string

+ type StringInterner struct

+ func NewStringInterner() StringInterner

+ func (si *StringInterner) Intern(str string) string

+ type StringSet struct

+ Elements []string

+ func NewStringSet() StringSet

+ func (s *StringSet) Add(element string)

+ func (s *StringSet) AddAll(elements []string)

+ type SubstContext struct

+ func NewSubstContext(pkg *Package) *SubstContext

+ func (ctx *SubstContext) Finish(diag Diagnoser)

+ func (ctx *SubstContext) Process(mkline *MkLine)

+ type SuggestedUpdate struct

+ Comment string

+ Line Location

+ Pkgname string

+ Version string

+ type Tool struct

+ Aliases []string

+ MustUseVarForm bool

+ Name string

+ Validity Validity

+ Varname string

+ func (tool *Tool) String() string

+ func (tool *Tool) UsableAtLoadTime(seenPrefs bool) bool

+ func (tool *Tool) UsableAtRunTime() bool

+ type ToolTime uint8

+ const LoadTime

+ const RunTime

+ func (t ToolTime) String() string

+ type Tools struct

+ AliasOf map[string]string

+ SeenPrefs bool

+ func NewTools() *Tools

+ func (tr *Tools) ByName(name string) *Tool

+ func (tr *Tools) ByVarname(varname string) *Tool

+ func (tr *Tools) Define(name, varname string, mkline *MkLine) *Tool

+ func (tr *Tools) ExistsVar(varname string) bool

+ func (tr *Tools) Fallback(other *Tools)

+ func (tr *Tools) IsValidToolName(name string) bool

+ func (tr *Tools) ParseToolLine(mklines *MkLines, mkline *MkLine, fromInfrastructure bool, addToUseTools bool)

+ func (tr *Tools) Trace()

+ func (tr *Tools) Usable(tool *Tool, time ToolTime) bool

+ type Toplevel struct

+ type Validity uint8

+ const AfterPrefsMk

+ const AtRunTime

+ const Nowhere

+ func (time Validity) String() string

+ type Var struct

+ Name string

+ func NewVar(name string) *Var

+ func (v *Var) AddRef(varname string)

+ func (v *Var) ConditionalVars() []string

+ func (v *Var) ConstantValue() string

+ func (v *Var) IsConditional() bool

+ func (v *Var) IsConstant() bool

+ func (v *Var) Read(mkline *MkLine)

+ func (v *Var) ReadLocations() []*MkLine

+ func (v *Var) Refs() []string

+ func (v *Var) Value() string

+ func (v *Var) ValueInfra() string

+ func (v *Var) Write(mkline *MkLine, conditional bool, conditionVarnames ...string)

+ func (v *Var) WriteLocations() []*MkLine

+ type VarFact struct

+ Matches *makepat.Pattern

+ MkLine *MkLine

+ Text string

+ Varname string

+ type VarTypeRegistry struct

+ func NewVarTypeRegistry() VarTypeRegistry

+ func (reg *VarTypeRegistry) Canon(varname string) *Vartype

+ func (reg *VarTypeRegistry) Define(varname string, basicType *BasicType, options vartypeOptions, ...)

+ func (reg *VarTypeRegistry) DefineName(varname string, basicType *BasicType, options vartypeOptions, aclName string)

+ func (reg *VarTypeRegistry) DefineType(varcanon string, vartype *Vartype)

+ func (reg *VarTypeRegistry) Init(src *Pkgsrc)

+ func (reg *VarTypeRegistry) IsDefinedCanon(varname string) bool

+ func (reg *VarTypeRegistry) IsDefinedExact(varname string) bool

+ type VarUseContext struct

+ IsWordPart bool

+ func (vuc *VarUseContext) String() string

+ type VaralignBlock struct

+ func (va *VaralignBlock) Finish()

+ func (va *VaralignBlock) Process(mkline *MkLine)

+ type VaralignSplitter struct

+ func NewVaralignSplitter() VaralignSplitter

+ type VargroupsChecker struct

+ func NewVargroupsChecker(mklines *MkLines) *VargroupsChecker

+ func (ck *VargroupsChecker) Check(mkline *MkLine)

+ func (ck *VargroupsChecker) Finish()

+ type Vartype struct

+ func NewVartype(basicType *BasicType, options vartypeOptions, aclEntries ...ACLEntry) *Vartype

+ func (vt *Vartype) AlternativeFiles(perms ACLPermissions) string

+ func (vt *Vartype) EffectivePermissions(basename RelPath) ACLPermissions

+ func (vt *Vartype) IsAlwaysInScope() bool

+ func (vt *Vartype) IsCommandLineProvided() bool

+ func (vt *Vartype) IsDefinedIfInScope() bool

+ func (vt *Vartype) IsGuessed() bool

+ func (vt *Vartype) IsList() bool

+ func (vt *Vartype) IsNonemptyIfDefined() bool

+ func (vt *Vartype) IsOnePerLine() bool

+ func (vt *Vartype) IsPackageSettable() bool

+ func (vt *Vartype) IsShell() bool

+ func (vt *Vartype) IsSystemProvided() bool

+ func (vt *Vartype) IsUnique() bool

+ func (vt *Vartype) IsUserSettable() bool

+ func (vt *Vartype) MayBeAppendedTo() bool

+ func (vt *Vartype) NeedsRationale() bool

+ func (vt *Vartype) String() string

+ func (vt *Vartype) Union() ACLPermissions

+ type VartypeCheck struct

+ Guessed bool

+ MkComment string

+ MkLine *MkLine

+ MkLines *MkLines

+ Op MkOperator

+ Value string

+ ValueNoVar string

+ Varname string

+ func (cv *VartypeCheck) Autofix() *Autofix

+ func (cv *VartypeCheck) AwkCommand()

+ func (cv *VartypeCheck) BasicRegularExpression()

+ func (cv *VartypeCheck) BuildlinkDepmethod()

+ func (cv *VartypeCheck) CFlag()

+ func (cv *VartypeCheck) Category()

+ func (cv *VartypeCheck) Comment()

+ func (cv *VartypeCheck) ConfFiles()

+ func (cv *VartypeCheck) DependencyPattern()

+ func (cv *VartypeCheck) DependencyWithPath()

+ func (cv *VartypeCheck) DistSuffix()

+ func (cv *VartypeCheck) EmulPlatform()

+ func (cv *VartypeCheck) Enum(allowedValues map[string]bool, basicType *BasicType)

+ func (cv *VartypeCheck) Errorf(format string, args ...interface{})

+ func (cv *VartypeCheck) Explain(explanation ...string)

+ func (cv *VartypeCheck) FetchURL()

+ func (cv *VartypeCheck) FileMode()

+ func (cv *VartypeCheck) FilePattern()

+ func (cv *VartypeCheck) Filename()

+ func (cv *VartypeCheck) GccReqd()

+ func (cv *VartypeCheck) GitTag()

+ func (cv *VartypeCheck) GoModuleFile()

+ func (cv *VartypeCheck) Homepage()

+ func (cv *VartypeCheck) IdentifierDirect()

+ func (cv *VartypeCheck) IdentifierIndirect()

+ func (cv *VartypeCheck) Integer()

+ func (cv *VartypeCheck) LdFlag()

+ func (cv *VartypeCheck) License()

+ func (cv *VartypeCheck) MachineGnuPlatform()

+ func (cv *VartypeCheck) MachinePlatform()

+ func (cv *VartypeCheck) MachinePlatformPattern()

+ func (cv *VartypeCheck) MailAddress()

+ func (cv *VartypeCheck) MakeTarget()

+ func (cv *VartypeCheck) Message()

+ func (cv *VartypeCheck) Notef(format string, args ...interface{})

+ func (cv *VartypeCheck) Option()

+ func (cv *VartypeCheck) PathPattern()

+ func (cv *VartypeCheck) Pathlist()

+ func (cv *VartypeCheck) Pathname()

+ func (cv *VartypeCheck) PathnameSpace()

+ func (cv *VartypeCheck) Perl5Packlist()

+ func (cv *VartypeCheck) Perms()

+ func (cv *VartypeCheck) PkgOptionsVar()

+ func (cv *VartypeCheck) Pkgname()

+ func (cv *VartypeCheck) Pkgpath()

+ func (cv *VartypeCheck) Pkgrevision()

+ func (cv *VartypeCheck) PlistIdentifier()

+ func (cv *VartypeCheck) PrefixPathname()

+ func (cv *VartypeCheck) PythonDependency()

+ func (cv *VartypeCheck) RPkgName()

+ func (cv *VartypeCheck) RPkgVer()

+ func (cv *VartypeCheck) RelativePkgDir()

+ func (cv *VartypeCheck) RelativePkgPath()

+ func (cv *VartypeCheck) Restricted()

+ func (cv *VartypeCheck) SedCommands()

+ func (cv *VartypeCheck) ShellCommand()

+ func (cv *VartypeCheck) ShellCommands()

+ func (cv *VartypeCheck) ShellWord()

+ func (cv *VartypeCheck) Stage()

+ func (cv *VartypeCheck) ToolDependency()

+ func (cv *VartypeCheck) ToolName()

+ func (cv *VartypeCheck) URL()

+ func (cv *VartypeCheck) Unknown()

+ func (cv *VartypeCheck) UserGroupName()

+ func (cv *VartypeCheck) VariableName()

+ func (cv *VartypeCheck) VariableNamePattern()

+ func (cv *VartypeCheck) Version()

+ func (cv *VartypeCheck) Warnf(format string, args ...interface{})

+ func (cv *VartypeCheck) WithValue(value string) *VartypeCheck

+ func (cv *VartypeCheck) WithVarnameValue(varname, value string) *VartypeCheck

+ func (cv *VartypeCheck) WithVarnameValueMatch(varname, value string) *VartypeCheck

+ func (cv *VartypeCheck) WrapperReorder()

+ func (cv *VartypeCheck) WrapperTransform()

+ func (cv *VartypeCheck) WrkdirSubdirectory()

+ func (cv *VartypeCheck) WrksrcPathPattern()

+ func (cv *VartypeCheck) WrksrcSubdirectory()

+ func (cv *VartypeCheck) Yes()

+ func (cv *VartypeCheck) YesNo()

+ func (cv *VartypeCheck) YesNoIndirectly()

+ type VucQuoting uint8

+ const VucQuotBackt

+ const VucQuotDquot

+ const VucQuotPlain

+ const VucQuotSquot

+ const VucQuotUnknown

+ func (q VucQuoting) String() string

+ type VucTime uint8

+ const VucLoadTime

+ const VucRunTime

+ const VucUnknownTime

+ func (t VucTime) String() string

+ type YesNoUnknown uint8

+ func (ynu YesNoUnknown) String() string

Other modules containing this package

github.com/rillig/pkglint