core

package
v0.0.0-...-c3cb3ef Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 22, 2024 License: Apache-2.0 Imports: 38 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ToolchainModuleMap = mapper.New() // Global lookup for toolchain names

Functions

func AndroidBpFile 

func AndroidBpFile() bpwriter.File

Provides access to the global instance of the Android.bp file writer

func AppendMatchingProperties 

func AppendMatchingProperties(dst []interface{}, src interface{}) error

func AppendProperties 

func AppendProperties(dst interface{}, src interface{}) error

func ApplyTemplate 

func ApplyTemplate(props interface{}, properties *config.Properties)

ApplyTemplate writes configuration values (from properties) into the string properties in props. This is done recursively.

func DefaultApplierMutator 

func DefaultApplierMutator(ctx blueprint.BottomUpMutatorContext)

Applies default options

func DefaultDepsStage1Mutator 

func DefaultDepsStage1Mutator(ctx blueprint.BottomUpMutatorContext)

Locally store defaults in defaultsMap

func DefaultDepsStage2Mutator 

func DefaultDepsStage2Mutator(ctx blueprint.BottomUpMutatorContext)

Adds dependency links for defaults to all modules (but not defaults modules). Rather than creating a dependency hierarchy, flatten the hierarchy for each module. This allows us to remove duplication of defaults modules, while respecting ordering of defaults specified on each module, and between hierarchies. Without flattening the hierarchy we would need more control over the module visitation order in WalkDeps.

func GetGeneratedHeadersFiles 

func GetGeneratedHeadersFiles(ctx blueprint.ModuleContext) (orderOnly []string)

func GetLogger 

func GetLogger() *warnings.WarningLogger

func GetWholeStaticLibs 

func GetWholeStaticLibs(ctx blueprint.ModuleContext) []string

Returns the whole static dependencies for a library.

func LibraryFactory 

func LibraryFactory(config *BobConfig) (blueprint.Module, []interface{})

func Main 

func Main()

Main is the entry point for the bob primary builder.

It loads the configuration from .bob.config.json, registers the module type and mutators, initializes the backend, and finally calls into Blueprint.

func MetaDataWriteToFile 

func MetaDataWriteToFile(file string)

Writes the metadata to specified file if the path is set.

func ModuleToolchainFactory 

func ModuleToolchainFactory(config *BobConfig) (blueprint.Module, []interface{})

func PrependMatchingProperties 

func PrependMatchingProperties(dst []interface{}, src interface{}) error

func PrependProperties 

func PrependProperties(dst interface{}, src interface{}) error

func RegisterModuleTypes 

func RegisterModuleTypes(register func(string, FactoryWithConfig))

func RegisterToolchainModules 

func RegisterToolchainModules(ctx blueprint.EarlyMutatorContext)

func ResolveGenericDepsMutator 

func ResolveGenericDepsMutator(ctx blueprint.BottomUpMutatorContext)

func SetupLogger 

func SetupLogger(env *config.EnvironmentVariables)

func StrictBinaryFactory 

func StrictBinaryFactory(config *BobConfig) (blueprint.Module, []interface{})

func TearDownLogger 

func TearDownLogger()

Types

type AliasProps 

type AliasProps struct {
	// Modules that this alias will cause to build
	Srcs []string
	AliasableProps
}

AliasProps describes the properties of the bob_alias module

type AliasableProps 

type AliasableProps struct {
	// Adds this module to an alias
	Add_to_alias []string
}

AliasableProps are embedded in modules which can be aliased

type AndroidMTEProps 

type AndroidMTEProps struct {
	Mte struct {
		Memtag_heap      *bool
		Diag_memtag_heap *bool
	}
}

AndroidMTEProps defines properties used to enable the Arm Memory Tagging Extension

type AndroidPGOProps 

type AndroidPGOProps struct {
	Pgo struct {
		Benchmarks         []string
		Profile_file       *string
		Enable_profile_use *bool
		Cflags             []string
	}
}

AndroidPGOProps defines properties used to support profile-guided optimization.

type AndroidProps 

type AndroidProps struct {
	// Values to use on Android for LOCAL_MODULE_TAGS, defining which builds this module is built for
	Tags []string
	// Value to use on Android for LOCAL_MODULE_OWNER
	Owner *string
}

AndroidProps defines module properties used by Android backends

type Archivable 

type Archivable interface {
	flag.Consumer // Modules which are compilable need to support flags
	file.Consumer // Compilable objects must match the file consumer interface
	BackendConfigurationProvider
	// contains filtered or unexported methods
}

type BackendCommonLibraryInterface 

type BackendCommonLibraryInterface interface {
	flag.Consumer

	// Legacy functions which need a better interface
	IsForwardingSharedLibrary() bool
	IsRpathWanted() bool
	BackendConfigurationProvider
	// contains filtered or unexported methods
}

Temporary interface to make library handlers generic between legacy and strict libraries

type BackendCommonSharedLibraryInterface 

type BackendCommonSharedLibraryInterface interface {
	BackendCommonLibraryInterface
	// contains filtered or unexported methods
}

type BackendConfiguration 

type BackendConfiguration interface {
	GetBuildWrapperAndDeps(blueprint.ModuleContext) (string, []string)
	GetMteProps(blueprint.ModuleContext) AndroidMTEProps
	IsHwAsanEnabled() bool
	// contains filtered or unexported methods
}

func GetModuleBackendConfiguration 

func GetModuleBackendConfiguration(ctx blueprint.ModuleContext, m BackendConfigurationProvider) BackendConfiguration

type BackendConfigurationProvider 

type BackendConfigurationProvider interface {
	GetBackendConfiguration(blueprint.ModuleContext) BackendConfiguration
}

This interface provides configuration features

type BobConfig 

type BobConfig struct {
	Generator  generatorBackend
	Properties config.Properties
}

The `BobConfig` type is stored against the Blueprint context, and allows us to retrieve the backend and configuration values from within Blueprint callbacks.

type Build 

type Build struct {
	CommonProps
	BuildProps
	Target TargetSpecific
	Host   TargetSpecific
	SplittableProps
}

A Build represents the whole tree of properties for a 'library' object, including its host and target-specific properties

func (*Build) GetBuildWrapperAndDeps 

func (b *Build) GetBuildWrapperAndDeps(ctx blueprint.ModuleContext) (string, []string)

type BuildMeta 

type BuildMeta map[string]ModuleMeta

Map of metadata keyed by module name.

type BuildProps 

