"checker". For example, the printf checker reports mistakes in
fmt.Printf format strings.

A "modular" analysis is one that inspects one package at a time but can
save information from a lower-level package and use it when inspecting a
higher-level package, analogous to separate compilation in a toolchain.
The printf checker is modular: when it discovers that a function such as
log.Fatalf delegates to fmt.Printf, it records this fact, and checks

        "@com_google_absl//absl/log",
    ],
    alwayslink = 1,
)

# Library implementing helper functionality, so that the above only contains
# the API implementation for modular filesystems.
cc_library(
    name = "posix_filesystem_helper",
    srcs = ["posix_filesystem_helper.cc"],
    hdrs = ["posix_filesystem_helper.h"],
    deps = [":copy_file"],
)

		if j&1 == 1 { // map zeros to origin
			j++
			y++
		}
		j &= 7                               // octant modulo 2Pi radians (360 degrees)
		z = ((x - y*PI4A) - y*PI4B) - y*PI4C // Extended precision modular arithmetic
	}
	if j > 3 { // reflect in x axis
		j -= 4
		sinSign, cosSign = !sinSign, !cosSign
	}
	if j > 1 {
		cosSign = !cosSign
	}

	zz := z * z

import org.gradle.test.preconditions.UnitTestPreconditions

@Requires(UnitTestPreconditions.Jdk9OrLater)
class EclipseJavaProjectModulesIntegrationTest extends AbstractEclipseIntegrationSpec {

    def "depend on modular project"() {
        setup:
        /*
        This is the multi-module project structure the integration test works with:
        -root
          -api
          -util
        */

| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<modular-jar>>> *   | <<<tests>>>   | <<<jar>>>  | java      | modules               |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+

                implementation 'org:jlib:1.0'
            }
        """
    }

    @ToBeFixedForConfigurationCache
    def "dependencies are not marked as modules if the project itself is not modular"() {
        when:
        succeeds "eclipse"

        then:
        def libraries = classpath.libs
        libraries.size() == 3
        libraries[0].jarName == 'jmodule-1.0.jar'

# Istio Installer

Note: If making any changes to the charts or values.yaml in this dir, first read [UPDATING-CHARTS.md](UPDATING-CHARTS.md)

Istio installer is a modular, 'a-la-carte' installer for Istio. It is based on a
fork of the Istio helm templates, refactored to increase modularity and isolation.

Goals:
- Improve upgrade experience: users should be able to gradually roll upgrades, with proper

 * Since Java 9, these commands offer two different approaches to handle such a classpath:
 *
 * <ul>
 *   <li>A traditional classpath by using the --classpath parameter.
 *   <li>A modular classpath (module path) using the --module-path parameter.
 * </ul>
 *
 * If the --module-path is used, the Java Platform Module System (JPMS) becomes active and the module descriptors (module-info.class)

[[dependency_management_in_gradle]]
= Dependency Management

Software projects rarely work in isolation.
Projects often rely on reusable functionality from libraries.
Some projects organize unrelated functionality into separate parts of a modular system.

Dependency management is an automated technique for declaring, resolving, and using functionality required by a project.

     * is {@link JavaPathType#MODULES}, then this method returns {@code "--module-path"}.
     * The option does not include the {@linkplain JavaPathType.Modular#moduleName() module name}
     * on which it applies.
     *
     * @return the name of the tool option for this path type
     */
    @Nonnull
    Optional<String> option();

    /**