15: package path

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

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

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

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

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

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

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

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

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

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

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

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

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

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

74: func (n *DeviceTraceConfiguration) Path() *Any  { return &Any{Path: &Any_TraceConfig{n}} }

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

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

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

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

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

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

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

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

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

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

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

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

87: func (n *Messages) Path() *Any                  { return &Any{Path: &Any_Messages{n}} }

88: func (n *MultiResourceData) Path() *Any         { return &Any{Path: &Any_MultiResourceData{n}} }

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

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

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

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

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

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

96: func (n *Stats) Path() *Any                     { return &Any{Path: &Any_Stats{n}} }

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

95: func (n *StateTreeNodeForPath) Path() *Any      { return &Any{Path: &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

244: // Format implements fmt.Formatter to print the message path.

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

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

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

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

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

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

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

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

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

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

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

497: // NewField returns a new Field path.

504: // NewArrayIndex returns a new ArrayIndex path.

511: // NewMapIndex returns a new MapIndex path.

521: // NewSlice returns a new Slice path.

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

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

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

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

551: // Messages returns the path node to the capture's messages.

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

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

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

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

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

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

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

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

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

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

627: // ResourcesAfter returns the path node to the resources with the given

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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",

119: Path::Path(const tensorflow::metadata::v0::Path& p)

1: #include "tensorflow_data_validation/anomalies/path.h"

123: bool Path::Equals(const Path& p) const {

130: bool Path::Less(const Path& p) const {

135: int Path::Compare(const Path& p) const {

142: bool operator==(const Path& a, const Path& b) { return a.Compare(b) == 0; }

144: bool operator<(const Path& a, const Path& b) { return a.Compare(b) < 0; }

146: bool operator>(const Path& a, const Path& b) { return a.Compare(b) > 0; }

148: bool operator>=(const Path& a, const Path& b) { return a.Compare(b) >= 0; }

150: bool operator<=(const Path& a, const Path& b) { return a.Compare(b) <= 0; }

152: bool operator!=(const Path& a, const Path& b) { return a.Compare(b) != 0; }

154: string Path::Serialize() const {

163: tensorflow::metadata::v0::Path Path::AsProto() const {

164:   tensorflow::metadata::v0::Path path;

166:     path.add_step(step);

168:   return path;

172: // Note: for any path p:

173: // p==Path::Deserialize(p.Serialize())

174: tensorflow::Status Path::Deserialize(absl::string_view str, Path* result) {

186: Path Path::GetChild(absl::string_view last_step) const {

189:   return Path(std::move(new_steps));

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 {

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 {

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

13: const path = require('path').posix;

35:       const pathname = path.relative(

36:         path.dirname(parsedFrom.pathname), parsedTo.pathname);

54:       let path = match.replace(/["']/g, "").slice(4, -1);

55:       path = this.rewriteRelPath(importUrl, mainDocUrl, path);

56:       return 'url("' + path + '")';

12: // Adapted from vulcanize's pathResolver, but only used for css text

26:   rewriteRelPath: function rewriteRelPath(importUrl, mainDocUrl, relUrl) {

38:         pathname,

44: class Path {

47:   explicit Path(std::vector<string> step) : step_(std::move(step)) {}

2: #define TENSORFLOW_DATA_VALIDATION_ANOMALIES_PATH_H_

1: #ifndef TENSORFLOW_DATA_VALIDATION_ANOMALIES_PATH_H_

8: #include "tensorflow_metadata/proto/v0/path.pb.h"

16: // Specifically, individual steps in a path can be arbitrary strings (in the

25: // is sufficient to simply use dot separators to create the path.

46:   Path() = default;

48:   explicit Path(const tensorflow::metadata::v0::Path& p);

49:   Path(const Path& p) = default;

50:   Path(Path&& p) = default;

51:   Path& operator=(const Path& p) = default;

52:   Path& operator=(Path&& p) = default;

55:   int Compare(const Path& p) const;

57:   // Number of steps in a path.

64:   // Serialize a path into a string that can be Deserialized.

69:   // Serialize the path to a proto.

70:   tensorflow::metadata::v0::Path AsProto() const;

73:   // Note: for any path p (i.e. arbitrary steps):

74:   // Path p2;

75:   // TF_CHECK_OK(Path::Deserialize(p.Serialize(), &p2));

77:   static tensorflow::Status Deserialize(absl::string_view str, Path* result);

82:   // Get the parent path.

83:   Path GetParent() const {

84:     return Path(std::vector<string>(step_.begin(), step_.end() - 1));

87:   Path GetChild(absl::string_view last_step) const;

92:   bool Equals(const Path& p) const;

96:   bool Less(const Path& p) const;

98:   // The raw steps of a path.

104: bool operator<(const Path& a, const Path& b);

105: bool operator>(const Path& a, const Path& b);

106: bool operator==(const Path& a, const Path& b);

107: bool operator!=(const Path& a, const Path& b);

108: bool operator>=(const Path& a, const Path& b);

109: bool operator<=(const Path& a, const Path& b);

114: #endif  // TENSORFLOW_DATA_VALIDATION_ANOMALIES_PATH_H_

15: // list of paths in a 'human-readable' way.

1: package path;

39: message Path {

24: // A path is a more general substitute for the name of a field or feature that

32: // Thus, here the path {step:["parent", "age"]} in statistics would refer to the

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

8:             "type": "Path"

11:         "requiredType": "Path",

20:         "name": "pathPropertyDef"

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

559: TCL_PATH = tclsh

560: TCLTK_PATH = wish

790: 	SHELL_PATH = /bin/sh

793: 	PERL_PATH = /usr/bin/perl

796: 	PYTHON_PATH = /usr/bin/python

802: TEST_SHELL_PATH = $(SHELL_PATH)

540: pathsep = :

1244: 		CC_LD_DYNPATH = -Wl,-rpath,

1246: 		CC_LD_DYNPATH = -R

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

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

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

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

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

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

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

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

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

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

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

1983: 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

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

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

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

569: export TCL_PATH TCLTK_PATH

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

789: ifndef SHELL_PATH

792: ifndef PERL_PATH

795: ifndef PYTHON_PATH

799: export PERL_PATH

800: export PYTHON_PATH

932: LIB_OBJS += path.o

1188: ifdef SANE_TOOL_PATH

1243: 		# the runtime dynamic library path.

1344: ifdef ZLIB_PATH

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

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

1747: ifneq ($(PROCFS_EXECUTABLE_PATH),)

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

1752: ifdef HAVE_NS_GET_EXECUTABLE_PATH

1753: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH

1760: ifeq ($(TCLTK_PATH),)

1764: ifeq ($(PERL_PATH),)

1768: ifeq ($(PYTHON_PATH),)

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

1915: ifdef SHELL_PATH

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

1942: export DIFF TAR INSTALL DESTDIR SHELL_PATH

1947: SHELL = $(SHELL_PATH)

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

1986: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

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

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

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

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

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

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

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

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

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

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

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

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

2073:     -e $(BROKEN_PATH_FIX) \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2615: ### Detect Python interpreter path changes

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

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

2962: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell

254: # that tells runtime paths to dynamic libraries;

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

607: unexport CDPATH

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

816: LIB_OBJS += abspath.o

933: LIB_OBJS += pathspec.o

1240: ifndef CC_LD_DYNPATH

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

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

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

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

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

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

1668: ifdef HAVE_PATHS_H

1669: 	BASIC_CFLAGS += -DHAVE_PATHS_H

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

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

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

1313: 	char *path;

1542: 	struct strbuf path;

582: #define READ_GITFILE_ERR_NO_PATH 6

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

1307: 	struct strbuf symlink_path;

1323: #define GET_OID_RECORD_PATH     0200

481: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"

494: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"

495: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"

496: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"

497: #define GIT_ICASE_PATHSPECS_ENVIRONMENT "GIT_ICASE_PATHSPECS"

15: #include "path.h"

360: 				     const char *path,

374: 					       const char *path,

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

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

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

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

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

498: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

790: ...(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);

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

836: extern int quote_path_fully;

847: extern const char *git_hooks_path;

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

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

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

1139: int adjust_shared_perm(const char *path);

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

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

1154:  * safe_create_leading_directories() temporarily changes path while it

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

1166: enum scld_error safe_create_leading_directories(char *path);

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

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

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

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

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

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

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

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

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

1212: int mkdir_in_gitdir(const char *path);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1233: int daemon_avoid_alias(const char *path);

1304: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,

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

1550: 	strbuf_release(&cache->path);

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

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

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

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

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

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

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

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

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

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

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

221: struct pathspec;

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

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

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

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

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

1682: 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;

485:   required string path = 1;

527:   optional string path = 2;

651:   required string path = 1;

659:   required string path = 1;

667:   required string path = 1;

706:   required string path = 1;

787:   required string path = 1;

817:   optional string path = 3;

822:   required string path = 2;

709:   optional string targetPath = 1;

752:   required string snapshotPath = 1;

999:   rpc getEZForPath(GetEZForPathRequestProto)

1000:       returns(GetEZForPathResponseProto);

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

114:     outputPath: baseOutputPath,

137:     outputPath: baseOutputPath,

257:     outputPath: baseOutputPath,

285:     outputPath: baseOutputPath,

305:     outputPath: baseOutputPath,

329:     outputPath: baseOutputPath,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

207:     outputFile = path.join(

213:     template = path.join(

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

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

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

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

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

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

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

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

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

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

354:   const template = path.join(

362:   const outFile = path.join(

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

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

182:   options.outputPath = baseOutputPath;

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

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

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

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

371:     outputPath: baseOutputPath,

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

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

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

63: ...(74 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)...

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),

797:     repeated int32 path = 1 [packed=true];

869:     repeated int32 path = 1 [packed=true];

365:   //   - The basename of the package import path, if provided.

743:   //   span   path               represents

755:   //   have an outer location whose path refers to the "extensions" repeated

757:   // - Multiple locations may have the same path.  This happens when a single

760:   //   extend blocks in the same scope, each of which will have the same path.

777:     // Each element is a field number or an index.  They form a path from

779:     // example, this path:

792:     // Thus, the above path gives the location of a field name.  If we removed

795:     // this path refers to the whole field declaration (from the beginning

868:     // is formatted the same as SourceCodeInfo.Location.path.

871:     // Identifies the filesystem path to the original source .proto.

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

1665:     TVector<TIntermNode *> path;

51:     #pragma warning(disable : 4464) // relative include path contains '..'

1639:         path.push_back(current);

1645:         path.pop_back();

1650:         return path.size() == 0 ? NULL : path.back();

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

10: const path = require('path')

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

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

194:       const configPath = config.browserConsoleLogOptions.path

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

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

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

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

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

29: const keyPath = path.join(__dirname, 'oauth2.keys.json');

62:       parts.path !== '/oauth2callback'

33: if (fs.existsSync(keyPath)) {

34:   const keyFile = require(keyPath);

778:   uint32_t path;

775: struct rpath_command {

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

1185: inline void swapStruct(rpath_command &r) {

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",

172: 	Path   [UnixPathMax]int8

167: const UnixPathMax = 108

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

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

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;

2892:       required string path = 1;

2912:       required string path = 2;

3489:   required string path = 1;

3521:   optional string path = 1;

2850:   required string container_path = 1;

2857:   optional string host_path = 2;

2874:       HOST_PATH = 4;

2875:       SANDBOX_PATH = 2;

2924:     optional HostPath host_path = 5;

2925:     optional SandboxPath sandbox_path = 3;

2891:     message HostPath {

2901:     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.

1968:     // created on ROOT/PATH disk.

1976:     // created on ROOT/PATH disk.

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

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

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

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

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

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

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

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

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

3488:   // Absolute path to the file.

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

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

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

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

168:     RawUri = MochiReq:get(raw_path),

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

171:     % get requested path

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

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

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

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

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

285:         case HttpReq#httpd.path_parts of

290:     RawUri = MochiReq:get(raw_path),

337:         MochiReq:get(raw_path),

393:     RawUri = MochiReq:get(raw_path),

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

542: partition(Path) ->

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

583:     MochiReq:get(path).

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

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

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

621:     URI ++ Path.

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

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

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

985:                                     MochiReq:get(path);

1053: send_redirect(Req, Path) ->

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

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

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

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

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

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

986:                                 VHostPath ->

987:                                     VHostPath

1233: test_log_request(RawPath, UserCtx) ->

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

106:     CGMutablePathRef path;

273: void x3closepath(x3dc *dc);

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;

2885:       required string path = 1;

2905:       required string path = 2;

3482:   required string path = 1;

3514:   optional string path = 1;

2843:   required string container_path = 1;

2850:   optional string host_path = 2;

2867:       HOST_PATH = 4;

2868:       SANDBOX_PATH = 2;

2917:     optional HostPath host_path = 5;

2918:     optional SandboxPath sandbox_path = 3;

2884:     message HostPath {

2894:     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.

1960:     // created on ROOT/PATH disk.

1968:     // created on ROOT/PATH disk.

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

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

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

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

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

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

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

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

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

3481:   // Absolute path to the file.

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

639:   optional string path = 2;

484:   optional PathSpec src_path = 3;

487:   optional PathSpec dest_path = 5;

649:   optional PathSpec nested_path = 5;

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

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

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

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

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

512:   optional PathSpec pathspec = 6;

628: message PathSpec {

629:   enum PathType {

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

726:   optional PathSpec pathspec = 1;

731:   optional PathSpec pathspec = 1;

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

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

1102:   optional PathSpec pathspec = 1;

1115:   optional PathSpec pathspec = 3;

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

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

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

2043:   optional PathSpec pathspec = 1;

481: message CopyPathToFile {

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

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

475: //  - src_path: source pathspec from request

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

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

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

676:   // file - instead of the path.

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

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

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

749:   // optional string aff4path = 1;

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

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

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

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

1480:   // optional string path = 1;

1511:   // optional string path = 1;

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

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

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

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

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

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

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

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

460: // CopyPathToFile request and response.

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