type BuildProps struct {
	// Alternate output name, used for the file name and Android rules
	Out *string
	// Flags exported for dependent modules
	Export_cflags []string
	// Flags used for C compilation
	Conlyflags []string
	// Flags used for C++ compilation
	Cxxflags []string
	// Flags used for assembly compilation
	Asflags []string
	// Flags used for linking
	Ldflags []string
	// Same as ldflags, but specified on static libraries and propagated to
	// the top-level build object.
	Export_ldflags []string
	// Shared library version
	Library_version string
	// Shared library version script
	Version_script *string

	// The list of shared lib modules that this library depends on.
	// These are propagated to the closest linking object when specified on static libraries.
	// shared_libs is an indication that this module is using a shared library, and
	// users of this module need to link against it.
	Shared_libs []string `bob:"first_overrides"`
	// The libraries mentioned here will be appended to shared_libs of the modules that use
	// this library (via static_libs, whole_static_libs or shared_libs).
	ExtraSharedLibs []string `blueprint:"mutated"`

	// The list of static lib modules that this library depends on
	// These are propagated to the closest linking object when specified on static libraries.
	// static_libs is an indication that this module is using a static library, and
	// users of this module need to link against it.
	Static_libs []string `bob:"first_overrides"`

	// This list of dependencies that exported cflags and exported include dirs
	// should be propagated 1-level higher
	Reexport_libs []string `bob:"first_overrides"`
	// Internal property for collecting libraries with reexported flags and include paths
	ResolvedReexportedLibs []string `blueprint:"mutated"`
	// Same as above except for generated header providers which are not target variant aware and hence cannot
	// re use the same tagging.
	ResolvedGeneratedHeaders []string `blueprint:"mutated"`

	ResolvedStaticLibs []string `blueprint:"mutated"`

	// The list of whole static libraries that this library depnds on
	// This will include all the objects in the library (as opposed to normal static linking)
	// If this is set for a static library, any shared library will also include objects
	// from dependent libraries
	Whole_static_libs []string `bob:"first_overrides"`

	// List of libraries to import headers from, but not link to
	Header_libs []string `bob:"first_overrides"`

	// List of libraries that users of the current library should import
	// headers from, but not link to
	Export_header_libs []string `bob:"first_overrides"`

	// Linker flags required to link to the necessary system libraries
	// These are propagated to the closest linking object when specified on static libraries.
	Ldlibs []string `bob:"first_overrides"`

	// The list of modules that generate extra headers for this module
	Generated_headers []string `bob:"first_overrides"`

	// The list of modules that generate extra headers for this module,
	// which should be made available to linking modules
	Export_generated_headers []string `bob:"first_overrides"`

	// The list of modules that generate extra source files for this module
	Generated_sources []string

	// The list of modules that generate output required by the build wrapper
	Generated_deps []string

	// Include local dirs to be exported into dependent.
	// The system variant will propagate includes using `-isystem`, but use `-I` for
	// current module.
	Export_local_include_dirs        []string `bob:"first_overrides"`
	Export_local_system_include_dirs []string `bob:"first_overrides"`

	// Include dirs (path relative to root) to be exported into dependent.
	// The system variant will propagate includes using `-isystem`, but use `-I` for
	// current module.
	Export_include_dirs        []string `bob:"first_overrides"`
	Export_system_include_dirs []string `bob:"first_overrides"`

	// Wrapper for all build commands (object file compilation *and* linking)
	Build_wrapper *string

	// Adds DT_RPATH symbol to binaries and shared libraries so that they can find
	// their dependencies at runtime.
	Add_lib_dirs_to_rpath *bool

	// This is a shared library that pulls in one or more shared
	// libraries to resolve symbols that the binary needs. This is
	// useful where a named library is the standard library to link
	// against, but the implementation may exist in another
	// library.
	//
	// Only valid on bob_shared_library.
	//
	// Currently we need to link with -Wl,--copy-dt-needed-entries.
	// This makes the binary depend on the implementation library, and
	// requires the BFD linker.
	Forwarding_shlib *bool

	StripProps
	AndroidPGOProps
	AndroidMTEProps

	Hwasan_enabled *bool

	TargetType toolchain.TgtType `blueprint:"mutated"`
}

BuildProps contains properties required by all modules that compile C/C++

type CommonProps 

type CommonProps struct {
	LegacySourceProps
	IncludeDirsProps
	InstallableProps
	EnableableProps
	AndroidProps
	AliasableProps

	// Flags used for C compilation
	Cflags []string
}

CommonProps defines a set of properties which are common for multiple module types.

type Compilable 

type Compilable interface {
	flag.Consumer // Modules which are compilable need to support flags
	flag.Provider // Required for AOSP backend to check for exported flags

	file.Consumer // Compilable objects must match the file consumer interface

	BackendConfigurationProvider
	// contains filtered or unexported methods
}

type EnableableProps 

type EnableableProps struct {
	// Used to disable the generation of build rules. If this is set to false, no build rule will be generated.
	Enabled *bool
	// Whether it is built by default in a build with no targets requested.
	// Nothing to do with 'defaults'.
	Build_by_default *bool
	// Is this module depended on by a module which is built by default?
	// Used to prune unused modules from Android builds, where we can't
	// control exactly what gets built.
	Required bool `blueprint:"mutated"`
}

EnableableProps allow a module to be disabled or only built when explicitly requested

type ExternalLibProps 

type ExternalLibProps struct {
	Export_cflags  []string
	Export_ldflags []string
	Ldlibs         []string

	TargetType toolchain.TgtType `blueprint:"mutated"`
}

type FactoryWithConfig 

type FactoryWithConfig func(*BobConfig) (blueprint.Module, []interface{})

type Featurable 

type Featurable interface {
	FeaturableProperties() []interface{}
	Features() *Features
}

Modules implementing featurable support the use of features and templates.

type Features 

type Features struct {
	// 'BlueprintEmbed' is a special case in Blueprint which makes it interpret
	// a runtime-generated type as being embedded in its parent struct.
	BlueprintEmbed interface{}
}

Features must be embedded in each modules property structure to support the use of features in the module. The feature must be initialised with a call to Init().

func (*Features) AppendProps 

func (f *Features) AppendProps(dst []interface{}, properties *config.Properties) error

AppendProps merges properties from BlueprintEmbed to dst, but only for enabled features expect that Features are inited (before using this function we should call Features.Init) expect that properties.Features should contain all available features (whenever disabled/enabled)

func (*Features) DeInit 

func (f *Features) DeInit()

Set internal `BlueprintEmbed` field to nil.

Use it carefully as features won't be available anymore.

func (*Features) Init 

func (f *Features) Init(properties *config.Properties, list ...interface{})

Init generates and initializes a struct containing a field of type 'propsType' for every available feature. 'propsType' will be constructed from list of types. By constructed we mean properties of each type will be merged together. It is important to set here every available feature not only enabled ones, because blueprint will fail during reading .bp files. The generated object is embedded in each module types' properties instance, and is used by Blueprint to decide what properties can be set inside features in each module type.

An example generated type: 

type BlueprintEmbedType struct {
        Debug PropsType
        Enable_something PropsType
        Some_other_feature PropsType
}

Name of each property in this struct is custom feature name. Blueprint will inflate this structure with data read from .bp files. Only exported properties can be set so property name MUST start from capital letter.

type GenerateLibraryProps 

type GenerateLibraryProps struct {
	// List of headers that are created (if any)
	Headers []string

	// Alternate output name, used for the file name and Android rules
	Out *string

	// List of implicit sources. Implicit sources are input files that do not get
	// mentioned on the command line, and are not specified in the explicit sources.
	Implicit_srcs []string

	// Implicit source files that should not be included. Use with care.
	Exclude_implicit_srcs []string
}

GenerateLibraryProps contain the properties that are specific to generating libraries

type GenerateProps 

