}

    public String getName() {
        return currentPath.substring(sizeOfCommonPrefix + 1);
    }

    public boolean nextPath(String nextPath, boolean directory, Runnable exitDirectoryHandler) {
        currentPath = directory ? nextPath.substring(0, nextPath.length() - 1) : nextPath;
        String lastDirPath = directoryPaths.peekLast();
        sizeOfCommonPrefix = FilePathUtil.sizeOfCommonPrefix(lastDirPath, currentPath, 0, '/');

        boolean outsideOfRoot

        when:
        outsideOfRoot = parser.nextPath("tree-some/first/", true, exitHandler)
        then:
        0 * exitHandler.run()
        then:
        parser.name == "first"
        parser.relativePath == "first"
        !parser.root
        !outsideOfRoot

        when:
        outsideOfRoot = parser.nextPath("tree-some/first/file.txt", false, exitHandler)
        then:

	// corruption under full disk condition.
	// See https://github.com/kubernetes/kubernetes/issues/98989.
	err = os.WriteFile(v.nextPath(), []byte(vp.String()), 0666)
	if err != nil {
		return fmt.Errorf("failed to write new version file %s: %v", v.nextPath(), err)
	}
	return os.Rename(v.nextPath(), v.path)
}

func exists(path string) (bool, error) {
	if _, err := os.Stat(path); os.IsNotExist(err) {
		return false, nil

            String nextPath = refPath + ( path != null ? path.substring(r.getPathConsumed()) : "" );
            if ( log.isDebugEnabled() ) {
                log.debug(
                    String.format(
                        "Intermediate referral, server %s share %s refPath %s origPath %s nextPath %s",
                        r.getServer(),
                        r.getShare(),

			if err != nil {
				return nil, err
			}

			restrictionFiles = append(restrictionFiles, rules)
		}

		nextPath, removedDir := removeLastDir(path)
		if nextPath == path || isGoModRoot(path) || removedDir == "src" {
			break
		}

		path = nextPath
	}

	return restrictionFiles, nil
}

func readFile(path string) (*FileFormat, error) {
	currentBytes, err := os.ReadFile(path)

func (ctxt *Context) makePathsAbsolute(args []string, srcDir string) {
	nextPath := false
	for i, arg := range args {
		if nextPath {
			if !filepath.IsAbs(arg) {
				args[i] = filepath.Join(srcDir, arg)
			}
			nextPath = false
		} else if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
			if len(arg) == 2 {
				nextPath = true
			} else {
				if !filepath.IsAbs(arg[2:]) {

        TarArchiveEntry entry;

        while ((entry = input.getNextEntry()) != null) {
            boolean isDir = entry.isDirectory();
            boolean outsideOfRoot = parser.nextPath(safeEntryName(entry), isDir, builder::leaveDirectory);
            if (outsideOfRoot) {
                break;
            }
            entries.incrementAndGet();

func (ctxt *Context) makePathsAbsolute(args []string, srcDir string) {
	nextPath := false
	for i, arg := range args {
		if nextPath {
			if !filepath.IsAbs(arg) {
				args[i] = filepath.Join(srcDir, arg)
			}
			nextPath = false
		} else if strings.HasPrefix(arg, "-I") || strings.HasPrefix(arg, "-L") {
			if len(arg) == 2 {
				nextPath = true
			} else {
				if !filepath.IsAbs(arg[2:]) {

	var last *profMapEntry
Search:
	for e := m.hash[h]; e != nil; last, e = e, e.nextHash {
		if len(e.stk) != len(stk) || e.tag != tag {
			continue
		}
		for j := range stk {
			if e.stk[j] != uintptr(stk[j]) {
				continue Search
			}
		}
		// Move to front.
		if last != nil {
			last.nextHash = e.nextHash
			e.nextHash = m.hash[h]
			m.hash[h] = e
		}
		return e
	}

	// Add new entry.

            };

            do {
                try {
                    nextBatch = project.stepEvaluationListener(nextBatch, fireAction);
                } catch (Exception e) {
                    addConfigurationFailure(project, state, e, context);
                    return;
                }
            } while (nextBatch != null);

            context.setResult(NotifyProjectAfterEvaluatedBuildOperationType.RESULT);