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

24: type Path []PathStep

32: type PathStep interface {

149: type pathStep struct {

170: 	pathStep

208: 	pathStep

252: 	pathStep

266: 	pathStep

276: 	pathStep

286: 	pathStep

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

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

35: 	// Type is the resulting type after performing the path step.

38: 	// Values is the resulting values after performing the path step.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

55: 	_ PathStep = StructField{}

56: 	_ PathStep = SliceIndex{}

57: 	_ PathStep = MapIndex{}

58: 	_ PathStep = Indirect{}

59: 	_ PathStep = TypeAssertion{}

60: 	_ PathStep = Transform{}

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

86: 		return pathStep{}

114: 		var nextStep PathStep

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

155: func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }

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

25: 	Path []PathStep

30: 	PathStep interface {

187: 	pathStep struct {

192: 		pathStep

196: 		pathStep

200: 		pathStep

203: 		pathStep

215: 		pathStep

218: 		pathStep

33: 		isPathStep()

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{}

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

14:   pathMismatch(npmRoot) {

29: function fixPath(filepath) {

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

52:     const npmRoot = fixPath(stdout);

55:       return errors.pathMismatch(npmRoot);

54:     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 {

3: var path = require("path");

453:                 path: scope,

522:                 path: "",

62: function resolveScopeCountPath(scope) {

142: var pathVisitor = walk.make({

557: module.exports.mapLinesPathToScopePath = function(ternServer, defInfo) {

607: module.exports.getPath = function(node) {

47: function getFilePathName(fileName) {

19:  * @property {string} scope - scope path

28:  * @property {string} path - path to class

36:  * @return {string} path to given node in given file

100:  * required parent properties and adjusting path

102:  * @param {string} scope new scope (path)

316:             if (def && def.path) {

317:                 pathMap[formPathForScope(fileName, node.object)] = def.path;

318:                 newScope = def.path;

326:                 if (def && def.path) {

327:                     pathMap[formPathForScope(fileName, node.object)] = def.path;

328:                     newScope = def.path;

341:                     newScope = util.formPath(def.path, "fn", '+' + node.property.name);

344:                     newScope = util.formPath(def.path, "fn", '-' + node.property.name);

347:                     newScope = util.formPath(def.path, "fn", node.property.name);

350:                     newScope = util.formPath(classDefinitions[currentClass].path, "prop", node.property.name);

438:             // append /class/NAME to path being built

443:                 classDefinitions[currentClass].path = scope;

605:  * @returns {string} computed path to given node

39:     return util.formPath(fileName, data.start, data.end);

48:     fileName = util.normalizePath(fileName);

69:         return util.formPath(scope, scopeCountRes);

73: module.exports.pathMap = pathMap = {};

154:             var newScope = util.formPath(scopeInfo.scope, "obj_def_prop");

158:                 newScope = util.formPath(newScope, obj.name);

160:                 newScope = util.formPath(newScope, property.value);

164:             pathMap[key] = resolveScopeCountPath(newScope);

179:         var newScope = util.formPath(scopeInfo.scope, "import");

185:                     newScope = resolveScopeCountPath(util.formPath(newScope, id.name));

186:                     pathMap[key] = newScope;

204:         var newScope = util.formPath(scopeInfo.scope, "fn");

223:             newScope = resolveScopeCountPath(util.formPath(newScope, name));

224:             pathMap[formPathForScope(fileName, identNode)] = newScope;

228:             newScope = resolveScopeCountPath(newScope);

240:             var paramScope = resolveScopeCountPath(util.formPath(newScope, "param", param.name));

241:             pathMap[formPathForScope(fileName, param)] = paramScope;

267:                 var newScope = resolveScopeCountPath(util.formPath(scopeInfo.scope, "var", decl.name));

268:                 pathMap[key] = newScope;

309:             newScope = resolveScopeCountPath(util.formPath(scopeInfo.scope, "obj", node.object.name));

310:             pathMap[formPathForScope(fileName, node.object)] = newScope;

353:                 newScope = resolveScopeCountPath(util.formPath(newScope, "prop", node.property.name));

356:             pathMap[keyProp] = newScope;

371:         var newScope = util.formPath(scopeInfo.scope, "obj");

375:                 objScope = util.formPath(objScope, "objType", node.objType.name);

378:             var keyScope = util.formPath(objScope, "obj_key");

382:                 keyScope = resolveScopeCountPath(util.formPath(keyScope, node.properties[i].key.name));

383:                 pathMap[keyKey] = keyScope;

387:                 keyScope = resolveScopeCountPath(util.formPath(keyScope, node.properties[i].key.value));

388:                 pathMap[keyKey] = keyScope;

395:                 valScope = resolveScopeCountPath(util.formPath(valScope, "obj_val", node.properties[i].value.name));

396:                 pathMap[key_val] = valScope;

436:         var scope = util.formPath(scopeInfo.scope, "class");

439:             scope = resolveScopeCountPath(util.formPath(scope, node.id.name));

440:             pathMap[formPathForScope(node.sourceFile.name, node.id)] = scope;

446:             scope = resolveScopeCountPath(scope);

457:             pathMap[util.formPath(node.sourceFile.name, node.start, node.start + "class".length)] = scope;

513:     var visitor = extend({}, pathVisitor);

530:         pathVisitor.ClassDeclaration(node, state, cb);

543:         pathVisitor.MethodDefinition(node, state, cb);

562:     var mapRes = pathMap[key];

577:                     methods: pathVisitor

578:                 }, null, pathVisitor);

608:     return pathMap[formPathForScope(node.sourceFile.name, node)];

38: module.exports.formPathForScope = formPathForScope = function(fileName, data) {

163:             var key = formPathForScope(fileName, property);

184:                     var key = formPathForScope(fileName, id);

266:                 var key = formPathForScope(fileName, decl);

355:             keyProp = formPathForScope(fileName, node.property);

381:                 keyKey = formPathForScope(fileName, node.properties[i].key);

386:                 keyKey = formPathForScope(fileName, node.properties[i].key);

394:                 var key_val = formPathForScope(fileName, node.properties[i].value);

508: module.exports.initLocalFilesScopePaths = function(ternServer, localFiles) {

550:                 scope: getFilePathName(file.name),

558:     var key = formPathForScope(defInfo.file, {

575:                     scope: getFilePathName(file.name),

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

24: type Path struct {

39: func StringToPath(s string) (*Path, error) {

49: func sliceToPath(slice []string) (*Path, error) {

69: func encodePath(s string) (*Path, error) {

23: // Path to a specific variable

29: 	// Name of struct field in path

33: 	// if nil, this Path refers to the top-level element

34: 	Next *Path

37: // Converts a string to a Path pointer. If the pointer is nil,

38: // the Path refers to the top-level ("current") element.

47: // Converts a string slice to a Path pointer. If the pointer is nil,

48: // the Path refers to the top-level ("current") element.

50: 	var first *Path

51: 	var cur *Path

68: // Encodes path part

75: 		return &Path{

80: 	return &Path{

85: // Appends the specified newElement to the path and

86: // returns the new root of the path.

87: func (p *Path) Append(newElement *Path) *Path {

88: 	var prevEl *Path

89: 	var curEl *Path

100: // Removes the last element from the path and returns

101: // the new root of the path

102: func (p *Path) RemoveLast() *Path {

106: 	var prevEl *Path

107: 	var curEl *Path

114: type VisitingFunc func(updatedPath *Path)

116: // Attaches the specified element to the path, runs the specified function, and

119: func (p *Path) Visiting(element *Path, doing VisitingFunc) {

125: func (p *Path) String() string {

44: 	return sliceToPath(sliced)

53: 		pathEl, err := encodePath(elt)

58: 			first = pathEl

60: 			cur.Next = pathEl

62: 		cur = pathEl

129: 	subpath := p.Next.String()

134: 	if subpath == "" {

137: 		return elt + "." + subpath

1: package path;

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,

18: package path

26: type Path []string

44: func ToPaths(paths []string) []Path {

17: // Package path implements path manipulation routines used by cmaketobzl.

21: 	"path/filepath"

25: // Path is a slice of string segments, representing a filesystem path.

28: // Split cleans and splits the system-delimited filesystem path.

29: func New(s string) Path {

35: 		return Path{"/"}

37: 		return append(Path{"/"}, strings.Split(s[1:], "/")...)

45: 	split := make([]Path, len(paths))

53: func (p Path) LessThan(o Path) bool {

66: // String returns the properly platform-delimited form of the path.

67: func (p Path) String() string {

71: // Append appends additional elements to the end of path, disregarding

73: func Append(p Path, ps ...Path) Path {

84: // AppendString appends additional string elements to the end of path.

85: func AppendString(p Path, elem ...string) Path {

90: func Join(p Path, ps ...Path) Path {

97: // JoinString joins path and any number of additional string elements, returning the result.

98: func JoinString(p Path, elem ...string) Path {

103: // path and returns that along with each path stripped of that prefix.

104: func SplitCommonRoot(paths []Path) (Path, []Path) {

109: 	result := make([]Path, len(paths))

117: // path and returns that along with each path stripped of that prefix as /-delimited strings.

127: // LongestCommonPrefix returns the longest shared Path prefix of all of the paths.

128: func LongestCommonPrefix(paths []Path) Path {

30: 	s = filepath.ToSlash(filepath.Clean(s))

43: // ToPaths cleans and splits each of the system-delimited filesystem paths.

46: 	for i, p := range paths {

52: // LessThan provides lexicographic ordering of Paths.

68: 	return filepath.Join([]string(p)...)

75: 		// Drop the leading '/' when appending/joining fully qualified paths.

89: // Join joins any number of paths and returns the result.

105: 	root := LongestCommonPrefix(paths)

107: 		return root, paths

110: 	for i, p := range paths {

118: func SplitCommonRootString(paths []string) (string, []string) {

119: 	root, stripped := SplitCommonRoot(ToPaths(paths))

129: 	switch len(paths) {

133: 		return paths[0]

135: 	min, max := paths[0], paths[0]

136: 	for _, p := range paths[1:] {

86: 	return Append(p, ToPaths(elem)...)

99: 	return Join(p, ToPaths(elem)...)

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

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

566: TCL_PATH = tclsh

567: TCLTK_PATH = wish

801: 	SHELL_PATH = /bin/sh

804: 	PERL_PATH = /usr/bin/perl

807: 	PYTHON_PATH = /usr/bin/python

813: TEST_SHELL_PATH = $(SHELL_PATH)

546: pathsep = :

1162: CC_LD_DYNPATH = -Wl,-rpath,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

469: # current executable path.

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

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

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

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

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

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

575: export TCL_PATH TCLTK_PATH

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

800: ifndef SHELL_PATH

803: ifndef PERL_PATH

806: ifndef PYTHON_PATH

810: export PERL_PATH

811: export PYTHON_PATH

944: LIB_OBJS += path.o

1241: ifdef SANE_TOOL_PATH

1389: ifdef ZLIB_PATH

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

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

1814: ifneq ($(PROCFS_EXECUTABLE_PATH),)

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

1819: ifdef HAVE_NS_GET_EXECUTABLE_PATH

1820: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH

1837: ifeq ($(TCLTK_PATH),)

1841: ifeq ($(PERL_PATH),)

1845: ifeq ($(PYTHON_PATH),)

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

1993: ifdef SHELL_PATH

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

2020: export DIFF TAR INSTALL DESTDIR SHELL_PATH

2025: SHELL = $(SHELL_PATH)

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

2064: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

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

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

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

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

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

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

2137: 	$(QUIET_GEN)$(SHELL_PATH) ./generate-cmdlist.sh \

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

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

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

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

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

2153:     -e $(BROKEN_PATH_FIX) \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2703: ### Detect Python interpreter path changes

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

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

3035: 		SHELL_PATH='$(SHELL_PATH_SQ)' PERL_PATH='$(PERL_PATH_SQ)'

3120: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell

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

606: unexport CDPATH

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

828: LIB_OBJS += abspath.o

945: LIB_OBJS += pathspec.o

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

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

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

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

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

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

1735: ifdef HAVE_PATHS_H

1736: 	BASIC_CFLAGS += -DHAVE_PATHS_H

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

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

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

1326: 	char *path;

1619: 	struct strbuf path;

575: #define READ_GITFILE_ERR_NO_PATH 6

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

1320: 	struct strbuf symlink_path;

1336: #define GET_OID_RECORD_PATH     0200

472: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"

487: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"

488: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"

489: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"

490: #define GIT_ICASE_PATHSPECS_ENVIRONMENT "GIT_ICASE_PATHSPECS"

16: #include "path.h"

348: 				     const char *path,

362: 					       const char *path,

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

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

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

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

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

491: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"

543: void set_git_dir(const char *path);

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

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

556: int is_git_directory(const char *path);

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

568: int is_nonbare_repository_dir(struct strbuf *path);

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

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

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

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

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

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

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

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

614: char *prefix_filename(const char *prefix, const char *path);

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

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

659: int read_index_from(struct index_state *, const char *path,

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

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

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

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

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

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

786: ...(24 bytes skipped)...x_state *istate, struct object_id *oid, int fd, struct stat *st, enum object_type type, const char *path, unsigned flags);

787: int index_path(struct index_state *istate, struct object_id *oid, const char *path, struct stat *st, unsigned flags);

826: extern int quote_path_fully;

837: extern const char *git_hooks_path;

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

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

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

1152: int adjust_shared_perm(const char *path);

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

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

1167:  * safe_create_leading_directories() temporarily changes path while it

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

1179: enum scld_error safe_create_leading_directories(char *path);

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

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

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

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

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

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

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

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

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

1225: int mkdir_in_gitdir(const char *path);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1246: int daemon_avoid_alias(const char *path);

1317: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,

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

1356: 		       * Somewhere along the symlink chain, a path is

1627: 	strbuf_release(&cache->path);

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

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

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

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

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

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

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

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

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

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

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

208: struct pathspec;

403: #define read_cache_preload(pathspec) repo_read_index_preload(the_repository, (pathspec), 0)

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

655: 		   const struct pathspec *pathspec,

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

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

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

17:     readonly path: Path;

61:     path: string;

198:     path: Path;

204:     path: Path;

332:     readonly path: Path;

703: export declare const path: TemplateTag<Path>;

705: export declare type Path = string & {

79: export declare function asPosixPath(path: Path): PosixPath;

709: export declare class PathCannotBeFragmentException extends BaseException {

721: export declare class PathIsFileException extends BaseException {

747: export declare type PosixPath = string & {

16: export declare class AmbiguousProjectPathException extends BaseException {

11:     protected _aliases: Map<Path, Path>;

12:     readonly aliases: Map<Path, Path>;

13:     protected _resolve(path: Path): Path;

19:     constructor(path: Path, projects: ReadonlyArray<string>);

25:     pageview(path: string, options?: PageviewOptions): void;

81: export declare function asWindowsPath(path: Path): WindowsPath;

87: export declare function basename(path: Path): PathFragment;

155:     constructor(path: string);

160:     protected _filesToCreate: Set<Path>;

161:     protected _filesToDelete: Set<Path>;

162:     protected _filesToOverwrite: Set<Path>;

163:     protected _filesToRename: Map<Path, Path>;

164:     protected _filesToRenameRevert: Map<Path, Path>;

170:     create(path: Path, content: FileBuffer): Observable<void>;

171:     delete(path: Path): Observable<void>;

172:     exists(path: Path): Observable<boolean>;

173:     isDirectory(path: Path): Observable<boolean>;

174:     isFile(path: Path): Observable<boolean>;

175:     list(path: Path): Observable<PathFragment[]>;

176:     overwrite(path: Path, content: FileBuffer): Observable<void>;

177:     read(path: Path): Observable<FileBuffer>;

179:     rename(from: Path, to: Path): Observable<void>;

180:     stat(path: Path): Observable<Stats | null> | null;

181:     watch(path: Path, options?: HostWatchOptions): null;

182:     willCreate(path: Path): boolean;

183:     willDelete(path: Path): boolean;

184:     willOverwrite(path: Path): boolean;

185:     willRename(path: Path): boolean;

186:     willRenameTo(path: Path, to: Path): boolean;

187:     write(path: Path, content: FileBuffer): Observable<void>;

193:     path: Path;

210:     from: Path;

212:     to: Path;

254: export declare function dirname(path: Path): Path;

258:     exists(path: Path): Observable<boolean>;

259:     isDirectory(path: Path): Observable<boolean>;

260:     isFile(path: Path): Observable<boolean>;

261:     list(path: Path): Observable<PathFragment[]>;

262:     read(path: Path): Observable<FileBuffer>;

263:     stat(path: Path): Observable<Stats<{}> | null>;

271: export declare function extname(path: Path): string;

274:     constructor(path: string);

286:     constructor(path: string);

301:     pageview(path: string, options?: PageviewOptions): void;

306: export declare function fragment(path: string): PathFragment;

308: export declare function getSystemPath(path: Path): string;

321:     delete(path: Path): Observable<void>;

322:     rename(from: Path, to: Path): Observable<void>;

323:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

324:     write(path: Path, content: FileBufferLike): Observable<void>;

364:     constructor(path: string);

373: export declare function isAbsolute(p: Path): boolean;

385: export declare function join(p1: Path, ...others: string[]): Path;

576:     path: string[];

584:     pageview(path: string, options?: PageviewOptions): void;

600:     constructor(path: string);

608:     pageview(path: string, options?: PageviewOptions): void;

650: export declare function noCacheNormalize(path: string): Path;

660: export declare function normalize(path: string): Path;

662: export declare const NormalizedRoot: Path;

664: export declare const NormalizedSep: Path;

683:     path?: string;

706:     __PRIVATE_DEVKIT_PATH: void;

710:     constructor(path: string);

713: export declare type PathFragment = Path & {

714:     __PRIVATE_DEVKIT_PATH_FRAGMENT: void;

718:     constructor(path: string);

722:     constructor(path: string);

726:     constructor(path: string);

731:     path: string;

732:     constructor(path: string, exception: JsonException);

737:     protected _resolve(path: Path): Path;

748:     __PRIVATE_DEVKIT_POSIX_PATH: void;

810:     exists(path: Path): Observable<boolean>;

811:     isDirectory(path: Path): Observable<boolean>;

812:     isFile(path: Path): Observable<boolean>;

813:     list(path: Path): Observable<PathFragment[]>;

814:     read(path: Path): Observable<FileBuffer>;

815:     stat(path: Path): Observable<Stats<StatsT> | null> | null;

818: export declare function readWorkspace(path: string, host: WorkspaceHost, format?: WorkspaceFormat): Promise<{

838: export declare function relative(from: Path, to: Path): Path;

840: export declare type ReplacementFunction = (path: Path) => Path;

853: export declare function resolve(p1: Path, p2: Path): Path;

859:     protected abstract _resolve(path: Path): Path;

860:     delete(path: Path): Observable<void>;

861:     exists(path: Path): Observable<boolean>;

862:     isDirectory(path: Path): Observable<boolean>;

863:     isFile(path: Path): Observable<boolean>;

864:     list(path: Path): Observable<PathFragment[]>;

865:     read(path: Path): Observable<FileBuffer>;

866:     rename(from: Path, to: Path): Observable<void>;

867:     stat(path: Path): Observable<Stats<T> | null> | null;

868:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

869:     write(path: Path, content: FileBuffer): Observable<void>;

875:     exists(path: Path): Observable<boolean>;

876:     isDirectory(path: Path): Observable<boolean>;

877:     isFile(path: Path): Observable<boolean>;

878:     list(path: Path): Observable<PathFragment[]>;

879:     read(path: Path): Observable<FileBuffer>;

880:     stat(path: Path): Observable<Stats<StatsT> | null> | null;

939:     protected _root: Path;

940:     constructor(delegate: Host<T>, _root?: Path);

941:     protected _resolve(path: Path): Path;

951:     protected _cache: Map<Path, Stats<SimpleMemoryHostStats>>;

954:     protected _delete(path: Path): void;

955:     protected _exists(path: Path): boolean;

956:     protected _isDirectory(path: Path): boolean;

957:     protected _isFile(path: Path): boolean;

958:     protected _list(path: Path): PathFragment[];

981:     protected _read(path: Path): FileBuffer;

982:     protected _rename(from: Path, to: Path): void;

983:     protected _stat(path: Path): Stats<SimpleMemoryHostStats> | null;

984:     protected _toAbsolute(path: Path): Path;

985:     protected _updateWatchers(path: Path, type: HostWatchEventType): void;

986:     protected _watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;

987:     protected _write(path: Path, content: FileBuffer): void;

988:     delete(path: Path): Observable<void>;

989:     exists(path: Path): Observable<boolean>;

990:     isDirectory(path: Path): Observable<boolean>;

991:     isFile(path: Path): Observable<boolean>;

992:     list(path: Path): Observable<PathFragment[]>;

993:     read(path: Path): Observable<FileBuffer>;

994:     rename(from: Path, to: Path): Observable<void>;

996:     stat(path: Path): Observable<Stats<{}> | null> | null;

997:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

998:     write(path: Path, content: FileBuffer): Observable<void>;

1009: export declare function split(path: Path): PathFragment[];

1035:     delete(path: Path): void;

1036:     exists(path: Path): boolean;

1037:     isDirectory(path: Path): boolean;

1038:     isFile(path: Path): boolean;

1039:     list(path: Path): PathFragment[];

1040:     read(path: Path): FileBuffer;

1041:     rename(from: Path, to: Path): void;

1042:     stat(path: Path): Stats<T> | null;

1043:     watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent> | null;

1044:     write(path: Path, content: FileBufferLike): void;

1124:         path: Path;

1127:         from: Path;

1128:         to: Path;

1133:         readonly files: Path[];

1137:             [path: string]: string;

1139:         $exists(path: string): boolean;

1140:         $isDirectory(path: string): boolean;

1141:         $isFile(path: string): boolean;

1142:         $list(path: string): PathFragment[];

1143:         $read(path: string): string;

1144:         $write(path: string, content: string): void;

1145:         protected _delete(path: Path): void;

1146:         protected _exists(path: Path): boolean;

1147:         protected _isDirectory(path: Path): boolean;

1148:         protected _isFile(path: Path): boolean;

1149:         protected _list(path: Path): PathFragment[];

1150:         protected _read(path: Path): ArrayBuffer;

1151:         protected _rename(from: Path, to: Path): void;

1152:         protected _stat(path: Path): Stats<SimpleMemoryHostStats> | null;

1153:         protected _watch(path: Path, options?: HostWatchOptions): Observable<HostWatchEvent>;

1154:         protected _write(path: Path, content: FileBuffer): void;

1199:     __PRIVATE_DEVKIT_WINDOWS_PATH: void;

1205:     readonly root: Path;

1207:     constructor(_root: Path, _host: virtualFs.Host<{}>, registry?: schema.CoreSchemaRegistry);

1211:     getProjectByPath(path: Path): string | null;

1218:     loadWorkspaceFromHost(workspacePath: Path): Observable<this>;

1222:     static findWorkspaceFile(host: virtualFs.Host<{}>, path: Path): Promise<Path | null>;

1223:     static fromPath(host: virtualFs.Host<{}>, path: Path, registry: schema.CoreSchemaRegistry): Promise<Workspace>;

1232:     constructor(path: Path);

1240:     isDirectory(path: string): Promise<boolean>;

1241:     isFile(path: string): Promise<boolean>;

1242:     readFile(path: string): Promise<string>;

1243:     writeFile(path: string, data: string): Promise<void>;

1284: export declare function writeWorkspace(workspace: WorkspaceDefinition, host: WorkspaceHost, path?: string, format?: WorkspaceFormat): Promise<void>;

717: export declare class PathIsDirectoryException extends BaseException {

725: export declare class PathMustBeAbsoluteException extends BaseException {

729: export declare class PathSpecificJsonException extends JsonException {

921:     dataPath: string;

1198: export declare type WindowsPath = string & {

363: export declare class InvalidPathException extends BaseException {

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

26:     "canonical-path": "0.0.2",

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

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

614:   //   span   path               represents

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

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

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

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

650:     // example, this path:

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

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

506:   required string path = 3;

288:     INVALID_PATH_IN_ACL_REQUEST = 53; // Invalid path name in acl request.

129:   required string path = 1;

487:   required string path = 1;

529:   optional string path = 2;

653:   required string path = 1;

661:   required string path = 1;

669:   required string path = 1;

708:   required string path = 1;

789:   required string path = 1;

819:   optional string path = 3;

824:   required string path = 2;

711:   optional string targetPath = 1;

754:   required string snapshotPath = 1;

1014:   rpc getEZForPath(GetEZForPathRequestProto)

1015:       returns(GetEZForPathResponseProto);

215: 	Path   [108]int8

816: 	AT_EMPTY_PATH   = 0x1000

14: 	PathMax        = 0x1000

566: 	RTA_MULTIPATH           = 0x9

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

114:     outputPath: baseOutputPath,

137:     outputPath: baseOutputPath,

257:     outputPath: baseOutputPath,

285:     outputPath: baseOutputPath,

305:     outputPath: baseOutputPath,

326:     outputPath: baseOutputPath,

350:     outputPath: baseOutputPath,

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

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

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

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

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

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

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

375:   const template = path.join(

383:   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']);

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

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

392:     outputPath: baseOutputPath,

59:   path: string;

54:  * @template B The object matching the non-wildcard portion of the path.

55:  * @template V Additional types that could be set at the path.

58:   /** Path to the property that changed. */

60:   /** The object matching the non-wildcard portion of the path. */

62:   /** New value of the path that changed. */

267: 	Path   [UnixPathMax]int8

262: const UnixPathMax = 108

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

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

1097:   waitForXPath(xpath, options = {}) {

419:    * @param {!{url?: string, path?: string, content?: string, type?: string}} options

427:    * @param {!{url?: string, path?: string, content?: string}} options

852:     // options.type takes precedence over inferring the type from options.path

857:     } else if (options.path) {

858:       const mimeType = mime.getType(options.path);

923:     if (options.path)

924:       await writeFileAsync(options.path, buffer);

951:       path = null

988:     return await helper.readProtocolStream(this._client, result.stream, path);

1126:  * @property {string=} path

1149:  * @property {string=} path

1233:  * @property {string} path

1249:  * @property {string=} path

1331:     const files = filePaths.map(filePath => path.resolve(filePath));

1093:    * @param {string} xpath

1098:     return this.mainFrame().waitForXPath(xpath, options);

1325:    * @param {!Array<string>} filePaths

1328:   async accept(filePaths) {

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

1707:     TVector<TIntermNode *> path;

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

1681:         path.push_back(current);

1687:         path.pop_back();

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

428: 	Path uint64

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

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

440: 	q.Path = b.Read64()

447: 	b.Write64(q.Path)

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

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

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

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

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

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

782:   uint32_t path;

779: struct rpath_command {

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

1194: inline void swapStruct(rpath_command &r) {

861:   path: string;

866:   path: string;

872:   path: string;

909:   path: string;

1077:   hostPath: HostPathVolumeSource;

860: export interface HostPathVolumeSource {

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

215: 	Path   [108]int8

816: 	AT_EMPTY_PATH   = 0x1000

14: 	PathMax        = 0x1000

566: 	RTA_MULTIPATH           = 0x9

214: 	Path   [108]int8

810: 	AT_EMPTY_PATH   = 0x1000

14: 	PathMax        = 0x1000

565: 	RTA_MULTIPATH           = 0x9

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

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

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