type GenerateProps struct {
	LegacySourceProps
	AliasableProps
	EnableableProps
	InstallableProps

	/* The command that is to be run for this source generation.
	 * Substitutions can be made in the command, by using $name_of_var. A list of substitutions that can be used:
	 * $gen_dir      - the path to the directory which belongs to this source generator
	 * $in           - the path to the sources - space-delimited
	 * $out          - the path to the targets - space-delimited
	 * $depfile      - the path to generated dependency file
	 * $args         - the value of "args" - space-delimited
	 * $tool         - the path to the tool
	 * $tool <label> - the path to the tool with name <label>
	 * $host_bin     - the path to the binary that is produced by the host_bin module
	 * $(dep)_out    - the outputs of the generated_dep `dep`
	 * $src_dir      - the path to the project source directory - this will be different than the build source directory
	 *                 for Android.
	 * $module_dir   - the path to the module directory */
	Cmd *string

	// A paths to the tool that are to be used in cmd. If $tool is in the command variable, then this will be replaced
	// with the path to this tool. ${tool} refers to the first tool in a list. To reference
	// other tool use index syntax ${tool <label>} (e.g. ${tool fixer.py} for `fixer.py` tool from list).
	Tools []string

	// Adds a dependency on a binary with `host_supported: true` which is used by this module.
	// The path can be referenced in cmd as ${host_bin}.
	Host_bin *string

	// Values to use on Android for LOCAL_MODULE_TAGS, defining which builds this module is built for
	// TODO: Hide this in Android-specific properties
	Tags []string

	// A list of other modules that this generator depends on. The dependencies can be used in the command through
	// $name_of_dependency_dir .
	Generated_deps []string

	// A list of other modules that this generator depends on. The dependencies will be add to the list of srcs
	Generated_sources []string

	// A list of args that will be spaceseparated and add to the cmd
	Args []string

	// Used to indicate that the console should be used.
	Console *bool

	// A list of source modules that this bob_generated_source will encapsulate.
	// When this module is used with generated_headers, the named modules' export_gen_include_dirs will be forwarded.
	// When this module is used with generated_sources, the named modules' outputs will be supplied as sources.
	Encapsulates []string

	// Additional include paths to add for modules that use generate_headers.
	// This will be defined relative to the module-specific build directory
	Export_gen_include_dirs []string

	// The defaults used to retrieve cflags
	Flag_defaults []string

	// The target type - must be either "host" or "target"
	Target toolchain.TgtType

	// If true, depfile name will be generated and can be used as ${depfile} reference in 'cmd'
	Depfile *bool

	// If set, Ninja will expand the string and write it to a file just
	// before executing the command. This can be used to e.g. contain ${in},
	// in cases where the command line length is a limiting factor.
	Rsp_content *string
}

GenerateProps contains the module properties that allow generation of output from arbitrary commands

type GenerateSourceProps 

type GenerateSourceProps struct {
	// The list of files that will be output.
	Out []string
	// List of implicit sources. Implicit sources are input files that do not get
	// mentioned on the command line, and are not specified in the explicit sources.
	Implicit_srcs []string
	// Implicit source files that should not be included. Use with care.
	Exclude_implicit_srcs []string

	ResolvedOut file.Paths `blueprint:"mutated"`
}

GenerateSourceProps are properties of 'bob_generate_source', i.e. a module type which can generate sources using a single execution The command will be run once - with $in being the paths in "srcs" and $out being the paths in "out". The working directory will be the source directory, and all paths will be relative to the source directory if not else noted.

type GenruleProps 

type GenruleProps struct {
	Out         []string
	ResolvedOut file.Paths `blueprint:"mutated"`
}

type GensrcsProps 

type GensrcsProps struct {
	Output_extension string
	ResolvedOut      file.Paths `blueprint:"mutated"`
}

type GlobProps 

type GlobProps struct {
	// Path patterns that are relative to the current module
	Srcs []string

	// Path patterns that are relative to the current module to exclude from `Srcs`
	Exclude []string

	// Omitted directories from the `Files` result
	Exclude_directories *bool // Currently no supported.

	// Error-out if the result `Files` is empty
	Allow_empty *bool

	// Found module sources
	Files file.Paths `blueprint:"mutated"`
}

type IncludeDirsProps 

type IncludeDirsProps struct {
	// The list of include dirs to use that is relative to the source directory
	Include_dirs []string `bob:"first_overrides"`

	// The list of include dirs to use that is relative to the build.bp file
	// These use relative instead of absolute paths
	Local_include_dirs []string `bob:"first_overrides"`
}

IncludeDirsProps defines a set of properties for including directories by the module.

type IncludeProps 

type IncludeProps struct {
	Includes []string
}

List of include dirs to be added to the compile line.

Each string is prepended with `-I` when building the target itself and `-isystem` when building modules who consumes it. Unlike `Copts`, these flags are added for this rule and every rule that depends on it.

type InstallGroupProps 

type InstallGroupProps struct {
	Install_path *string
}

InstallGroupProps describes the properties of bob_install_group modules

type InstallableProps 

type InstallableProps struct {
	// Module specifying an installation directory
	Install_group *string
	// Other modules which must be installed alongside this
	Install_deps []string
	// Path to install to, relative to the install_group's path
	Relative_install_path *string
	// Script used during post install
	Post_install_tool *string
	// Command to execute on file(s) after they are installed
	Post_install_cmd *string
	// Arguments to post install command
	Post_install_args []string
	// The path retrieved from the install group so we don't need to walk dependencies to get it
	InstallGroupPath *string `blueprint:"mutated"`
}

InstallableProps are embedded by modules which can be installed outside the build directory

type KernelProps 

type KernelProps struct {
	// Linux kernel config options to emulate. These are passed to Kbuild in
	// the 'make' command-line, and set in the source code via EXTRA_CFLAGS
	Kbuild_options []string
	// Kernel modules which this module depends on
	Extra_symbols []string
	// Arguments to pass to kernel make invocation
	Make_args []string
	// Kernel directory location
	Kernel_dir *string
	// Compiler prefix for kernel build
	Kernel_cross_compile *string
	// Kernel target compiler
	Kernel_cc *string
	// Kernel host compiler
	Kernel_hostcc *string
	// Kernel linker
	Kernel_ld *string
	// Target triple when using clang as the compiler
	Kernel_clang_triple *string
}

type LegacySourceProps 

type LegacySourceProps struct {
	// The list of source files. Wildcards can be used (but are suboptimal)
	Srcs []string
	// The list of source files that should not be included. Use with care.
	Exclude_srcs []string
	// A list of filegroup modules that provide srcs, these are directly added to Srcs.
	// We do not currently re-use Srcs for this
	Filegroup_srcs []string

	ResolvedSrcs file.Paths `blueprint:"mutated"` // Glob results.
}

LegacySourceProps defines module properties that are used to identify the source files associated with a module. These are used for legacy targets, new targets should use `SourceProps` where possible.

func (*LegacySourceProps) GetDirectFiles 

func (s *LegacySourceProps) GetDirectFiles() file.Paths

func (*LegacySourceProps) GetFiles 

func (s *LegacySourceProps) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (*LegacySourceProps) GetTargets 

func (s *LegacySourceProps) GetTargets() []string

func (*LegacySourceProps) ResolveFiles 

func (s *LegacySourceProps) ResolveFiles(ctx blueprint.BaseModuleContext)

type LegacySourcePropsInterface 

type LegacySourcePropsInterface interface {
	file.Consumer
	file.Resolver
	// contains filtered or unexported methods
}

All interfaces supported by LegacySourceProps

type ModuleAlias 

type ModuleAlias struct {
	module.ModuleBase
	Properties struct {
		AliasProps
		Features
	}
}

