"internal/syscall/windows"
	"syscall"
)

const (
	PathSeparator     = '\\' // OS-specific path separator
	PathListSeparator = ';'  // OS-specific path list separator
)

// IsPathSeparator reports whether c is a directory separator character.
func IsPathSeparator(c uint8) bool {
	// NOTE: Windows accepts / as path separator.
	return c == '\\' || c == '/'
}

func dirname(path string) string {

// Match reports whether name matches the shell file name pattern.
// The pattern syntax is:
//
//	pattern:
//		{ term }
//	term:
//		'*'         matches any sequence of non-Separator characters
//		'?'         matches any single non-Separator character
//		'[' [ '^' ] { character-range } ']'
//		            character class (must be non-empty)
//		c           matches character c (c != '*', '?', '\\', '[')

   * the operating system's default line separator. This method is equivalent to {@code
   * writeLines(lines, System.getProperty("line.separator"))}.
   *
   * @throws IOException if an I/O error occurs while writing to this sink
   */
  public void writeLines(Iterable<? extends CharSequence> lines) throws IOException {
    writeLines(lines, System.getProperty("line.separator"));
  }

  /**

DocumentationComponent 'docs'
-----------------------------

Source sets
    Markdown source 'docs:userguide'
        srcDir: src${File.separator}docs${File.separator}userguide
    Text source 'docs:reference'
        srcDir: src${File.separator}docs${File.separator}reference

Binaries
    DocumentationBinary 'docs:exploded'
        build using task: :docsExploded
"""
    }

    def "can build binary"() {

     */
    private
    fun File.injectAgentOptions(separator: String) {
        if (agentJarNames.isEmpty()) {
            return
        }
        var replacementsCount = 0
        // readLines eats EOLs, so we need to use postfix to make sure the last line ends with EOL too.
        writeBytes(readLines().joinToString(separator = separator, postfix = separator) { line ->
            when {

 * limitations under the License.
 */

package org.gradle.kotlin.dsl.internal.sharedruntime.support


/**
 * Appends value to the given Appendable and simple `\n` line separator after it.
 *
 * Always using the same line separator on all systems to allow for reproducible outputs.
 */
fun Appendable.appendReproducibleNewLine(value: CharSequence = ""): Appendable {
    assert('\r' !in value) {

     */
    public static String join(String separator, Object[] objects) {
        return join(separator, objects == null ? null : Arrays.asList(objects));
    }

    /**
     * Creates a string with {@code toString()} of each transformed object with the given separator.
     *
     * @see #join(String, Object[])
     */

	separator := byte(0x80) // gets reset to 0x00 once used
	for i := byte(0); i < chunk; i++ {
		mask := byte(int8(i-nx) >> 7) // 0x00 after the end of data

		// if we reached the end of the data, replace with 0x80 or 0x00
		d.x[i] = (^mask & separator) | (mask & d.x[i])

		// zero the separator once used
		separator &= mask

		if i >= 56 {

        File file = new File(s);
        if (file.isAbsolute()) {
            // path was already absolute, just normalize file separator and we're done
            s = file.getPath();
        } else if (file.getPath().startsWith(File.separator)) {
            // drive-relative Windows path, don't align with project directory but with drive root
            s = file.getAbsolutePath();
        } else {

     */
    @Override
    String getName();

    /**
     * Returns the path of this file, relative to the root of the copy destination.
     * <p>
     * Always uses '/' as the hierarchy separator, regardless of platform file separator.
     * Same as calling <code>getRelativePath().getPathString()</code>.
     *
     * @return The path, relative to the root of the copy destination. Never returns null.
     */
    @Override