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();

            };

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

            context.setResult(NotifyProjectAfterEvaluatedBuildOperationType.RESULT);

                }
                Batch nextBatch = batchesIterator.next()
                expectedSingle = nextBatch.expectedSingle
                expectedMulti = nextBatch.expectedMulti
                expectConflictResolution = nextBatch.expectConflict
                current = permutations(nextBatch).iterator()
                if (nextBatch.batchName != currentBatch) {
                    idx = 0