Type representing each bob_alias module

func (*ModuleAlias) FeaturableProperties 

func (m *ModuleAlias) FeaturableProperties() []interface{}

func (*ModuleAlias) Features 

func (m *ModuleAlias) Features() *Features

func (*ModuleAlias) GenerateBuildActions 

func (m *ModuleAlias) GenerateBuildActions(ctx blueprint.ModuleContext)

Called by Blueprint to generate the rules associated with the alias. This is forwarded to the backend to handle.

func (ModuleAlias) GetProperties 

func (m ModuleAlias) GetProperties() interface{}

type ModuleBinary 

type ModuleBinary struct {
	ModuleLibrary
}

func (*ModuleBinary) GenerateBuildActions 

func (m *ModuleBinary) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleBinary) GetBackendConfiguration 

func (m *ModuleBinary) GetBackendConfiguration(ctx blueprint.ModuleContext) BackendConfiguration

func (ModuleBinary) GetProperties 

func (m ModuleBinary) GetProperties() interface{}

func (*ModuleBinary) OutFileTargets 

func (m *ModuleBinary) OutFileTargets() (tgts []string)

func (*ModuleBinary) OutFiles 

func (m *ModuleBinary) OutFiles() (srcs file.Paths)

type ModuleDefaults 

type ModuleDefaults struct {
	module.ModuleBase

	Properties struct {
		Features
		Build
		KernelProps
		TagableProps
		// The list of default properties that should prepended to all configuration
		Defaults []string
	}
}

func (*ModuleDefaults) FeaturableProperties 

func (m *ModuleDefaults) FeaturableProperties() []interface{}

func (*ModuleDefaults) Features 

func (m *ModuleDefaults) Features() *Features

func (*ModuleDefaults) GenerateBuildActions 

func (m *ModuleDefaults) GenerateBuildActions(ctx blueprint.ModuleContext)

func (ModuleDefaults) GetProperties 

func (m ModuleDefaults) GetProperties() interface{}

type ModuleExternalLibrary 

type ModuleExternalLibrary struct {
	module.ModuleBase
	Properties struct {
		ExternalLibProps
		TagableProps
		Features
	}
}

func (*ModuleExternalLibrary) FeaturableProperties 

func (m *ModuleExternalLibrary) FeaturableProperties() []interface{}

func (*ModuleExternalLibrary) Features 

func (m *ModuleExternalLibrary) Features() *Features

func (*ModuleExternalLibrary) FlagsIn 

func (m *ModuleExternalLibrary) FlagsIn() flag.Flags

func (*ModuleExternalLibrary) FlagsInTransitive 

func (m *ModuleExternalLibrary) FlagsInTransitive(ctx blueprint.BaseModuleContext) (ret flag.Flags)

func (*ModuleExternalLibrary) FlagsOut 

func (m *ModuleExternalLibrary) FlagsOut() flag.Flags

func (*ModuleExternalLibrary) GenerateBuildActions 

func (m *ModuleExternalLibrary) GenerateBuildActions(ctx blueprint.ModuleContext)

External libraries have no actions - they are already built.

func (ModuleExternalLibrary) GetProperties 

func (m ModuleExternalLibrary) GetProperties() interface{}

type ModuleFilegroup 

type ModuleFilegroup struct {
	module.ModuleBase
	Properties struct {
		SourceProps
		TagableProps
		Features
		EnableableProps
	}
}

func (*ModuleFilegroup) FeaturableProperties 

func (m *ModuleFilegroup) FeaturableProperties() []interface{}

func (*ModuleFilegroup) Features 

func (m *ModuleFilegroup) Features() *Features

func (*ModuleFilegroup) GenerateBuildActions 

func (m *ModuleFilegroup) GenerateBuildActions(ctx blueprint.ModuleContext)

func (ModuleFilegroup) GetProperties 

func (m ModuleFilegroup) GetProperties() interface{}

func (*ModuleFilegroup) GetTags 

func (m *ModuleFilegroup) GetTags() []string

func (*ModuleFilegroup) GetTagsRegex 

func (m *ModuleFilegroup) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleFilegroup) HasTag 

func (m *ModuleFilegroup) HasTag(query string) bool

func (*ModuleFilegroup) HasTagRegex 

func (m *ModuleFilegroup) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleFilegroup) OutFileTargets 

func (m *ModuleFilegroup) OutFileTargets() []string

func (*ModuleFilegroup) OutFiles 

func (m *ModuleFilegroup) OutFiles() file.Paths

func (*ModuleFilegroup) ResolveFiles 

func (m *ModuleFilegroup) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleGenerateCommon 

type ModuleGenerateCommon struct {
	module.ModuleBase
	Properties struct {
		GenerateProps
		Features
		FlagArgsBuild Build `blueprint:"mutated"`
	}
	// contains filtered or unexported fields
}

func (*ModuleGenerateCommon) FeaturableProperties 

func (m *ModuleGenerateCommon) FeaturableProperties() []interface{}

func (*ModuleGenerateCommon) Features 

func (m *ModuleGenerateCommon) Features() *Features

func (*ModuleGenerateCommon) OutFiles 

func (m *ModuleGenerateCommon) OutFiles() (files file.Paths)

func (*ModuleGenerateCommon) ResolveFiles 

func (m *ModuleGenerateCommon) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleGenerateSource 

type ModuleGenerateSource struct {
	ModuleGenerateCommon
	Properties struct {
		GenerateSourceProps
	}
}

func (*ModuleGenerateSource) FeaturableProperties 

func (m *ModuleGenerateSource) FeaturableProperties() []interface{}

func (*ModuleGenerateSource) FlagsOut 

func (m *ModuleGenerateSource) FlagsOut() (flags flag.Flags)

func (*ModuleGenerateSource) GenerateBuildActions 

func (m *ModuleGenerateSource) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleGenerateSource) GetDirectFiles 

func (m *ModuleGenerateSource) GetDirectFiles() file.Paths

func (*ModuleGenerateSource) GetFiles 

func (m *ModuleGenerateSource) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (ModuleGenerateSource) GetProperties 

func (m ModuleGenerateSource) GetProperties() interface{}

func (*ModuleGenerateSource) GetTargets 

func (m *ModuleGenerateSource) GetTargets() (tgts []string)

func (*ModuleGenerateSource) OutFileTargets 

func (m *ModuleGenerateSource) OutFileTargets() []string

func (*ModuleGenerateSource) OutFiles 

func (m *ModuleGenerateSource) OutFiles() file.Paths

func (*ModuleGenerateSource) ResolveFiles 

func (m *ModuleGenerateSource) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleGenrule 

type ModuleGenrule struct {
	ModuleStrictGenerateCommon
	Properties struct {
		GenruleProps
	}
}

func (*ModuleGenrule) FeaturableProperties 

func (m *ModuleGenrule) FeaturableProperties() []interface{}

func (*ModuleGenrule) FlagsOut 

func (m *ModuleGenrule) FlagsOut() (flags flag.Flags)

func (*ModuleGenrule) GenerateBuildActions 

func (m *ModuleGenrule) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleGenrule) GetDirectFiles 

func (m *ModuleGenrule) GetDirectFiles() file.Paths

func (*ModuleGenrule) GetFiles 

func (m *ModuleGenrule) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (ModuleGenrule) GetProperties 

