25: 	Path []PathStep

30: 	PathStep interface {

187: 	pathStep struct {

192: 		pathStep

196: 		pathStep

200: 		pathStep

203: 		pathStep

215: 		pathStep

218: 		pathStep

270: func (pathStep) isPathStep()           {}

16: 	// Path is a list of PathSteps describing the sequence of operations to get

18: 	// The first Path element is always an operation-less PathStep that exists

32: 		Type() reflect.Type // Resulting type after performing the path step

91: func (pa *Path) push(s PathStep) {

95: func (pa *Path) pop() {

99: // Last returns the last PathStep in the Path.

100: // If the path is empty, this returns a non-nil PathStep that reports a nil Type.

101: func (pa Path) Last() PathStep {

105: // Index returns the ith step in the Path and supports negative indexing.

106: // A negative index starts counting from the tail of the Path such that -1

109: func (pa Path) Index(i int) PathStep {

119: // String returns the simplified path to a node.

120: // The simplified path only contains struct field accesses.

124: func (pa Path) String() string {

134: // GoString returns the path to a specific node using Go syntax.

138: func (pa Path) GoString() string {

27: 	// PathStep is a union-type for specific operations to traverse

38: 		PathStep

56: 		PathStep

62: 		PathStep

67: 		PathStep

74: 		PathStep

79: 		PathStep

108: // If index is invalid, this returns a non-nil PathStep that reports a nil Type.

114: 		return pathStep{}

142: 		var nextStep PathStep

174: 			if s.Type().PkgPath() == "" {

223: func (ps pathStep) Type() reflect.Type { return ps.typ }

224: func (ps pathStep) String() string {

286: 	_ PathStep = sliceIndex{}

287: 	_ PathStep = mapIndex{}

288: 	_ PathStep = typeAssertion{}

289: 	_ PathStep = structField{}

290: 	_ PathStep = indirect{}

291: 	_ PathStep = transform{}

33: 		isPathStep()

15: package path

60: func (n *API) Path() *Any                       { return &Any{&Any_API{n}} }

61: func (n *ArrayIndex) Path() *Any                { return &Any{&Any_ArrayIndex{n}} }

62: func (n *As) Path() *Any                        { return &Any{&Any_As{n}} }

63: func (n *Blob) Path() *Any                      { return &Any{&Any_Blob{n}} }

64: func (n *Capture) Path() *Any                   { return &Any{&Any_Capture{n}} }

65: func (n *ConstantSet) Path() *Any               { return &Any{&Any_ConstantSet{n}} }

66: func (n *Command) Path() *Any                   { return &Any{&Any_Command{n}} }

67: func (n *Commands) Path() *Any                  { return &Any{&Any_Commands{n}} }

68: func (n *CommandTree) Path() *Any               { return &Any{&Any_CommandTree{n}} }

69: func (n *CommandTreeNode) Path() *Any           { return &Any{&Any_CommandTreeNode{n}} }

70: func (n *CommandTreeNodeForCommand) Path() *Any { return &Any{&Any_CommandTreeNodeForCommand{n}} }

71: func (n *Context) Path() *Any                   { return &Any{&Any_Context{n}} }

72: func (n *Contexts) Path() *Any                  { return &Any{&Any_Contexts{n}} }

73: func (n *Device) Path() *Any                    { return &Any{&Any_Device{n}} }

74: func (n *Events) Path() *Any                    { return &Any{&Any_Events{n}} }

75: func (n *FramebufferObservation) Path() *Any    { return &Any{&Any_FBO{n}} }

76: func (n *Field) Path() *Any                     { return &Any{&Any_Field{n}} }

77: func (n *GlobalState) Path() *Any               { return &Any{&Any_GlobalState{n}} }

78: func (n *ImageInfo) Path() *Any                 { return &Any{&Any_ImageInfo{n}} }

79: func (n *MapIndex) Path() *Any                  { return &Any{&Any_MapIndex{n}} }

80: func (n *Memory) Path() *Any                    { return &Any{&Any_Memory{n}} }

81: func (n *Mesh) Path() *Any                      { return &Any{&Any_Mesh{n}} }

82: func (n *Metrics) Path() *Any                   { return &Any{&Any_Metrics{n}} }

83: func (n *Parameter) Path() *Any                 { return &Any{&Any_Parameter{n}} }

84: func (n *Report) Path() *Any                    { return &Any{&Any_Report{n}} }

85: func (n *ResourceData) Path() *Any              { return &Any{&Any_ResourceData{n}} }

86: func (n *Resources) Path() *Any                 { return &Any{&Any_Resources{n}} }

87: func (n *Result) Path() *Any                    { return &Any{&Any_Result{n}} }

88: func (n *Slice) Path() *Any                     { return &Any{&Any_Slice{n}} }

89: func (n *State) Path() *Any                     { return &Any{&Any_State{n}} }

90: func (n *StateTree) Path() *Any                 { return &Any{&Any_StateTree{n}} }

91: func (n *StateTreeNode) Path() *Any             { return &Any{&Any_StateTreeNode{n}} }

93: func (n *Thumbnail) Path() *Any                 { return &Any{&Any_Thumbnail{n}} }

92: func (n *StateTreeNodeForPath) Path() *Any      { return &Any{&Any_StateTreeNodeForPath{n}} }

33: // command list, single command, memory, state or sub-object. A path can be

37: 	// Parent returns the path that this path derives from.

38: 	// If this path is a root, then Base returns nil.

41: 	// SetParent sets the path that this derives from.

44: 	// Path returns this path node as a path.

45: 	Path() *Any

47: 	// Validate checks the path for correctness, returning an error if any

417: // Node returns the path node for p.

418: func (p *Any) Node() Node { return oneOfNode(p.Path) }

425: // FindCommand traverses the path nodes looking for a Command path node.

426: // If no Command path node was found then nil is returned.

437: // FindCapture traverses the path nodes looking for a Capture path node.

438: // If no Capture path node was found then nil is returned.

449: // NewAPI returns a new API path node with the given ID.

454: // NewCapture returns a new Capture path node with the given ID.

459: // NewDevice returns a new Device path node with the given ID.

464: // NewBlob returns a new Blob path node with the given ID.

469: // NewImageInfo returns a new ImageInfo path node with the given ID.

474: // NewField returns a new Field path.

481: // NewArrayIndex returns a new ArrayIndex path.

488: // NewMapIndex returns a new MapIndex path.

498: // NewSlice returns a new Slice path.

505: // ConstantSet returns a path to the API's i'th ConstantSet.

513: // Resources returns the path node to the capture's resources.

518: // Report returns the path node to the capture's report.

523: // Contexts returns the path node to the capture's contexts.

528: // Commands returns the path node to the capture's commands.

537: // CommandRange returns the path node to a range of the capture's commands.

546: // SubCommandRange returns the path node to a range of the capture's subcommands

555: // CommandTree returns the path to the root node of a capture's command tree

561: // Child returns the path to the i'th child of the CommandTreeNode.

569: // Command returns the path node to a single command in the capture.

575: // Context returns the path node to the a context with the given ID.

580: // Thread returns the path node to the thread with the given ID.

585: // MemoryAfter returns the path node to the memory after this command.

590: // ResourceAfter returns the path node to the resource with the given identifier

599: // FramebufferObservation returns the path node to framebuffer observation

605: // Mesh returns the path node to the mesh of this command.

633: // GlobalStateAfter returns the path node to the state after this command.

638: // StateAfter returns the path node to the state after this command.

643: // First returns the path to the first command.

648: // Last returns the path to the last command.

653: // Index returns the path to the i'th child of the StateTreeNode.

661: // Parameter returns the path node to the parameter with the given name.

666: // Result returns the path node to the command's result.

671: // Tree returns the path node to the state tree for this state.

127: func (n StateTreeNodeForPath) Parent() Node      { return nil }

156: func (n *StateTreeNodeForPath) SetParent(p Node)      {}

271: func (n StateTreeNodeForPath) Format(f fmt.State, c rune) {

738: // ShallowEqual returns true if paths a and b are equal (ignoring parents).

33:   const string_view_t Path;

340: string_view_t path::__relative_path() const

350: string_view_t path::__parent_path() const

22: struct PathParser {

38:   PathParser(string_view_t P, ParserState State) noexcept

42:   PathParser(string_view_t P, string_view_t E, unsigned char S)

324: string_view_t path::__root_path_raw() const

1: //===--------------------- filesystem/path.cpp ----------------------------===//

18: using string_view_t = path::__string_view;

20: using PosPtr = path::value_type const*;

39:       : Path(P), State(State) {}

43:       : Path(P), RawEntry(E), State(static_cast<ParserState>(S)) {

121:                            Path.data(), RStart + 1);

123:         auto PP = CreateBegin(Path);

131:           return makeState(PS_InRootName, Path.data(), RStart + 1);

142:                          Path.data(), RStart + 1);

149:       return makeState(PS_InRootName, Path.data(), RStart + 1);

199:     return Path.data() + Path.size();

203:     return Path.data() - 1;

211:       return Path.data();

229:       return &Path.front();

235:       return &Path.back() + 1;

283: //                            path definitions

286: constexpr path::value_type path::preferred_separator;

288: path & path::replace_extension(path const & replacement)

290:     path p = extension();

304: // path.decompose

306: string_view_t path::__root_name() const

314: string_view_t path::__root_directory() const

362: string_view_t path::__filename() const

368: string_view_t path::__stem() const

373: string_view_t path::__extension() const

379: // path.comparisons

380: int path::__compare(string_view_t __s) const {

396: // path.nonmembers

397: size_t hash_value(const path& __p) noexcept {

409: // path.itr

410: path::iterator path::begin() const

414:     it.__path_ptr_ = this;

421: path::iterator path::end() const

425:     it.__path_ptr_ = this;

429: path::iterator& path::iterator::__increment() {

431:   PathParser PP(__path_ptr_->native(), __entry_, __state_);

439: path::iterator& path::iterator::__decrement() {

440:   PathParser PP(__path_ptr_->native(), __entry_, __state_);

47:   static PathParser CreateBegin(string_view_t P) noexcept {

48:     PathParser PP(P, PS_BeforeBegin);

53:   static PathParser CreateEnd(string_view_t P) noexcept {

54:     PathParser PP(P, PS_AtEnd);

178:   PathParser& operator++() noexcept {

183:   PathParser& operator--() noexcept {

279: using parser::PathParser;

308:     auto PP = PathParser::CreateBegin(__pn_);

309:     if (PP.State == PathParser::PS_InRootName)

316:     auto PP = PathParser::CreateBegin(__pn_);

317:     if (PP.State == PathParser::PS_InRootName)

319:     if (PP.State == PathParser::PS_InRootDir)

326:     auto PP = PathParser::CreateBegin(__pn_);

327:     if (PP.State == PathParser::PS_InRootName) {

335:     if (PP.State == PathParser::PS_InRootDir)

342:     auto PP = PathParser::CreateBegin(__pn_);

343:     while (PP.State <= PathParser::PS_InRootDir)

345:     if (PP.State == PathParser::PS_AtEnd)

354:     auto PP = PathParser::CreateEnd(__pn_);

365:     return *(--PathParser::CreateEnd(__pn_));

381:     auto PP = PathParser::CreateBegin(__pn_);

382:     auto PP2 = PathParser::CreateBegin(__s);

388:     if (PP.State == PP2.State && PP.State == PathParser::PS_AtEnd)

390:     if (PP.State == PathParser::PS_AtEnd)

398:   auto PP = PathParser::CreateBegin(__p.native());

412:     auto PP = PathParser::CreateBegin(__pn_);

424:     it.__state_ = PathParser::PS_AtEnd;

430:   static_assert(__at_end == PathParser::PS_AtEnd, "");

6: package path

76: 		o.Array = obj.(Path)

113: 	Package: "path",

116: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},

163: 	Package: "path",

218: 	Package: "path",

284: 	Package: "path",

334: 	Package: "path",

383: 	Package: "path",

412: 		o.Struct = obj.(Path)

449: 	Package: "path",

452: 		{Declared: "Struct", Type: &schema.Interface{Name: "Path"}},

505: 	Package: "path",

554: 	Package: "path",

592: 		o.Map = obj.(Path)

633: 	Package: "path",

636: 		{Declared: "Map", Type: &schema.Interface{Name: "Path"}},

722: 	Package: "path",

780: 	Package: "path",

812: 		o.Array = obj.(Path)

857: 	Package: "path",

860: 		{Declared: "Array", Type: &schema.Interface{Name: "Path"}},

914: 	Package: "path",

963: 	Package: "path",

3: const path = require('path');

14:   pathMismatch(npmRoot) {

29: function fixPath(filepath) {

49:   const nodePaths = (process.env.NODE_PATH || '').split(path.delimiter).map(fixPath);

7: exports.description = 'NODE_PATH matches the npm root';

11:     return message.get('node-path-npm-failure', {});

15:     let msgPath = 'node-path-path-mismatch';

22:       path: process.env.NODE_PATH,

30:   let fixedPath = path.resolve(path.normalize(filepath.trim()));

44:   if (process.env.NODE_PATH === undefined) {

18:       msgPath += '-windows';

21:     return message.get(msgPath, {

33:     fixedPath = fs.realpathSync(fixedPath);

40:   return fixedPath;

57:     const npmRoot = fixPath(stdout);

60:       cb(errors.pathMismatch(npmRoot));

59:     if (nodePaths.indexOf(npmRoot) < 0) {

22:   const string& path() const { return path_; }

25:   string path_;

17: class ScopedTempPath {

19:   ScopedTempPath() {}

6: #define CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

5: #ifndef CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

20:   // The temporary path will be removed when the object is destroyed.

33:   // Create a temporary file.  If successful, the path will be stored in

34:   // |path_|.  If not, |path_| will be an empty string.

43:   // Create a temporary directory.  If successful, the path will be stored in

44:   // |path_|.  If not, |path_| will be an empty string.

53: #endif  // CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

21:   virtual ~ScopedTempPath();

28:   DISALLOW_COPY_AND_ASSIGN(ScopedTempPath);

31: class ScopedTempFile : public ScopedTempPath {

41: class ScopedTempDir : public ScopedTempPath {

60: class Path : public ThreadCapture<Path> {

56:   std::ostringstream path_;

34: class PathBuilder {

85:   static std::string DelegateRootPath(const Path& path) {

89:   static void DelegateLocalPath(const Path& path, PathBuilder* builder) {

95: class InRootPath : public Path {

97:   InRootPath(const std::string& root_path)

101:   std::string RootPath() const override { return root_path_; }

103:   void AppendLocalPath(PathBuilder* builder) const override {

116: class InLocalPath : public Path {

118:   InLocalPath(const std::string& local_path)

122:   std::string RootPath() const override {

127:   void AppendLocalPath(PathBuilder* builder) const override {

111:   const std::string root_path_;

137:   const std::string local_path_;

36:   std::string String() const { return path_.str(); }

41:         path_.str("");

42:         path_ << component;

45:           path_ << '/';

47:         path_ << component;

86:     return path.RootPath();

90:     path.AppendLocalPath(builder);

94: // Sets the root path, which persists while the instance is in scope.

98:       : root_path_(root_path), capture_to_(this) {}

115: // Sets the local path relative to the current root + local path.

119:       : local_path_(local_path), capture_to_(this) {}

133:     builder->Add(local_path_);

143:   InLocalPath path("bin");

146:     std::cerr << "Installing binary " << Path::Working() << std::endl;

152:   InLocalPath path("lib");

155:     std::cerr << "Installing library " << Path::Working() << std::endl;

160: void InstallProjectIn(const std::string& path) {

161:   InRootPath root(path);

162:   std::cerr << "Installing project in " << Path::Root() << std::endl;

33: // A helper class for building paths from components.

38:   PathBuilder& Add(const std::string& component) {

59: // Tracks persistent root and local paths.

64:       return GetCurrent()->RootPath();

72:       PathBuilder builder;

74:       GetCurrent()->AppendLocalPath(&builder);

82:   virtual std::string RootPath() const = 0;

83:   virtual void AppendLocalPath(PathBuilder* builder) const = 0;

106:       DelegateLocalPath(*previous, builder);

124:     return previous ? DelegateRootPath(*previous) : "";

131:       DelegateLocalPath(*previous, builder);

145:     InLocalPath file(target);

154:     InLocalPath file(target);

11: 	Path

1: package jsonpath

190: func pathMatchOp(q *query, e *Eval, i *Item) queryStateFn {

242: func pathEndValue(q *query, e *Eval, i *Item) queryStateFn {

46: func newEvaluation(tr tokenReader, paths ...*Path) *Eval {

73: func newQuery(p *Path) *query {

75: 		Path:        *p,

99: 	// run path function for each path

300: 			values[q.Path.stringValue] = i

59: 	for _, p := range paths {

76: 		state:       pathMatchOp,

232: 		return pathEndValue

238: 		return pathMatchOp

282: 		return pathMatchOp

284: 	return pathEndValue

208: 							queries:     make([]*query, len(nextOp.dependentPaths)),

212: 						for i, p := range nextOp.dependentPaths {

1: package path;

7:             "path": "/myapp:myName/myapp:myChildNode/aSubChildNode",

8:             "type": "Path"

11:         "requiredType": "Path",

20:         "name": "pathPropertyDef"

1168: PATH := $(SANE_TOOL_PATH):${PATH}

554: TCL_PATH = tclsh

555: TCLTK_PATH = wish

780: 	SHELL_PATH = /bin/sh

783: 	PERL_PATH = /usr/bin/perl

786: 	PYTHON_PATH = /usr/bin/python

792: TEST_SHELL_PATH = $(SHELL_PATH)

535: pathsep = :

1221: 		CC_LD_DYNPATH = -Wl,-rpath,

1223: 		CC_LD_DYNPATH = -R

1166: SANE_TOOL_PATH_SQ = $(subst ','\'',$(SANE_TOOL_PATH))

1167: BROKEN_PATH_FIX = 's|^\# @@BROKEN_PATH_FIX@@$$|git_broken_path_fix $(SANE_TOOL_PATH_SQ)|'

1170: BROKEN_PATH_FIX = '/^\# @@BROKEN_PATH_FIX@@$$/d'

1725: 	procfs_executable_path_SQ = $(subst ','\'',$(PROCFS_EXECUTABLE_PATH))

1830: SHELL_PATH_SQ = $(subst ','\'',$(SHELL_PATH))

1831: TEST_SHELL_PATH_SQ = $(subst ','\'',$(TEST_SHELL_PATH))

1832: PERL_PATH_SQ = $(subst ','\'',$(PERL_PATH))

1833: PYTHON_PATH_SQ = $(subst ','\'',$(PYTHON_PATH))

1834: TCLTK_PATH_SQ = $(subst ','\'',$(TCLTK_PATH))

1893: SHELL_PATH_CQ = "$(subst ",\",$(subst \,\\,$(SHELL_PATH)))"

1894: SHELL_PATH_CQ_SQ = $(subst ','\'',$(SHELL_PATH_CQ))

1960: please_set_SHELL_PATH_to_a_more_modern_shell:

6: # Define SHELL_PATH to a POSIX shell if your /bin/sh is broken.

8: # Define SANE_TOOL_PATH to a colon-separated list of paths to prepend

9: # to PATH if your tools in /usr/bin are broken.

94: # Define HAVE_PATHS_H if you have paths.h and want to use the default PATH

253: # Define NO_R_TO_GCC_LINKER if your gcc does not like "-R/path/lib"

255: # "-Wl,-rpath=/path/lib" is used instead.

295: # Define PERL_PATH to the path of your Perl binary (usually /usr/bin/perl).

305: # Define PYTHON_PATH to the path of your Python binary (often /usr/bin/python

315: # The TCL_PATH variable governs the location of the Tcl interpreter

319: # The TCLTK_PATH variable governs the location of the Tcl/Tk interpreter.

438: # Define TEST_SHELL_PATH if you want to use a shell besides SHELL_PATH for

455: # When using RUNTIME_PREFIX, define PROCFS_EXECUTABLE_PATH if your platform

456: # mounts a "procfs" filesystem capable of resolving the path of the current

457: # executable. If defined, this must be the canonical path for the "procfs"

458: # current executable path.

460: # When using RUNTIME_PREFIX, define HAVE_NS_GET_EXECUTABLE_PATH if your platform

461: # supports calling _NSGetExecutablePath to retrieve the path of the running

465: # the global variable _wpgmptr containing the absolute path of the current

489: 	@$(SHELL_PATH) ./GIT-VERSION-GEN

507: # can be specified as a relative path some/where/else;

509: # runtime figures out where they are based on the path to the executable.

564: export TCL_PATH TCLTK_PATH

717: TEST_BUILTINS_OBJS += test-path-utils.o

779: ifndef SHELL_PATH

782: ifndef PERL_PATH

785: ifndef PYTHON_PATH

789: export PERL_PATH

790: export PYTHON_PATH

913: LIB_OBJS += path.o

1165: ifdef SANE_TOOL_PATH

1220: 		# the runtime dynamic library path.

1321: ifdef ZLIB_PATH

1322: 	BASIC_CFLAGS += -I$(ZLIB_PATH)/include

1323: 	EXTLIBS += -L$(ZLIB_PATH)/$(lib) $(CC_LD_DYNPATH)$(ZLIB_PATH)/$(lib)

1724: ifneq ($(PROCFS_EXECUTABLE_PATH),)

1726: 	BASIC_CFLAGS += '-DPROCFS_EXECUTABLE_PATH="$(procfs_executable_path_SQ)"'

1729: ifdef HAVE_NS_GET_EXECUTABLE_PATH

1730: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH

1737: ifeq ($(TCLTK_PATH),)

1741: ifeq ($(PERL_PATH),)

1745: ifeq ($(PYTHON_PATH),)

1839: # relative to each other and share an installation path.

1892: ifdef SHELL_PATH

1896: BASIC_CFLAGS += -DSHELL_PATH='$(SHELL_PATH_CQ_SQ)'

1919: export DIFF TAR INSTALL DESTDIR SHELL_PATH

1924: SHELL = $(SHELL_PATH)

1958: 	$(QUIET_SUBDIR0)templates $(QUIET_SUBDIR1) SHELL_PATH='$(SHELL_PATH_SQ)' PERL_PATH='$(PERL_PATH_SQ)'

1963: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

2003: 	'-DGIT_HTML_PATH="$(htmldir_relative_SQ)"' \

2004: 	'-DGIT_MAN_PATH="$(mandir_relative_SQ)"' \

2005: 	'-DGIT_INFO_PATH="$(infodir_relative_SQ)"'

2015: 	'-DGIT_HTML_PATH="$(htmldir_relative_SQ)"' \

2016: 	'-DGIT_MAN_PATH="$(mandir_relative_SQ)"' \

2017: 	'-DGIT_INFO_PATH="$(infodir_relative_SQ)"'

2035: 	$(QUIET_GEN)$(SHELL_PATH) ./generate-cmdlist.sh command-list.txt >$@+ && mv $@+ $@

2037: SCRIPT_DEFINES = $(SHELL_PATH_SQ):$(DIFF_SQ):$(GIT_VERSION):\

2038: 	$(localedir_SQ):$(NO_CURL):$(USE_GETTEXT_SCHEME):$(SANE_TOOL_PATH_SQ):\

2039: 	$(gitwebdir_SQ):$(PERL_PATH_SQ):$(SANE_TEXT_GREP):$(PAGER_ENV):\

2043: sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2044:     -e 's|@SHELL_PATH@|$(SHELL_PATH_SQ)|' \

2049:     -e $(BROKEN_PATH_FIX) \

2051:     -e 's|@@PERL@@|$(PERL_PATH_SQ)|g' \

2089: PERL_DEFINES = $(PERL_PATH_SQ):$(PERLLIB_EXTRA_SQ):$(perllibdir_SQ)

2091: PERL_DEFINES := $(PERL_PATH_SQ) $(PERLLIB_EXTRA_SQ) $(perllibdir_SQ)

2100: # Don't export a fixed $(localedir) path; it will be resolved by the Perl header

2111: 	    -e '	s|#!.*perl|#!$(PERL_PATH_SQ)|' \

2156: 	sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2170: 	sed -e '1s|#!.*python|#!$(PYTHON_PATH_SQ)|' \

2177: 	sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2287: 	'-DGIT_EXEC_PATH="$(gitexecdir_SQ)"' \

2288: 	'-DGIT_LOCALE_PATH="$(localedir_relative_SQ)"' \

2306: 	-DGIT_LOCALE_PATH='"$(localedir_relative_SQ)"'

2536: 	@echo SHELL_PATH=\''$(subst ','\'',$(SHELL_PATH_SQ))'\' >$@+

2537: 	@echo TEST_SHELL_PATH=\''$(subst ','\'',$(TEST_SHELL_PATH_SQ))'\' >>$@+

2538: 	@echo PERL_PATH=\''$(subst ','\'',$(PERL_PATH_SQ))'\' >>$@+

2540: 	@echo PYTHON_PATH=\''$(subst ','\'',$(PYTHON_PATH_SQ))'\' >>$@+

2590: ### Detect Python interpreter path changes

2592: TRACK_PYTHON = $(subst ','\'',-DPYTHON_PATH='$(PYTHON_PATH_SQ)')

2609: 	$(QUIET_GEN)sed -e '1s|#!.*/sh|#!$(SHELL_PATH_SQ)|' \

2927: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell

254: # that tells runtime paths to dynamic libraries;

600: # scripts to unexpected places.  If you like CDPATH, define it for your

602: unexport CDPATH

778: # Set paths to tools early so that they can be used for version tests.

806: LIB_OBJS += abspath.o

914: LIB_OBJS += pathspec.o

1217: ifndef CC_LD_DYNPATH

1254: 	EXTLIBS += -L$(LIBPCREDIR)/$(lib) $(CC_LD_DYNPATH)$(LIBPCREDIR)/$(lib)

1271: 		# Try "-Wl,-rpath=$(CURLDIR)/$(lib)" in such a case.

1273: 		CURL_LIBCURL = -L$(CURLDIR)/$(lib) $(CC_LD_DYNPATH)$(CURLDIR)/$(lib) -lcurl

1310: 			EXPAT_LIBEXPAT = -L$(EXPATDIR)/$(lib) $(CC_LD_DYNPATH)$(EXPATDIR)/$(lib) -lexpat

1331: 		OPENSSL_LINK = -L$(OPENSSLDIR)/$(lib) $(CC_LD_DYNPATH)$(OPENSSLDIR)/$(lib)

1358: 			ICONV_LINK = -L$(ICONVDIR)/$(lib) $(CC_LD_DYNPATH)$(ICONVDIR)/$(lib)

1645: ifdef HAVE_PATHS_H

1646: 	BASIC_CFLAGS += -DHAVE_PATHS_H

1838: # RUNTIME_PREFIX's resolution logic requires resource paths to be expressed

2133: 	sed -e 's=@@PATHSEP@@=$(pathsep)=g' \

3004: GCOVFLAGS = --preserve-paths --branch-probabilities --all-blocks

1305: 	char *path;

1531: 	struct strbuf path;

520: #define READ_GITFILE_ERR_NO_PATH 6

1144: static inline int is_absolute_path(const char *path)

1299: 	struct strbuf symlink_path;

1315: #define GET_OID_RECORD_PATH     0200

419: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"

432: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"

433: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"

434: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"

435: #define GIT_ICASE_PATHSPECS_ENVIRONMENT "GIT_ICASE_PATHSPECS"

15: #include "path.h"

350: #define read_cache_from(path) read_index_from(&the_index, (path), (get_git_dir()))

360: #define remove_file_from_cache(path) remove_file_from_index(&the_index, (path))

361: #define add_to_cache(path, st, flags) add_to_index(&the_index, (path), (st), (flags))

362: #define add_file_to_cache(path, flags) add_file_to_index(&the_index, (path), (flags))

373: #define read_blob_data_from_cache(path, sz) read_blob_data_from_index(&the_index, (path), (sz))

436: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"

488: extern void set_git_dir(const char *path);

497:  * Return true if the given path is a git directory; note that this _just_

499:  * is a repository, you must feed that path, not just "foo".

501: extern int is_git_directory(const char *path);

504:  * Return 1 if the given path is the root of a git repository or

513: extern int is_nonbare_repository_dir(struct strbuf *path);

523: extern void read_gitfile_error_die(int error_code, const char *path, const char *dir);

524: extern const char *read_gitfile_gently(const char *path, int *return_error_code);

525: #define read_gitfile(path) read_gitfile_gently((path), NULL)

527: #define resolve_gitdir(path) resolve_gitdir_gently((path), NULL)

546: extern char *prefix_path(const char *prefix, int len, const char *path);

547: extern char *prefix_path_gently(const char *prefix, int len, int *remaining, const char *path);

550:  * Concatenate "prefix" (if len is non-zero) and "path", with no

552:  * Unlike prefix_path, this should be used if the named file does

559: extern char *prefix_filename(const char *prefix, const char *path);

566: extern int path_inside_repo(const char *prefix, const char *path);

601: extern int do_read_index(struct index_state *istate, const char *path,

603: extern int read_index_from(struct index_state *, const char *path,

645: extern int verify_path(const char *path, unsigned mode);

683: extern int remove_file_from_index(struct index_state *, const char *path);

690:  * These two are used to add the contents of the file at path

693:  * that has already run lstat(2) on the path can call

698: extern int add_to_index(struct index_state *, const char *path, struct stat *, int flags);

699: extern int add_file_to_index(struct index_state *, const char *path, int flags);

701: ...(2 bytes skipped)...tern struct cache_entry *make_cache_entry(unsigned int mode, const unsigned char *sha1, const char *path, int stage, unsigned int refresh_options);

726: ...(3 bytes skipped)...ern int index_fd(struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);

727: extern int index_path(struct object_id *oid, const char *path, struct stat *st, unsigned flags);

772: extern int quote_path_fully;

783: extern const char *git_hooks_path;

921:  * Read the repository format characteristics from the config file "path" into

926: int read_repository_format(struct repository_format *format, const char *path);

937:  * Check the repository format version in the path found in get_git_dir(),

1068: int adjust_shared_perm(const char *path);

1071:  * Create the directory containing the named path, using care to be

1077:  * path existed at one point during the function call and then

1083:  * safe_create_leading_directories() temporarily changes path while it

1085:  * safe_create_leading_directories_const() doesn't modify path, even

1095: enum scld_error safe_create_leading_directories(char *path);

1096: enum scld_error safe_create_leading_directories_const(const char *path);

1100:  * expected to do something that makes dirname(path) permanent despite

1103:  * path, but alternatively it could create another file in that

1109:  * - ENOENT -- dirname(path) does not exist. In this case,

1110:  *             raceproof_create_file() tries creating dirname(path)

1126: typedef int create_file_fn(const char *path, void *cb);

1129:  * Create a file in dirname(path) by calling fn, creating leading

1132:  * contains path. See the documentation for create_file_fn for more

1139: int raceproof_create_file(const char *path, create_file_fn fn, void *cb);

1141: int mkdir_in_gitdir(const char *path);

1142: extern char *expand_user_path(const char *path, int real_home);

1143: const char *enter_repo(const char *path, int strict);

1146: 	return is_dir_sep(path[0]) || has_dos_drive_prefix(path);

1149: char *strbuf_realpath(struct strbuf *resolved, const char *path,

1151: const char *real_path(const char *path);

1152: const char *real_path_if_valid(const char *path);

1153: char *real_pathdup(const char *path, int die_on_error);

1154: const char *absolute_path(const char *path);

1155: char *absolute_pathdup(const char *path);

1156: const char *remove_leading_path(const char *in, const char *prefix);

1157: const char *relative_path(const char *in, const char *prefix, struct strbuf *sb);

1158: int normalize_path_copy_len(char *dst, const char *src, int *prefix_len);

1159: int normalize_path_copy(char *dst, const char *src);

1160: int longest_ancestor_length(const char *path, struct string_list *prefixes);

1161: char *strip_path_suffix(const char *path, const char *suffix);

1162: int daemon_avoid_alias(const char *path);

1231:  * Open the loose object at path, check its hash, and return the contents,

1237: int read_loose_object(const char *path,

1296: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,

1301: 	 * If GET_OID_RECORD_PATH is set, this will record path (if any)

1539: 	strbuf_release(&cache->path);

1542: extern int has_symlink_leading_path(const char *name, int len);

1543: extern int threaded_has_symlink_leading_path(struct cache_def *, const char *, int);

1544: extern int check_leading_path(const char *name, int len);

1545: extern int has_dirs_only_path(const char *name, int len, int prefix_len);

1580:  * directory "path", triggering the following callbacks:

1596:  * In the "buf" variant, "path" is a strbuf which will also be used as a

1601: 				 const char *path,

1604: 				const char *path,

1607: 				 const char *path,

1610: 				struct strbuf *path,

1615: int for_each_loose_file_in_objdir(const char *path,

1620: int for_each_loose_file_in_objdir_buf(struct strbuf *path,

1741:  * Open (and truncate) the file at path, write the contents of buf to it,

1744: extern void write_file_buf(const char *path, const char *buf, size_t len);

1751:  *   write_file(path, "counter: %d", ctr);

1754: extern void write_file(const char *path, const char *fmt, ...);

1860:  * Returns 1 if the path is a regular file (or a symlink to a regular

1865: int stat_validity_check(struct stat_validity *sv, const char *path);

192: /* used to temporarily mark paths matched by pathspecs */

219: struct pathspec;

351: #define read_cache_preload(pathspec) read_index_preload(&the_index, (pathspec))

372: #define unmerge_cache(pathspec) unmerge_index(&the_index, pathspec)

600: extern int read_index_preload(struct index_state *, const struct pathspec *pathspec);

753: extern int refresh_index(struct index_state *, unsigned int flags, const struct pathspec *pathspec, char *seen, const char *header_msg);

1526: extern int checkout_entry(struct cache_entry *ce, const struct checkout *state, char *topath);

1790: int add_files_to_cache(const char *prefix, const struct pathspec *pathspec, int flags);

109:       "path": "node_modules/cz-conventional-changelog"

27:     "canonical-path": "0.0.2",

321:     path: 4

466:   var pathVertexPositionBuffer;

467:   var pathVertexColorBuffer;

1076:     function SubPath(x, y) {

1082:     gl.beginPath = function beginPath() {

1087:     gl.closePath = function closePath() {

1130:     function fillSubPath(index) {

1159:     function strokeSubPath(index) {

1194:     gl.isPointInPath = function isPointInPath() {};

1074:     var subPaths = [];

483:     pathVertexPositionBuffer  = gl.createBuffer();

484:     pathVertexColorBuffer     = gl.createBuffer();

1086:     // Mark last subpath as closed and create a new subpath with the same starting point as the previous subpath

1089:         // Mark last subpath closed.

1090:         var prevPath = subPaths[subPaths.length -1], startX = prevPath.verts[0], startY = prevPath.verts[1];

1091:         prevPath.closed = true;

1093:         // Create new subpath using the starting position of previous subpath

1094:         var newPath = new SubPath(startX, startY);

1095:         subPaths.push(newPath);

1099:     // Create a new subpath with the specified point as its first (and only) point

1101:       subPaths.push(new SubPath(x, y));

1108:         // Create a new subpath if none currently exist

1119:     // Adds a closed rect subpath and creates a new subpath

1125:       gl.closePath();

1134:       var subPath = subPaths[index];

1135:       var verts = subPath.verts;

1137:       gl.bindBuffer(gl.ARRAY_BUFFER, pathVertexPositionBuffer);

1155:         fillSubPath(i);

1163:       var subPath = subPaths[index];

1164:       var verts = subPath.verts;

1166:       gl.bindBuffer(gl.ARRAY_BUFFER, pathVertexPositionBuffer);

1177:       if (subPath.closed) {

1188:         strokeSubPath(i);

1081:     // Empty the list of subpaths so that the context once again has zero subpaths

1083:       subPaths.length = 0;

1088:       if (subPaths.length) {

1105:       if (subPaths.length) {

1106:         subPaths[subPaths.length -1].verts.push(x, y, 0, 0);

1154:       for(var i = 0; i < subPaths.length; i++) {

1187:       for(var i = 0; i < subPaths.length; i++) {

127:   required string path = 1;

482:   required string path = 1;

524:   optional string path = 2;

648:   required string path = 1;

656:   required string path = 1;

664:   required string path = 1;

703:   required string path = 1;

784:   required string path = 1;

814:   optional string path = 3;

819:   required string path = 2;

706:   optional string targetPath = 1;

749:   required string snapshotPath = 1;

988:   rpc getEZForPath(GetEZForPathRequestProto)

989:       returns(GetEZForPathResponseProto);

151:       "path": "./lighthouse-extension/dist/scripts/lighthouse-background.js",

155:       "path": "./lighthouse-viewer/dist/src/viewer.js",

169:       "path": "./node_modules/cz-customizable"

63: ...(45 bytes skipped)...cli -A=./lighthouse-core/test/results/artifacts --throttling-method=devtools --output=json --output-path=./lighthouse-core/test/results/sample_v2.json && node lighthouse-core/scripts/cleanup-LHR-for-diff....(71 bytes skipped)...

56:   required string path = 1;

91:   required string path = 1;

421:   optional string path = 3;

441:   required bytes path = 2;          // local name of inode encoded java UTF8

540:   required bytes parent_fullpath = 4;

554:   required bytes fullpath = 1;

556:   optional bytes targetPath = 3;

574:   required bytes fullpath = 1;

577:   optional bytes targetPath = 4;

582:   required bytes startPath = 1;

418: message HdfsPathHandleProto {

51:   storage. The path, offset and length will result in ranged read. The nonce

532:  * the full path of the parent directory. 

563:   // full path of the directory where snapshots were taken

589:   // full path of the directory where snapshots were taken

206:  * Contains a list of paths corresponding to corrupt files and a cookie

11: const path = require('path');

106:     outputPath: baseOutputPath,

129:     outputPath: baseOutputPath,

249:     outputPath: baseOutputPath,

277:     outputPath: baseOutputPath,

297:     outputPath: baseOutputPath,

321:     outputPath: baseOutputPath,

343:     outputPath: global.WF.src.content,

38:         outputPath: path.join(opts.outputPath, year),

99:   const baseOutputPath = path.join(global.WF.src.content, section);

108:   const startPath = path.join(global.WF.src.content, section);

122:   const baseOutputPath = path.join(global.WF.src.content, section);

131:   const startPath = path.join(global.WF.src.content, 'showcase');

137:   options.template = path.join(global.WF.src.templates, 'showcase/index.yaml');

145:   options.template = path.join(global.WF.src.templates, 'showcase/region.md');

146:   options.outputPath = path.join(baseOutputPath, 'region');

151:   options.template = path.join(global.WF.src.templates, 'showcase/vertical.md');

152:   options.outputPath = path.join(baseOutputPath, 'vertical');

157:   options.outputPath = path.join(baseOutputPath, 'tags');

165:     options.outputPath = path.join(baseOutputPath, year);

192:     let template = path.join(global.WF.src.templates, 'shows', 'index.md');

193:     let outputFile = path.join(global.WF.src.content, 'shows', 'index.md');

198:     template = path.join(global.WF.src.templates, 'shows', 'latest.html');

199:     outputFile = path.join(

205:     template = path.join(

207:     outputFile = path.join(global.WF.src.content, '_index-latest-show.html');

225:           outputPath: path.join(global.WF.src.content, 'shows', year),

237:   const baseOutputPath = path.join(global.WF.src.content, src);

264:   const baseOutputPath = path.join(global.WF.src.content, src);

292:   const baseOutputPath = path.join(global.WF.src.content, section);

299:   const startPath = path.join(global.WF.src.content, section);

314:   const baseOutputPath = path.join(global.WF.src.content, section);

323:   const startPath = path.join(global.WF.src.content, section);

329:   options.outputPath = path.join(baseOutputPath, 'tags');

333:     options.outputPath = path.join(baseOutputPath, year);

349:   const template = path.join(

352:   const outFile = path.join(

109:   const files = wfHelper.getFileList(startPath, ['**/*.md']);

133:   let files = wfHelper.getFileList(startPath, patterns);

174:   options.outputPath = baseOutputPath;

252:   let files = wfHelper.getFileList(baseOutputPath, ['*.md', '!index.md']);

280:   let files = wfHelper.getFileList(baseOutputPath, ['*.md', '!index.md']);

300:   let files = wfHelper.getFileList(startPath, ['**/*.md']);

325:   let files = wfHelper.getFileList(startPath, patterns);

411: 	Path uint64

410: 	// Path is a unique server identifier for this path (e.g. inode).

416: 	return fmt.Sprintf("QID{Type: %d, Version: %d, Path: %d}", q.Type, q.Version, q.Path)

423: 	q.Path = b.Read64()

430: 	b.Write64(q.Path)

433: // QIDGenerator is a simple generator for QIDs that atomically increments Path

437: 	// to provide unique Path values for QIDs.

441: // Get returns a new 9P unique ID with a unique Path given a QID type.

450: 		Path:    atomic.AddUint64(&q.uids, 1),

1343: google.maps.DirectionsStep.prototype.path;

3872: google.maps.PathElevationRequest.prototype.path;

3942: google.maps.PolyMouseEvent.prototype.path;

4209: google.maps.PolylineOptions.prototype.path;

5044: google.maps.Symbol.prototype.path;

1272: google.maps.DirectionsRoute.prototype.overview_path;

1604: google.maps.ElevationService.prototype.getElevationAlongPath = function(request, callback) {};

3867: google.maps.PathElevationRequest = function() {};

3974: google.maps.Polygon.prototype.getPath = function() {};

4014: google.maps.Polygon.prototype.setPath = function(path) {};

4071: google.maps.PolygonOptions.prototype.paths;

4128: google.maps.Polyline.prototype.getPath = function() {};

4163: google.maps.Polyline.prototype.setPath = function(path) {};

5630: google.maps.geometry.encoding.decodePath = function(encodedPath) {};

5636: google.maps.geometry.encoding.encodePath = function(path) {};

3979: google.maps.Polygon.prototype.getPaths = function() {};

4020: google.maps.Polygon.prototype.setPaths = function(paths) {};

4011: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path

4160: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path

5633:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5660:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5664: google.maps.geometry.spherical.computeArea = function(path, radius) {};

5682:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5686: google.maps.geometry.spherical.computeLength = function(path, radius) {};

1600:  * @param {!google.maps.PathElevationRequest} request

3877: google.maps.PathElevationRequest.prototype.samples;

4017: ...(127 bytes skipped)...google.maps.LatLng|google.maps.LatLngLiteral>>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} paths

5042:  * @type {google.maps.SymbolPath|string}

5074: google.maps.SymbolPath = {

5627:  * @param {string} encodedPath

1705: var path = require('path');

1711:   includePaths: [

36:  *   {@code <script type="text/javascript" src="/path/to/prettify.js"></script>}

1713:     path.resolve(__dirname, '../styles')

1710:   // include paths for css preprocessor support

10: const path = require('path')

43:     path: config.urlRoot + 'socket.io/',

190:     if (config.browserConsoleLogOptions && config.browserConsoleLogOptions.path) {

193:       const configPath = config.browserConsoleLogOptions.path

370:     const child = spawn(process.argv[0], [path.resolve(__dirname, '../lib/detached.js'), tmpFile.name], {

194:       this.log.info(`Writing browser console to file: ${configPath}`)

195:       const browserLogFile = fs.openSync(configPath, 'w+')

1406: google.maps.DirectionsStep.prototype.path;

4039: google.maps.PathElevationRequest.prototype.path;

4109: google.maps.PolyMouseEvent.prototype.path;

4387: google.maps.PolylineOptions.prototype.path;

5258: google.maps.Symbol.prototype.path;

1335: google.maps.DirectionsRoute.prototype.overview_path;

1667: google.maps.ElevationService.prototype.getElevationAlongPath = function(request, callback) {};

4034: google.maps.PathElevationRequest = function() {};

4145: google.maps.Polygon.prototype.getPath = function() {};

4187: google.maps.Polygon.prototype.setPath = function(path) {};

4244: google.maps.PolygonOptions.prototype.paths;

4305: google.maps.Polyline.prototype.getPath = function() {};

4341: google.maps.Polyline.prototype.setPath = function(path) {};

5815: google.maps.geometry.encoding.decodePath = function(encodedPath) {};

5821: google.maps.geometry.encoding.encodePath = function(path) {};

4151: google.maps.Polygon.prototype.getPaths = function() {};

4193: google.maps.Polygon.prototype.setPaths = function(paths) {};

4184: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path

4338: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path

5818:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5845:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5849: google.maps.geometry.spherical.computeArea = function(path, opt_radius) {};

5867:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5871: google.maps.geometry.spherical.computeLength = function(path, opt_radius) {};

1663:  * @param {google.maps.PathElevationRequest|Object.<string>} request

4044: google.maps.PathElevationRequest.prototype.samples;

4190: ...(127 bytes skipped)...google.maps.LatLng|google.maps.LatLngLiteral>>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} paths

5256:  * @type {google.maps.SymbolPath|string}

5288: google.maps.SymbolPath = {

5812:  * @param {string} encodedPath

53: function va(b,a){var c=Gb.exec(b),c={protocol:c[1],host:c[3],port:G(c[5])||Hb[c[1]]||null,path...(120 bytes skipped)...,c){return b+"://"+a+(c==Hb[b]?"":":"+c)}function Fc(b,a,c){var d=va(b);return decodeURIComponent(d.path...(80 bytes skipped)...,a.lastIndexOf("/"))+d.hash.substr(c.length)}function Gc(b,a,c){var d=va(b);if(decodeURIComponent(d.path)==

122: ...(57 bytes skipped)...ce:!1,absUrl:Ka("$$absUrl"),url:function(a,c){if(v(a))return this.$$url;var d=ac.exec(a);d[1]&&this.path...(60 bytes skipped)...");this.hash(d[5]||"",c);return this},protocol:Ka("$$protocol"),host:Ka("$$host"),port:Ka("$$port"),path:Jb("$$path",function(a){return a.charAt(0)=="/"?a:"/"+a}),search:function(a,c){if(v(a))return this.$$search;x(...(69 bytes skipped)...

32: ...(64 bytes skipped)...ar V={},z="",M=f.baseHref();f.cookies=function(a,b){var d,e,f,g;if(a)if(b===s)i.cookie=escape(a)+"=;path="+M+";expires=Thu, 01 Jan 1970 00:00:00 GMT";else{if(F(b))d=(i.cookie=escape(a)+"="+escape(b)+";path="+M).length+1,d>4096&&c.warn("Cookie '"+a+"' possibly not set or overflowed because it was too larg...(138 bytes skipped)...

54: ...(11 bytes skipped)...else{var e=d.search&&"?"+d.search||"",g=d.hash&&"#"+d.hash||"",h=a.substr(0,a.lastIndexOf("/")),f=d.path.substr(h.length);if(d.path.indexOf(h)!==0)throw y('Invalid url "'+b+'", missing path...(45 bytes skipped)...st,d.port)+a+"#"+c+f+e+g}}function hb(b,a,c){a=a||"";this.$$parse=function(b){var c=va(b,this);if(c.path.indexOf(a)!==0)throw y('Invalid url "'+b+'", missing path prefix "'+a+'" !');this.$$path=decodeURIComponent(c.path.substr(a.length));this.$$search=Ya(c.search);

55: ...(77 bytes skipped)...ompose=function(){var b=pb(this.$$search),c=this.$$hash?"#"+$a(this.$$hash):"";this.$$url=Fb(this.$$path)+(b?"?"+b:"")+c;this.$$absUrl=ka(this.$$protocol,this.$$host,this.$$port)+a+this.$$url};this.$$rewr...(220 bytes skipped)...

56: a+'" !');d=c.path+(c.search?"?"+c.search:"");c=Hc.exec((c.hash||"").substr(a.length));this.$$path...(159 bytes skipped)...ompose=function(){var b=pb(this.$$search),c=this.$$hash?"#"+$a(this.$$hash):"";this.$$url=Fb(this.$$path)+(b?"?"+b:"")+c;this.$$absUrl=ka(this.$$protocol,this.$$host,this.$$port)+d+(this.$$url?"#"+a+this....(61 bytes skipped)...

58: ...(218 bytes skipped)...ew hb(Fc(k,i,b),j,l):new Ib(Gc(k,i,b),b,l,i.substr(j.length+1))):(l=ka(l.protocol,l.host,l.port)+(l.path||"")+(l.search?"?"+l.search:"")+"#"+b+"/",f=new Ja(k,b,l));g.bind("click",function(a){if(!a.ctrlKey...(84 bytes skipped)...

79: ...(7 bytes skipped)... if(b||i)n=!1,a.$broadcast("$routeChangeStart",b,i),(p.current=b)&&b.redirectTo&&(F(b.redirectTo)?c.path(k(b.redirectTo,b.params)).search(b.params).replace():c.url(b.redirectTo(b.pathParams,c.path(),c.search())).replace()),e.when(b).then(function(){if(b){var a=[],c=[],d;m(b.resolve||{},function(...(224 bytes skipped)...

80: ...(174 bytes skipped)...ent&&a.$broadcast("$routeChangeError",b,i,c)})}function j(){var a,d;m(b,function(b,e){if(!d&&(a=l(c.path(),e)))d=ya(b,{params:D({},c.search(),a),pathParams:a}),d.$route=b});return d||b[null]&&ya(b[null],{params:{},pathParams:{}})}function k(a,b){var c=[];m((a||"").split(":"),function(a,d){if(d==0)c.push(a);else{var e...(22 bytes skipped)...

78: ...(315 bytes skipped)...ache",function(a,c,d,e,g,h,f){function i(){var b=j(),i=p.current;if(b&&i&&b.$route===i.$route&&ga(b.pathParams,i.pathParams)&&!b.reloadOnSearch&&!n)i.params=b.params,U(i.params,d),a.$broadcast("$routeUpdate",

778:   uint32_t path;

775: struct rpath_command {

1188:   sys::swapByteOrder(r.path);

1185: inline void swapStruct(rpath_command &r) {

1344: google.maps.DirectionsStep.prototype.path;

3974: google.maps.PathElevationRequest.prototype.path;

4043: google.maps.PolyMouseEvent.prototype.path;

4321: google.maps.PolylineOptions.prototype.path;

5174: google.maps.Symbol.prototype.path;

1273: google.maps.DirectionsRoute.prototype.overview_path;

1605: google.maps.ElevationService.prototype.getElevationAlongPath = function(request, callback) {};

3969: google.maps.PathElevationRequest = function() {};

4079: google.maps.Polygon.prototype.getPath = function() {};

4121: google.maps.Polygon.prototype.setPath = function(path) {};

4178: google.maps.PolygonOptions.prototype.paths;

4239: google.maps.Polyline.prototype.getPath = function() {};

4275: google.maps.Polyline.prototype.setPath = function(path) {};

5723: google.maps.geometry.encoding.decodePath = function(encodedPath) {};

5729: google.maps.geometry.encoding.encodePath = function(path) {};

4085: google.maps.Polygon.prototype.getPaths = function() {};

4127: google.maps.Polygon.prototype.setPaths = function(paths) {};

4118: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path

4272: ...(5 bytes skipped)...aram {google.maps.MVCArray<google.maps.LatLng>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} path

5726:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5753:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5757: google.maps.geometry.spherical.computeArea = function(path, opt_radius) {};

5775:  * @param {Array<google.maps.LatLng>|google.maps.MVCArray<google.maps.LatLng>} path

5779: google.maps.geometry.spherical.computeLength = function(path, opt_radius) {};

1601:  * @param {google.maps.PathElevationRequest|Object.<string>} request

3979: google.maps.PathElevationRequest.prototype.samples;

4124: ...(127 bytes skipped)...google.maps.LatLng|google.maps.LatLngLiteral>>|Array<google.maps.LatLng|google.maps.LatLngLiteral>} paths

5172:  * @type {google.maps.SymbolPath|string}

5204: google.maps.SymbolPath = {

5720:  * @param {string} encodedPath

168: 	Path   [UnixPathMax]int8

163: const UnixPathMax = 108

160: // UnixPathMax is the maximum length of the path in an AF_UNIX socket.

154:   optional string path = 3;

450:     optional string path = 2;

529:     optional string path = 2;

1427:         PATH = 1;

1435:       message Path {

1451:       optional Path path = 2;

2902:       required string path = 1;

2922:       required string path = 2;

3499:   required string path = 1;

3531:   optional string path = 1;

2860:   required string container_path = 1;

2867:   optional string host_path = 2;

2884:       HOST_PATH = 4;

2885:       SANDBOX_PATH = 2;

2934:     optional HostPath host_path = 5;

2935:     optional SandboxPath sandbox_path = 3;

2901:     message HostPath {

2911:     message SandboxPath {

443:   // http://<host>:port/path. Note that <host> is not configurable and is

449:     // HTTP request path.

515:   // scheme://<host>:port/path. Note that <host> is not configurable and is

528:     // HTTP request path.

675:     // must be a relative path), the local copy will be stored in that

1415:     // 'container_path' inside 'volume'. The 'host_path' inside

1436:         // Path to the folder (e.g., /mnt/raid/disk0). If the path is a

1437:         // relative path, it is relative to the agent work directory.

1445:         // Path to mount point (e.g., /mnt/raid/disk0). If the path is a

1446:         // relative path, it is relative to the agent work directory.

1970:     // created on ROOT/PATH disk.

1978:     // created on ROOT/PATH disk.

2856:   // Path pointing to a directory or file in the container. If the

2857:   // path is a relative path, it is relative to the container work

2858:   // directory. If the path is an absolute path, that path must

2865:   // Absolute path pointing to a directory or file on the host or a

2866:   // path relative to the container work directory.

2900:     // Absolute path pointing to a directory or file on the host.

2906:     // Describe a path from a container's sandbox. The container can

2920:       // A path relative to the corresponding container's sandbox.

2938:     // internal) downloads the secret and makes it available at container_path.

3498:   // Absolute path to the file.

2845:  * versa. Both paths can either refer to a directory or a file.

106:     CGMutablePathRef path;

273: void x3closepath(x3dc *dc);

573: path(#httpd{mochi_req=MochiReq}) ->

20:     qs_value/3, qs/1, qs_json_value/3, path/1, absolute_uri/2, body_length/1,

157:     % for the path, use the raw path with the query string and fragment

159:     RawUri = MochiReq:get(raw_path),

160:     {"/" ++ Path, _, _} = mochiweb_util:urlsplit_path(RawUri),

162:     % get requested path

163:     RequestedPath = case MochiReq:get_header_value("x-couchdb-vhost-path") of

165:             case MochiReq:get_header_value("x-couchdb-requested-path") of

216:         path_parts = [list_to_binary(chttpd:unquote(Part))

217:                 || Part <- string:tokens(Path, "/")],

218:         requested_path_parts = [?l2b(unquote(Part))

276:         case HttpReq#httpd.path_parts of

281:     RawUri = MochiReq:get(raw_path),

328:         MochiReq:get(raw_path),

384:     RawUri = MochiReq:get(raw_path),

397: possibly_hack(#httpd{path_parts=[<<"_replicate">>]}=Req) ->

533: partition(Path) ->

534:     mochiweb_util:partition(Path, "/").

574:     MochiReq:get(path).

576: absolute_uri(#httpd{mochi_req=MochiReq, absolute_uri = undefined}, Path) ->

610:     Scheme ++ "://" ++ Host ++ Path;

611: absolute_uri(#httpd{absolute_uri = URI}, Path) ->

612:     URI ++ Path.

900:         <<"At least one path segment of `", DbName/binary, "` is too long.">>};

972:                                 % Redirect to the path the user requested, not

974:                                 UrlReturnRaw = case MochiReq:get_header_value("x-couchdb-vhost-path") of

976:                                     MochiReq:get(path);

1044: send_redirect(Req, Path) ->

1045:     Headers = [{"Location", chttpd:absolute_uri(Req, Path)}],

219:                 || Part <- string:tokens(RequestedPath, "/")]

548: serve_file(Req, RelativePath, DocumentRoot) ->

549:     serve_file(Req, RelativePath, DocumentRoot, []).

551: serve_file(Req0, RelativePath0, DocumentRoot0, ExtraHeaders) ->

552:     couch_httpd:serve_file(Req0, RelativePath0, DocumentRoot0, ExtraHeaders).

977:                                 VHostPath ->

978:                                     VHostPath

1224: test_log_request(RawPath, UserCtx) ->

1226:     MochiReq = mochiweb_request:new(socket, [], 'POST', RawPath, version, Headers),

152:   optional string path = 3;

448:     optional string path = 2;

527:     optional string path = 2;

1419:         PATH = 1;

1427:       message Path {

1443:       optional Path path = 2;

2894:       required string path = 1;

2914:       required string path = 2;

3491:   required string path = 1;

3523:   optional string path = 1;

2852:   required string container_path = 1;

2859:   optional string host_path = 2;

2876:       HOST_PATH = 4;

2877:       SANDBOX_PATH = 2;

2926:     optional HostPath host_path = 5;

2927:     optional SandboxPath sandbox_path = 3;

2893:     message HostPath {

2903:     message SandboxPath {

441:   // http://<host>:port/path. Note that <host> is not configurable and is

447:     // HTTP request path.

513:   // scheme://<host>:port/path. Note that <host> is not configurable and is

526:     // HTTP request path.

673:     // must be a relative path), the local copy will be stored in that

1407:     // 'container_path' inside 'volume'. The 'host_path' inside

1428:         // Path to the folder (e.g., /mnt/raid/disk0). If the path is a

1429:         // relative path, it is relative to the agent work directory.

1437:         // Path to mount point (e.g., /mnt/raid/disk0). If the path is a

1438:         // relative path, it is relative to the agent work directory.

1962:     // created on ROOT/PATH disk.

1970:     // created on ROOT/PATH disk.

2848:   // Path pointing to a directory or file in the container. If the

2849:   // path is a relative path, it is relative to the container work

2850:   // directory. If the path is an absolute path, that path must

2857:   // Absolute path pointing to a directory or file on the host or a

2858:   // path relative to the container work directory.

2892:     // Absolute path pointing to a directory or file on the host.

2898:     // Describe a path from a container's sandbox. The container can

2912:       // A path relative to the corresponding container's sandbox.

2930:     // internal) downloads the secret and makes it available at container_path.

3490:   // Absolute path to the file.

2837:  * versa. Both paths can either refer to a directory or a file.

646:   optional string path = 2;

491:   optional PathSpec src_path = 3;

494:   optional PathSpec dest_path = 5;

656:   optional PathSpec nested_path = 5;

673:   optional Options path_options = 7 [(sem_type) = {

744:   repeated string path_list = 1[(sem_type) = {

1180:   optional string write_path = 2;  // Path to write the binary to.

1314:   optional string path_glob = 13 [(sem_type) = {

1319:   optional string path_regex = 3 [(sem_type) = {

519:   optional PathSpec pathspec = 6;

635: message PathSpec {

636:   enum PathType {

644:   optional PathType pathtype = 1 [default = UNSET];

733:   optional PathSpec pathspec = 1;

738:   optional PathSpec pathspec = 1;

747:   optional PathSpec.PathType pathtype = 2 [(sem_type) = {

828:   optional PathSpec pathspec = 18 [(sem_type) = {

1104:   optional PathSpec pathspec = 1;

1117:   optional PathSpec pathspec = 3;

1212:   optional PathSpec pathspec = 1 [(sem_type) = {

1310:   optional PathSpec pathspec = 2 [(sem_type) = {

1395:   optional PathSpec pathspec = 1 [(sem_type) = {

2051:   optional PathSpec pathspec = 1;

488: message CopyPathToFile {

472: //  - src_path: source pathspec to copy from

473: //  - dest_path: unset (GRRTempfile will create a random filename in dest_dir)

482: //  - src_path: source pathspec from request

484: //  - dest_path: on-disk output pathspec

633: // A message to encode a filesystem path (maybe for raw access)

667:     // The path component is a regular expression.

683:   // file - instead of the path.

731: // Ask the ListDir action to list all files in path (returns StatEntry)

748:       description: "Type of path to call statfs on.",

752: // A stat() record for a given path

756:   // optional string aff4path = 1;

829:       description: "The path specification to this file on the client."

1311:       description: "The base path to recursive search from ",

1321:       description: "This matches the filename. Overrides the path_glob.",

1400:       description: "A path into the plist to base the filter on",

1482:   // optional string path = 1;

1513:   // optional string path = 1;

504: //     - pathspec will be set to the desired file to read

670:     // Indicates that this pathspec represents any subdirectory recursively.

727:       description: "Indicates that this pathspec already contains a "

745:       description: "List of paths for statfs."

827:   // The pathspec which the client can use to re-reach this file.

1213:       description: "The pathspec for the file to retrieve.",

1243:   optional PathSpec target = 1 [(sem_type) = {

1396:       description: "The pathspec for the plist file to query.",

467: // CopyPathToFile request and response.

3: PATH := $(shell npm bin):$(PATH)

1024: class JSON_API Path {

993: class JSON_API PathArgument {

291: class Path;

990: /** \brief Experimental and untested: represents an element of the "path" to

995:   friend class Path;

1013: /** \brief Experimental and untested: represents a "path" to access a node.

1026:   Path(const std::string& path,

1035:   /// Creates the "path" to access the specified node and returns a reference on

1043:   void makePath(const std::string& path, const InArgs& in);

1044:   void addPathInArg(const std::string& path,

1048:   void invalidPath(const std::string& path, int location);

292: class PathArgument;

997:   PathArgument();

998:   PathArgument(ArrayIndex index);

999:   PathArgument(const char* key);

1000:   PathArgument(const std::string& key);

1027:        const PathArgument& a1 = PathArgument(),

1028:        const PathArgument& a2 = PathArgument(),

1029:        const PathArgument& a3 = PathArgument(),

1030:        const PathArgument& a4 = PathArgument(),

1031:        const PathArgument& a5 = PathArgument());

1040:   typedef std::vector<const PathArgument*> InArgs;

1041:   typedef std::vector<PathArgument> Args;

1047:                     PathArgument::Kind kind);

806:   optional string path = 1 [(sem_type) = {

1105:   optional string path = 1 [(sem_type) = {

608:   optional string blob_path = 1 [(sem_type) = {

836:   optional string history_path = 5 [(sem_type) = {

930:   optional PathSpec root_path = 3 [(sem_type) = {

1005:   optional string history_path = 5 [(sem_type) = {

1709:   repeated string path_list = 1 [(sem_type) = {

550:   optional PathSpec pathspec = 1 [(sem_type) = {

780:   optional PathSpec pathspec = 1 [(sem_type) = {

798:   optional PathSpec.PathType pathtype = 1 [(sem_type) = {

822:   optional PathSpec.PathType pathtype = 1 [(sem_type) = {

848:   optional PathSpec.PathType pathtype = 2 [(sem_type) = {

872:   optional PathSpec pathspec = 1 [(sem_type) = {

879:   optional PathSpec pathspec = 1 [(sem_type) = {

900:   optional PathSpec pathspec = 1;

920:   repeated string paths = 1 [(sem_type) = {

926:   optional PathSpec.PathType pathtype = 2 [(sem_type) = {

965:   optional PathSpec pathspec = 1 [(sem_type) = {

991:   optional PathSpec.PathType pathtype = 1 [(sem_type) = {

1098:   optional PathSpec.PathType pathtype = 3 [(sem_type) = {

1110:   optional PathSpec.PathType pathtype = 2 [(sem_type) = {

1138:   repeated PathSpec pathspecs = 2 [(sem_type) = {

1538:   repeated string paths = 1 [(sem_type) = {

1544:   optional PathSpec.PathType pathtype = 2 [(sem_type) = {

1622:   repeated PathSpec pathspecs = 2 [(sem_type) = {

1713:   optional PathSpec.PathType pathtype = 2 [(sem_type) = {