blob: 0f7876d384e65b0ab7e45f2456e2987b3d2fc2d8 [file] [log] [blame]
// Copyright 2018 The Bazel Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package com.google.devtools.build.lib.includescanning;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.includescanning.IncludeParser.Inclusion;
import com.google.devtools.build.lib.includescanning.IncludeParser.Inclusion.Kind;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.List;
/**
* Helper class that deals with the processing of a given file's inclusions. Extracted for use in
* multiple include scanning implementations.
*/
class IncludeScannerHelper {
private final List<PathFragment> includePaths;
private final List<PathFragment> quoteIncludePaths;
private final Artifact source;
private boolean hasQuoteContextPathPos = false;
private int quoteContextPathPos = -1;
private boolean hasAngleContextPathPos = false;
private int angleContextPathPos = -1;
IncludeScannerHelper(List<PathFragment> includePaths, List<PathFragment> quoteIncludePaths,
Artifact source) {
this.includePaths = includePaths;
this.quoteIncludePaths = quoteIncludePaths;
this.source = source;
}
/**
* Finds {@code source} in the given {@code includePaths} as if it were #included as {@code
* include}.
*
* @return the index in {@code includePaths} a #include_next directive should start searching
* from, or -1 if the source file was not found.
*/
private static int findContextPathPos(
PathFragment include, Artifact source, List<PathFragment> includePaths) {
for (int i = 0; i < includePaths.size(); ++i) {
PathFragment execPath = includePaths.get(i);
if (execPath.getRelative(include).equals(source.getExecPath())) {
return i + 1;
}
}
return -1;
}
/**
* Most inclusions become inclusions with context as-is -- the context of their including file is
* their context. However, in the case of a top-level #include_next inclusion, a more involved
* procedure is needed to find the proper context.
*/
InclusionWithContext createInclusionWithContext(Inclusion inclusion, int contextPathPos,
Kind contextKind) {
if (inclusion.kind.isNext() && contextPathPos == -1) {
// Special handling for the case when a #include_next directive is found without context,
// e. g., in the main source file. This is the case if either:
// 1. We do header preprocessing / parsing to check strict layering, or when building
// header modules; in this case we emulate clang's behavior; gcc's implementation
// diverges from clang here, but gcc does not support these use cases.
// 2. A .c / .cc file contains #include_next. Here the behavior of clang/gcc is different
// from what we implement, but it will lead to an error anyway.
// First, try to find the source of the inclusion via a header search.
if (inclusion.kind == Kind.NEXT_QUOTE) {
if (!hasQuoteContextPathPos) {
quoteContextPathPos =
findContextPathPos(inclusion.pathFragment, source, quoteIncludePaths);
hasQuoteContextPathPos = true;
}
contextPathPos = quoteContextPathPos;
} else {
if (!hasAngleContextPathPos) {
angleContextPathPos =
findContextPathPos(inclusion.pathFragment, source, includePaths);
hasAngleContextPathPos = true;
}
contextPathPos = angleContextPathPos;
}
Kind kind = (inclusion.kind == Kind.NEXT_QUOTE) ? Kind.QUOTE : Kind.ANGLE;
if (contextPathPos != -1) {
// If the source was found via the header search, assume that is a valid context to
// start the search from.
// The context kind was previously unknown, as this inclusion came from a top-level
// source; assume the context kind is the same as the kind of the include_next
// directive.
contextKind = kind;
} else {
// If the source was not found, #include_next behaves exactly like #include.
inclusion = Inclusion.create(inclusion.pathFragment, kind);
}
}
return new InclusionWithContext(inclusion, contextPathPos, contextKind);
}
}