func (m ModuleGenrule) GetProperties() interface{}

func (*ModuleGenrule) GetTags 

func (m *ModuleGenrule) GetTags() []string

func (*ModuleGenrule) GetTagsRegex 

func (m *ModuleGenrule) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleGenrule) GetTargets 

func (m *ModuleGenrule) GetTargets() []string

func (*ModuleGenrule) HasTag 

func (m *ModuleGenrule) HasTag(query string) bool

func (*ModuleGenrule) HasTagRegex 

func (m *ModuleGenrule) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleGenrule) OutFileTargets 

func (m *ModuleGenrule) OutFileTargets() (tgts []string)

func (*ModuleGenrule) OutFiles 

func (m *ModuleGenrule) OutFiles() file.Paths

func (*ModuleGenrule) ResolveFiles 

func (m *ModuleGenrule) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleGenruleInterface 

type ModuleGenruleInterface interface {
	file.Consumer
	file.Resolver

	Tagable
	// contains filtered or unexported methods
}

type ModuleGensrcs 

type ModuleGensrcs struct {
	ModuleStrictGenerateCommon
	Properties struct {
		GensrcsProps
	}
}

func (*ModuleGensrcs) FeaturableProperties 

func (m *ModuleGensrcs) FeaturableProperties() []interface{}

func (*ModuleGensrcs) FlagsOut 

func (m *ModuleGensrcs) FlagsOut() (flags flag.Flags)

func (*ModuleGensrcs) GenerateBuildActions 

func (m *ModuleGensrcs) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleGensrcs) GetDirectFiles 

func (m *ModuleGensrcs) GetDirectFiles() file.Paths

func (*ModuleGensrcs) GetFiles 

func (m *ModuleGensrcs) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (ModuleGensrcs) GetProperties 

func (m ModuleGensrcs) GetProperties() interface{}

func (*ModuleGensrcs) GetTags 

func (m *ModuleGensrcs) GetTags() []string

func (*ModuleGensrcs) GetTagsRegex 

func (m *ModuleGensrcs) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleGensrcs) GetTargets 

func (m *ModuleGensrcs) GetTargets() []string

func (*ModuleGensrcs) HasTag 

func (m *ModuleGensrcs) HasTag(query string) bool

func (*ModuleGensrcs) HasTagRegex 

func (m *ModuleGensrcs) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleGensrcs) OutFileTargets 

func (m *ModuleGensrcs) OutFileTargets() (tgts []string)

func (*ModuleGensrcs) OutFiles 

func (m *ModuleGensrcs) OutFiles() file.Paths

func (*ModuleGensrcs) ResolveFiles 

func (m *ModuleGensrcs) ResolveFiles(ctx blueprint.BaseModuleContext)

func (*ModuleGensrcs) ResolveOutFiles 

func (m *ModuleGensrcs) ResolveOutFiles(ctx blueprint.BaseModuleContext)

type ModuleGensrcsInterface 

type ModuleGensrcsInterface interface {
	file.Consumer
	file.Resolver

	Tagable
	// contains filtered or unexported methods
}

type ModuleGlob 

type ModuleGlob struct {
	module.ModuleBase
	Properties struct {
		GlobProps
		TagableProps
	}
}

func (*ModuleGlob) GenerateBuildActions 

func (m *ModuleGlob) GenerateBuildActions(ctx blueprint.ModuleContext)

func (ModuleGlob) GetProperties 

func (m ModuleGlob) GetProperties() interface{}

func (*ModuleGlob) GetTags 

func (m *ModuleGlob) GetTags() []string

func (*ModuleGlob) GetTagsRegex 

func (m *ModuleGlob) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleGlob) HasTag 

func (m *ModuleGlob) HasTag(query string) bool

func (*ModuleGlob) HasTagRegex 

func (m *ModuleGlob) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleGlob) OutFileTargets 

func (m *ModuleGlob) OutFileTargets() (tgts []string)

func (*ModuleGlob) OutFiles 

func (m *ModuleGlob) OutFiles() file.Paths

func (*ModuleGlob) ResolveFiles 

func (m *ModuleGlob) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleInstallGroup 

type ModuleInstallGroup struct {
	module.ModuleBase
	Properties struct {
		InstallGroupProps
		TagableProps
		Features
	}
}

func (*ModuleInstallGroup) FeaturableProperties 

func (m *ModuleInstallGroup) FeaturableProperties() []interface{}

func (*ModuleInstallGroup) Features 

func (m *ModuleInstallGroup) Features() *Features

func (*ModuleInstallGroup) GenerateBuildActions 

func (m *ModuleInstallGroup) GenerateBuildActions(ctx blueprint.ModuleContext)

func (ModuleInstallGroup) GetProperties 

func (m ModuleInstallGroup) GetProperties() interface{}

func (*ModuleInstallGroup) GetTags 

func (m *ModuleInstallGroup) GetTags() []string

func (*ModuleInstallGroup) GetTagsRegex 

func (m *ModuleInstallGroup) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleInstallGroup) HasTag 

func (m *ModuleInstallGroup) HasTag(query string) bool

func (*ModuleInstallGroup) HasTagRegex 

func (m *ModuleInstallGroup) HasTagRegex(query *regexp.Regexp) bool

type ModuleKernelObject 

type ModuleKernelObject struct {
	module.ModuleBase
	Properties struct {
		Features
		CommonProps
		KernelProps
		TagableProps
		Defaults []string
	}
}

func (*ModuleKernelObject) FeaturableProperties 

func (m *ModuleKernelObject) FeaturableProperties() []interface{}

func (*ModuleKernelObject) Features 

func (m *ModuleKernelObject) Features() *Features

func (*ModuleKernelObject) GenerateBuildActions 

func (m *ModuleKernelObject) GenerateBuildActions(ctx blueprint.ModuleContext)

func (ModuleKernelObject) GetProperties 

func (m ModuleKernelObject) GetProperties() interface{}

func (*ModuleKernelObject) GetTags 

func (m *ModuleKernelObject) GetTags() []string

func (*ModuleKernelObject) GetTagsRegex 

func (m *ModuleKernelObject) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleKernelObject) HasTag 

func (m *ModuleKernelObject) HasTag(query string) bool

func (*ModuleKernelObject) HasTagRegex 

func (m *ModuleKernelObject) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleKernelObject) OutFileTargets 

func (m *ModuleKernelObject) OutFileTargets() []string

func (*ModuleKernelObject) OutFiles 

func (m *ModuleKernelObject) OutFiles() file.Paths

func (*ModuleKernelObject) ResolveFiles 

func (m *ModuleKernelObject) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleLibrary 

type ModuleLibrary struct {
	module.ModuleBase

	Properties struct {
		Features
		TransitiveLibraryProps
		Build
		TagableProps

		// The list of default properties that should prepended to all configuration
		Defaults []string

		VersionScriptModule *string `blueprint:"mutated"`
	}
}

ModuleLibrary is a base class for modules which are generated from sets of object files

func (*ModuleLibrary) FeaturableProperties 

func (m *ModuleLibrary) FeaturableProperties() []interface{}

func (*ModuleLibrary) Features 

func (m *ModuleLibrary) Features() *Features

func (*ModuleLibrary) FlagsIn 

func (m *ModuleLibrary) FlagsIn() flag.Flags

func (*ModuleLibrary) FlagsInTransitive 

func (m *ModuleLibrary) FlagsInTransitive(ctx blueprint.BaseModuleContext) (ret flag.Flags)

func (*ModuleLibrary) FlagsOut 

func (m *ModuleLibrary) FlagsOut() flag.Flags

func (*ModuleLibrary) FlagsOutTargets 

func (m *ModuleLibrary) FlagsOutTargets() []string

func (*ModuleLibrary) GenerateBuildActions 

func (m *ModuleLibrary) GenerateBuildActions(blueprint.ModuleContext)

func (*ModuleLibrary) GetBuildWrapperAndDeps 

func (m *ModuleLibrary) GetBuildWrapperAndDeps(ctx blueprint.ModuleContext) (string, []string)

func (*ModuleLibrary) GetDirectFiles 

func (m *ModuleLibrary) GetDirectFiles() file.Paths

func (*ModuleLibrary) GetFiles 

func (m *ModuleLibrary) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (*ModuleLibrary) GetMteProps 

func (m *ModuleLibrary) GetMteProps(blueprint.ModuleContext) AndroidMTEProps

func (*ModuleLibrary) GetStaticLibs 

func (m *ModuleLibrary) GetStaticLibs(ctx blueprint.ModuleContext) []string

Returns all the static library dependencies for a module.

func (*ModuleLibrary) GetTags 

func (m *ModuleLibrary) GetTags() []string

func (*ModuleLibrary) GetTagsRegex 

func (m *ModuleLibrary) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleLibrary) GetTargets 

func (m *ModuleLibrary) GetTargets() (tgts []string)

func (*ModuleLibrary) HasTag 

func (m *ModuleLibrary) HasTag(query string) bool

func (*ModuleLibrary) HasTagRegex 

func (m *ModuleLibrary) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleLibrary) IsForwardingSharedLibrary 

func (m *ModuleLibrary) IsForwardingSharedLibrary() bool

func (*ModuleLibrary) IsHwAsanEnabled 

func (m *ModuleLibrary) IsHwAsanEnabled() bool

func (*ModuleLibrary) IsRpathWanted 

func (m *ModuleLibrary) IsRpathWanted() bool

func (*ModuleLibrary) LibraryFactory 

func (m *ModuleLibrary) LibraryFactory(config *BobConfig, module blueprint.Module) (blueprint.Module, []interface{})

func (*ModuleLibrary) ResolveFiles 

func (m *ModuleLibrary) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleMeta 

type ModuleMeta struct {
	Srcs           []string `json:"srcs"`
	TransitiveDeps []string `json:"deps"`
}

type ModuleResource 

type ModuleResource struct {
	module.ModuleBase
	Properties struct {
		ResourceProps
		Features
	}
}

func (*ModuleResource) FeaturableProperties 

func (m *ModuleResource) FeaturableProperties() []interface{}

func (*ModuleResource) Features 

func (m *ModuleResource) Features() *Features

func (*ModuleResource) GenerateBuildActions 

func (m *ModuleResource) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleResource) GetDirectFiles 

func (m *ModuleResource) GetDirectFiles() file.Paths

func (*ModuleResource) GetFiles 

func (m *ModuleResource) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (ModuleResource) GetProperties 

func (m ModuleResource) GetProperties() interface{}

func (*ModuleResource) GetTags 

func (m *ModuleResource) GetTags() []string

func (*ModuleResource) GetTagsRegex 

func (m *ModuleResource) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleResource) GetTargets 

func (m *ModuleResource) GetTargets() []string

func (*ModuleResource) HasTag 

func (m *ModuleResource) HasTag(query string) bool

func (*ModuleResource) HasTagRegex 

func (m *ModuleResource) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleResource) OutFileTargets 

func (m *ModuleResource) OutFileTargets() []string

func (*ModuleResource) OutFiles 

func (m *ModuleResource) OutFiles() (files file.Paths)

func (*ModuleResource) ResolveFiles 

func (m *ModuleResource) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleSharedLibrary 

type ModuleSharedLibrary struct {
	ModuleLibrary
	// contains filtered or unexported fields
}

func (*ModuleSharedLibrary) FlagsIn 

func (m *ModuleSharedLibrary) FlagsIn() flag.Flags

func (*ModuleSharedLibrary) GenerateBuildActions 

func (m *ModuleSharedLibrary) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleSharedLibrary) GetBackendConfiguration 

func (m *ModuleSharedLibrary) GetBackendConfiguration(ctx blueprint.ModuleContext) BackendConfiguration

func (ModuleSharedLibrary) GetProperties 

func (m ModuleSharedLibrary) GetProperties() interface{}

func (*ModuleSharedLibrary) OutFileTargets 

func (m *ModuleSharedLibrary) OutFileTargets() []string

func (*ModuleSharedLibrary) OutFiles 

func (m *ModuleSharedLibrary) OutFiles() (files file.Paths)

type ModuleStaticLibrary 

type ModuleStaticLibrary struct {
	ModuleLibrary
}

func (*ModuleStaticLibrary) GenerateBuildActions 

func (m *ModuleStaticLibrary) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleStaticLibrary) GetBackendConfiguration 

func (m *ModuleStaticLibrary) GetBackendConfiguration(ctx blueprint.ModuleContext) BackendConfiguration

func (ModuleStaticLibrary) GetProperties 

func (m ModuleStaticLibrary) GetProperties() interface{}

func (*ModuleStaticLibrary) OutFileTargets 

func (m *ModuleStaticLibrary) OutFileTargets() []string

func (*ModuleStaticLibrary) OutFiles 

func (m *ModuleStaticLibrary) OutFiles() (srcs file.Paths)

type ModuleStrictBinary 

type ModuleStrictBinary struct {
	ModuleStrictLibrary
}

func (*ModuleStrictBinary) FlagsInTransitive 

func (m *ModuleStrictBinary) FlagsInTransitive(ctx blueprint.BaseModuleContext) flag.Flags

func (*ModuleStrictBinary) GenerateBuildActions 

func (m *ModuleStrictBinary) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleStrictBinary) OutFiles 

func (m *ModuleStrictBinary) OutFiles() file.Paths

type ModuleStrictGenerateCommon 

type ModuleStrictGenerateCommon struct {
	module.ModuleBase
	Properties struct {
		EnableableProps
		TagableProps
		Features
		StrictGenerateProps
	}
	// contains filtered or unexported fields
}

func (*ModuleStrictGenerateCommon) FeaturableProperties 

func (m *ModuleStrictGenerateCommon) FeaturableProperties() []interface{}

func (*ModuleStrictGenerateCommon) Features 

func (m *ModuleStrictGenerateCommon) Features() *Features

func (*ModuleStrictGenerateCommon) GenerateBuildActions 

func (m *ModuleStrictGenerateCommon) GenerateBuildActions(blueprint.ModuleContext)

func (*ModuleStrictGenerateCommon) GetDirectFiles 

func (m *ModuleStrictGenerateCommon) GetDirectFiles() file.Paths

func (*ModuleStrictGenerateCommon) GetFiles 

func (m *ModuleStrictGenerateCommon) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (*ModuleStrictGenerateCommon) GetTags 

func (m *ModuleStrictGenerateCommon) GetTags() []string

func (*ModuleStrictGenerateCommon) GetTagsRegex 

func (m *ModuleStrictGenerateCommon) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleStrictGenerateCommon) GetTargets 

func (m *ModuleStrictGenerateCommon) GetTargets() []string

func (*ModuleStrictGenerateCommon) HasTag 

func (m *ModuleStrictGenerateCommon) HasTag(query string) bool

func (*ModuleStrictGenerateCommon) HasTagRegex 

func (m *ModuleStrictGenerateCommon) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleStrictGenerateCommon) ResolveFiles 

func (m *ModuleStrictGenerateCommon) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleStrictLibrary 

type ModuleStrictLibrary struct {
	module.ModuleBase
	Properties struct {
		StrictLibraryProps
		IncludeProps
		TransitiveLibraryProps
		TagableProps

		Features
		EnableableProps
		SplittableProps
		InstallableProps

		TargetType toolchain.TgtType `blueprint:"mutated"`
		Target     TargetSpecific
		Host       TargetSpecific

		ToolchainFlagsProps
	}
}

func (*ModuleStrictLibrary) FeaturableProperties 

func (m *ModuleStrictLibrary) FeaturableProperties() []interface{}

func (*ModuleStrictLibrary) Features 

func (m *ModuleStrictLibrary) Features() *Features

func (*ModuleStrictLibrary) FlagsIn 

func (m *ModuleStrictLibrary) FlagsIn() flag.Flags

func (*ModuleStrictLibrary) FlagsInTransitive 

func (m *ModuleStrictLibrary) FlagsInTransitive(ctx blueprint.BaseModuleContext) (ret flag.Flags)

func (*ModuleStrictLibrary) FlagsOut 

func (m *ModuleStrictLibrary) FlagsOut() flag.Flags

func (*ModuleStrictLibrary) GenerateBuildActions 

func (m *ModuleStrictLibrary) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleStrictLibrary) GetBackendConfiguration 

func (m *ModuleStrictLibrary) GetBackendConfiguration(ctx blueprint.ModuleContext) BackendConfiguration

func (*ModuleStrictLibrary) GetDirectFiles 

func (m *ModuleStrictLibrary) GetDirectFiles() file.Paths

func (*ModuleStrictLibrary) GetFiles 

func (m *ModuleStrictLibrary) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (ModuleStrictLibrary) GetProperties 

func (m ModuleStrictLibrary) GetProperties() interface{}

func (*ModuleStrictLibrary) GetStaticLibs 

func (m *ModuleStrictLibrary) GetStaticLibs(ctx blueprint.ModuleContext) (libs []string)

func (*ModuleStrictLibrary) GetTags 

func (m *ModuleStrictLibrary) GetTags() []string

func (*ModuleStrictLibrary) GetTagsRegex 

func (m *ModuleStrictLibrary) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleStrictLibrary) GetTargets 

func (m *ModuleStrictLibrary) GetTargets() (tgts []string)

func (*ModuleStrictLibrary) HasTag 

func (m *ModuleStrictLibrary) HasTag(query string) bool

func (*ModuleStrictLibrary) HasTagRegex 

func (m *ModuleStrictLibrary) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleStrictLibrary) IsForwardingSharedLibrary 

func (m *ModuleStrictLibrary) IsForwardingSharedLibrary() bool

func (*ModuleStrictLibrary) IsRpathWanted 

func (m *ModuleStrictLibrary) IsRpathWanted() bool

func (*ModuleStrictLibrary) OutFileTargets 

func (m *ModuleStrictLibrary) OutFileTargets() []string

func (*ModuleStrictLibrary) OutFiles 

func (m *ModuleStrictLibrary) OutFiles() file.Paths

func (*ModuleStrictLibrary) ResolveFiles 

func (m *ModuleStrictLibrary) ResolveFiles(ctx blueprint.BaseModuleContext)

type ModuleTest 

type ModuleTest struct {
	ModuleStrictBinary
}

func (*ModuleTest) GenerateBuildActions 

func (m *ModuleTest) GenerateBuildActions(ctx blueprint.ModuleContext)

type ModuleToolchain 

type ModuleToolchain struct {
	module.ModuleBase

	SplittableProps

	Properties struct {
		ModuleToolchainProps
		StripProps
		TagableProps

		Target     TargetSpecific
		Host       TargetSpecific
		TargetType toolchain.TgtType `blueprint:"mutated"`

		Features
	}
}

Strict targets will not support defaults by design.

With this in mind, we will need a way to propagate common toolchain flags to targets (optimization etc).

func (*ModuleToolchain) FeaturableProperties 

func (m *ModuleToolchain) FeaturableProperties() []interface{}

func (*ModuleToolchain) Features 

func (m *ModuleToolchain) Features() *Features

func (*ModuleToolchain) FlagsOut 

func (m *ModuleToolchain) FlagsOut() flag.Flags

func (*ModuleToolchain) GenerateBuildActions 

func (m *ModuleToolchain) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleToolchain) GetBuildWrapperAndDeps 

func (m *ModuleToolchain) GetBuildWrapperAndDeps(ctx blueprint.ModuleContext) (string, []string)

func (*ModuleToolchain) GetMteProps 

func (m *ModuleToolchain) GetMteProps(blueprint.ModuleContext) AndroidMTEProps

func (*ModuleToolchain) GetTags 

func (m *ModuleToolchain) GetTags() []string

func (*ModuleToolchain) GetTagsRegex 

func (m *ModuleToolchain) GetTagsRegex(query *regexp.Regexp) []string

func (*ModuleToolchain) HasTag 

func (m *ModuleToolchain) HasTag(query string) bool

func (*ModuleToolchain) HasTagRegex 

func (m *ModuleToolchain) HasTagRegex(query *regexp.Regexp) bool

func (*ModuleToolchain) IsHwAsanEnabled 

func (m *ModuleToolchain) IsHwAsanEnabled() bool

type ModuleToolchainInterface 

type ModuleToolchainInterface interface {
	Featurable

	flag.Provider
	Tagable
	// contains filtered or unexported methods
}

type ModuleToolchainProps 

type ModuleToolchainProps struct {
	// Flags that will be used for C and C++ compiles.
	Cflags []string

	// Flags that will be used for C compiles.
	Conlyflags []string

	// Flags that will be used for C++ compiles.
	Cppflags []string

	// Flags that will be used for .S compiles.
	Asflags []string

	// Flags that will be used for all link steps.
	Ldflags []string

	// Wrapper for all build commands (object file compilation *and* linking)
	Build_wrapper *string

	AndroidMTEProps

	Hwasan_enabled *bool
}

type ModuleTransformSource 

type ModuleTransformSource struct {
	ModuleGenerateCommon
	Properties struct {
		TransformSourceProps
	}
}

The module that can generate sources using a multiple execution The command will be run once per src file- with $in being the path in "srcs" and $out being the path transformed through the regexp defined by out.match and out.replace. The regular expression that is used is in regexp.compiled(out.Match).ReplaceAllString(src[i], out.Replace). See https://golang.org/pkg/regexp/ for more information. The working directory will be the source directory, and all paths will be relative to the source directory if not else noted

func (*ModuleTransformSource) FeaturableProperties 

func (m *ModuleTransformSource) FeaturableProperties() []interface{}

func (*ModuleTransformSource) FlagsOut 

func (m *ModuleTransformSource) FlagsOut() (flags flag.Flags)

func (*ModuleTransformSource) GenerateBuildActions 

func (m *ModuleTransformSource) GenerateBuildActions(ctx blueprint.ModuleContext)

func (*ModuleTransformSource) GetDirectFiles 

func (m *ModuleTransformSource) GetDirectFiles() file.Paths

func (*ModuleTransformSource) GetFiles 

func (m *ModuleTransformSource) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (ModuleTransformSource) GetProperties 

func (m ModuleTransformSource) GetProperties() interface{}

func (*ModuleTransformSource) GetTargets 

func (m *ModuleTransformSource) GetTargets() []string

func (*ModuleTransformSource) OutFileTargets 

func (m *ModuleTransformSource) OutFileTargets() []string

func (*ModuleTransformSource) OutFiles 

func (m *ModuleTransformSource) OutFiles() file.Paths

func (*ModuleTransformSource) ResolveFiles 

func (m *ModuleTransformSource) ResolveFiles(ctx blueprint.BaseModuleContext)

func (*ModuleTransformSource) ResolveOutFiles 

func (m *ModuleTransformSource) ResolveOutFiles(ctx blueprint.BaseModuleContext)

type PropertyProvider 

type PropertyProvider interface {
	GetProperties() interface{}
}

type ResourceProps 

type ResourceProps struct {
	LegacySourceProps
	AliasableProps
	InstallableProps
	EnableableProps
	AndroidProps
	TagableProps
}

ResourceProps defines all the properties that can be used in a bob_resource

type SharedLibraryExporter 

type SharedLibraryExporter interface {
	flag.Provider // Eventually the below functions will be removed
	// contains filtered or unexported methods
}

type SourceProps 

type SourceProps struct {
	// The list of source files and target names for globs/filegroups
	Srcs []string

	ResolvedSrcs file.Paths `blueprint:"mutated"` // Glob results.
}

func (*SourceProps) GetDirectFiles 

func (s *SourceProps) GetDirectFiles() file.Paths

func (*SourceProps) GetFiles 

func (s *SourceProps) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (*SourceProps) GetTargets 

func (s *SourceProps) GetTargets() []string

Basic common implementation, certain targets will custmize this.

func (*SourceProps) ResolveFiles 

func (s *SourceProps) ResolveFiles(ctx blueprint.BaseModuleContext)

type SplittableProps 

type SplittableProps struct {
	Host_supported   *bool
	Target_supported *bool
}

SplittableProps are embedded by modules which can be split into multiple variants

type StrictGenerateCommonInterface 

type StrictGenerateCommonInterface interface {
	file.Consumer
	file.Resolver
	Tagable
	// contains filtered or unexported methods
}

type StrictGenerateProps 

type StrictGenerateProps struct {
	// See https://ci.android.com/builds/submitted/8928481/linux/latest/view/soong_build.html
	Name                string
	Srcs                []string // TODO: This module should probalby make use of LegacySourceProps
	Exclude_srcs        []string
	Cmd                 *string
	Depfile             *bool
	Export_include_dirs []string
	Tool_files          []string
	Tools               []string

	ResolvedSrcs file.Paths `blueprint:"mutated"` // Glob results.
}

func (*StrictGenerateProps) GetDirectFiles 

func (ag *StrictGenerateProps) GetDirectFiles() file.Paths

func (*StrictGenerateProps) GetFiles 

func (ag *StrictGenerateProps) GetFiles(ctx blueprint.BaseModuleContext) file.Paths

func (*StrictGenerateProps) GetTargets 

func (ag *StrictGenerateProps) GetTargets() []string

func (*StrictGenerateProps) ResolveFiles 

func (ag *StrictGenerateProps) ResolveFiles(ctx blueprint.BaseModuleContext)

type StrictGeneratePropsInterface 

type StrictGeneratePropsInterface interface {
	file.Consumer
	file.Resolver
	// contains filtered or unexported methods
}

type StrictGenerator 

type StrictGenerator interface {
	// contains filtered or unexported methods
}

Module implementing `StrictGenerator` are able to generate output files

type StrictLibraryProps 

type StrictLibraryProps struct {
	SourceProps
	Hdrs []string
	// TODO: Header inclusion
	//Textual_hdrs           []string
	//Includes               []string
	//Include_prefixes       []string
	//Strip_include_prefixes []string
	Alwayslink *bool
	Linkstatic *bool

	Linkopts []string

	Local_defines []string
	Copts         []string
	Deps          []string

	// TODO: unused but needed for the output interface, no easy way to hide it
	Out *string
}

type StripCapable 

type StripCapable interface {
	GetStripable(blueprint.ModuleContext) stripable
}

A module which can return a stripable object such as `bob_toolchain`. In the case of legacy modules, it will often return itself.

type StripProps 

type StripProps struct {
	// When set, strip symbols and debug information from libraries
	// and binaries. This is a separate stage that occurs after
	// linking and before post install.
	//
	// On Android, its infrastructure is used to do the stripping. If
	// not enabled, follow Android's default behaviour.
	Strip *bool

	// Module specifying a directory for debug information
	Debug_info *string

	// The path retrieved from debug install group so we don't need to
	// walk dependencies to get it
	Debug_path *string `blueprint:"mutated"`
}

type Tagable 

type Tagable interface {
	blueprint.Module

	// Returns true if any of the tags match the expression
	HasTagRegex(*regexp.Regexp) bool

	// Return true if any of the tags match query
	HasTag(string) bool

	// Returns all tags matching regex
	GetTagsRegex(*regexp.Regexp) []string

	// Returns all tags
	GetTags() []string
}

type TagableProps 

type TagableProps struct {
	Tags []string
}

func (*TagableProps) GetTags 

func (p *TagableProps) GetTags() []string

func (*TagableProps) GetTagsRegex 

func (p *TagableProps) GetTagsRegex(query *regexp.Regexp) []string

func (*TagableProps) HasTag 

func (p *TagableProps) HasTag(query string) bool

func (*TagableProps) HasTagRegex 

func (p *TagableProps) HasTagRegex(query *regexp.Regexp) bool

type TargetSpecific 

type TargetSpecific struct {
	Features

	// 'BlueprintEmbed' is a special case in Blueprint which makes it interpret
	// a runtime-generated type as being embedded in its parent struct.
	BlueprintEmbed interface{}
}

A TargetSpecific module is one that supports building on host and target, with a set of properties in `host: {}` or `target: {}` blocks.

type ToolchainFlagsProps 

type ToolchainFlagsProps struct {
	// `ModuleToolchain` module.
	Toolchain *string
}

type TransformSourceProps 

type TransformSourceProps struct {
	// The regular expression that is used to transform the source path to the target path.
	Out struct {
		// Regular expression to capture groups from srcs
		Match string
		// Names of outputs, which can use capture groups from match
		Replace []string
		// List of implicit sources. Implicit sources are input files that do not get mentioned on the command line,
		// and are not specified in the explicit sources.
		Implicit_srcs []string
	}

	// Stores the files generated
	ResolvedOut file.Paths `blueprint:"mutated"`
}

TransformSourceProps contains the properties allowed in the bob_transform_source module. This module supports one command execution per input file.

type TransitiveLibraryProps 

type TransitiveLibraryProps struct {
	Defines []string
}

In Bazel, some properties are transitive.

Source Files

View all Source files

Directories

Path Synopsis
The backend package provides platform specific configuration for the generator.
 The backend package provides platform specific configuration for the generator.
mapper

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.