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 {

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

231: namespace path {

1172: namespace path {

360: StringRef root_path(StringRef path) {

443: StringRef relative_path(StringRef path) {

493: StringRef parent_path(StringRef path) {

634: bool has_root_path(const Twine &path) {

641: bool has_relative_path(const Twine &path) {

655: bool has_parent_path(const Twine &path) {

135:   size_t parent_path_end(StringRef path) {

525: void replace_path_prefix(SmallVectorImpl<char> &Path,

1: //===-- Path.cpp - Implement OS Path Concept ------------------------------===//

10: //  This file implements the operating system Path API.

20: #include "llvm/Support/Path.h"

36:   using llvm::sys::path::is_separator;

46:   StringRef find_first_component(StringRef path) {

53:     if (path.empty())

54:       return path;

58:     if (path.size() >= 2 && std::isalpha(static_cast<unsigned char>(path[0])) &&

59:         path[1] == ':')

60:       return path.substr(0, 2);

64:     if ((path.size() > 2) &&

65:         is_separator(path[0]) &&

66:         path[0] == path[1] &&

67:         !is_separator(path[2])) {

69:       size_t end = path.find_first_of(separators, 2);

70:       return path.substr(0, end);

74:     if (is_separator(path[0]))

75:       return path.substr(0, 1);

78:     size_t end = path.find_first_of(separators);

79:     return path.substr(0, end);

136:     size_t end_pos = filename_pos(path);

138:     bool filename_was_sep = path.size() > 0 && is_separator(path[end_pos]);

141:     size_t root_dir_pos = root_dir_start(path.substr(0, end_pos));

145:           is_separator(path[end_pos - 1]))

170:     if (!sys::path::is_absolute(Twine(ModelStorage))) {

172:       sys::path::system_temp_directory(true, TDir);

173:       sys::path::append(TDir, Twine(ModelStorage));

179:   // path already exists.

185: retry_random_path:

199:         goto retry_random_path;

213:     goto retry_random_path;

220:         goto retry_random_path;

233: const_iterator begin(StringRef path) {

235:   i.Path      = path;

236:   i.Component = find_first_component(path);

241: const_iterator end(StringRef path) {

243:   i.Path      = path;

244:   i.Position  = path.size();

249:   assert(Position < Path.size() && "Tried to increment past end!");

255:   if (Position == Path.size()) {

268:   if (is_separator(Path[Position])) {

276:       Component = Path.substr(Position, 1);

281:     while (Position != Path.size() &&

282:            is_separator(Path[Position])) {

287:     if (Position == Path.size()) {

295:   size_t end_pos = Path.find_first_of(separators, Position);

296:   Component = Path.slice(Position, end_pos);

302:   return Path.begin() == RHS.Path.begin() && Position == RHS.Position;

309: reverse_iterator rbegin(StringRef Path) {

311:   I.Path = Path;

312:   I.Position = Path.size();

316: reverse_iterator rend(StringRef Path) {

318:   I.Path = Path;

319:   I.Component = Path.substr(0, 0);

326:   // we are the root path.

327:   size_t root_dir_pos = root_dir_start(Path);

328:   if (Position == Path.size() &&

329:       Path.size() > root_dir_pos + 1 &&

330:       is_separator(Path[Position - 1])) {

341:         is_separator(Path[end_pos - 1]))

345:   size_t start_pos = filename_pos(Path.substr(0, end_pos));

346:   Component = Path.slice(start_pos, end_pos);

352:   return Path.begin() == RHS.Path.begin() && Component == RHS.Component &&

361:   const_iterator b = begin(path),

363:                  e = end(path);

376:         return path.substr(0, b->size() + pos->size());

392: StringRef root_name(StringRef path) {

393:   const_iterator b = begin(path),

394:                  e = end(path);

410:   // No path or no name.

414: StringRef root_directory(StringRef path) {

415:   const_iterator b = begin(path),

417:                  e = end(path);

439:   // No path or no root.

444:   StringRef root = root_path(path);

445:   return path.substr(root.size());

448: void append(SmallVectorImpl<char> &path, const Twine &a,

464:     bool path_has_sep = !path.empty() && is_separator(path[path.size() - 1]);

468:     if (path_has_sep) {

474:       path.append(c.begin(), c.end());

478:     if (!component_has_sep && !(path.empty() || is_root_name)) {

480:       path.push_back(preferred_separator);

483:     path.append(component.begin(), component.end());

487: void append(SmallVectorImpl<char> &path,

490:     path::append(path, *begin);

494:   size_t end_pos = parent_path_end(path);

498:     return path.substr(0, end_pos);

501: void remove_filename(SmallVectorImpl<char> &path) {

502:   size_t end_pos = parent_path_end(StringRef(path.begin(), path.size()));

504:     path.set_size(end_pos);

507: void replace_extension(SmallVectorImpl<char> &path, const Twine &extension) {

508:   StringRef p(path.begin(), path.size());

515:     path.set_size(pos);

519:     path.push_back('.');

522:   path.append(ext.begin(), ext.end());

531:   StringRef OrigPath(Path.begin(), Path.size());

537:     std::copy(NewPrefix.begin(), NewPrefix.end(), Path.begin());

543:   path::append(NewPath, NewPrefix);

544:   path::append(NewPath, RelPath);

545:   Path.swap(NewPath);

548: void native(const Twine &path, SmallVectorImpl<char> &result) {

549:   assert((!path.isSingleStringRef() ||

550:           path.getSingleStringRef().data() != result.data()) &&

551:          "path and result are not allowed to overlap!");

554:   path.toVector(result);

558: void native(SmallVectorImpl<char> &Path) {

560:   std::replace(Path.begin(), Path.end(), '/', '\\');

562:   for (auto PI = Path.begin(), PE = Path.end(); PI < PE; ++PI) {

574: StringRef filename(StringRef path) {

575:   return *rbegin(path);

578: StringRef stem(StringRef path) {

579:   StringRef fname = filename(path);

591: StringRef extension(StringRef path) {

592:   StringRef fname = filename(path);

620: bool has_root_name(const Twine &path) {

621:   SmallString<128> path_storage;

622:   StringRef p = path.toStringRef(path_storage);

627: bool has_root_directory(const Twine &path) {

628:   SmallString<128> path_storage;

629:   StringRef p = path.toStringRef(path_storage);

635:   SmallString<128> path_storage;

636:   StringRef p = path.toStringRef(path_storage);

638:   return !root_path(p).empty();

642:   SmallString<128> path_storage;

643:   StringRef p = path.toStringRef(path_storage);

645:   return !relative_path(p).empty();

648: bool has_filename(const Twine &path) {

649:   SmallString<128> path_storage;

650:   StringRef p = path.toStringRef(path_storage);

656:   SmallString<128> path_storage;

657:   StringRef p = path.toStringRef(path_storage);

659:   return !parent_path(p).empty();

662: bool has_stem(const Twine &path) {

663:   SmallString<128> path_storage;

664:   StringRef p = path.toStringRef(path_storage);

669: bool has_extension(const Twine &path) {

670:   SmallString<128> path_storage;

671:   StringRef p = path.toStringRef(path_storage);

676: bool is_absolute(const Twine &path) {

677:   SmallString<128> path_storage;

678:   StringRef p = path.toStringRef(path_storage);

690: bool is_relative(const Twine &path) { return !is_absolute(path); }

692: StringRef remove_leading_dotslash(StringRef Path) {

694:   while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1])) {

695:     Path = Path.substr(2);

696:     while (Path.size() > 0 && is_separator(Path[0]))

697:       Path = Path.substr(1);

699:   return Path;

702: static SmallString<256> remove_dots(StringRef path, bool remove_dot_dot) {

705:   // Skip the root path, then look for traversal in the components.

706:   StringRef rel = path::relative_path(path);

707:   for (StringRef C : llvm::make_range(path::begin(rel), path::end(rel))) {

710:     // Leading ".." will remain in the path unless it's at the root.

716:       if (path::is_absolute(path))

722:   SmallString<256> buffer = path::root_path(path);

724:     path::append(buffer, C);

728: bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot) {

729:   StringRef p(path.data(), path.size());

732:   if (result == path)

735:   path.swap(result);

739: } // end namespace path

743: std::error_code getUniqueID(const Twine Path, UniqueID &Result) {

745:   std::error_code EC = status(Path, Status);

807:                                      SmallVectorImpl<char> &path,

809:   StringRef p(path.data(), path.size());

811:   bool rootDirectory = path::has_root_directory(p),

813:        rootName = path::has_root_name(p);

826:   else if (std::error_code ec = current_path(current_dir))

829:   // Relative path. Prepend the current directory.

831:     // Append path to the current directory.

832:     path::append(current_dir, p);

833:     // Set path to the result.

834:     path.swap(current_dir);

839:     StringRef cdrn = path::root_name(current_dir);

841:     path::append(curDirRootName, p);

842:     // Set path to the result.

843:     path.swap(curDirRootName);

848:     StringRef pRootName      = path::root_name(p);

849:     StringRef bRootDirectory = path::root_directory(current_dir);

850:     StringRef bRelativePath  = path::relative_path(current_dir);

851:     StringRef pRelativePath  = path::relative_path(p);

854:     path::append(res, pRootName, bRootDirectory, bRelativePath, pRelativePath);

855:     path.swap(res);

864:                               SmallVectorImpl<char> &path) {

865:   return make_absolute(current_directory, path, true);

868: std::error_code make_absolute(SmallVectorImpl<char> &path) {

869:   return make_absolute(Twine(), path, false);

872: std::error_code create_directories(const Twine &Path, bool IgnoreExisting,

875:   StringRef P = Path.toStringRef(PathStorage);

886:   StringRef Parent = path::parent_path(P);

942: std::error_code is_directory(const Twine &path, bool &result) {

944:   if (std::error_code ec = status(path, st))

954: std::error_code is_regular_file(const Twine &path, bool &result) {

956:   if (std::error_code ec = status(path, st))

968: std::error_code is_other(const Twine &Path, bool &Result) {

970:   if (std::error_code EC = status(Path, FileStatus))

977:   SmallString<128> path = path::parent_path(Path);

978:   path::append(path, filename);

979:   Path = path.str();

1140: std::error_code identify_magic(const Twine &Path, file_magic &Result) {

1142:   if (std::error_code EC = openFileForRead(Path, FD))

1155:   return fs::status(Path, result);

1164: #include "Unix/Path.inc"

1167: #include "Windows/Path.inc"

1174: bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1,

1175:                           const Twine &Path2, const Twine &Path3) {

1177:     append(Result, Path1, Path2, Path3);

1183: } // end namespace path

162:                                           SmallVectorImpl<char> &ResultPath,

180:   ResultPath = ModelStorage;

182:   ResultPath.push_back(0);

183:   ResultPath.pop_back();

189:       ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];

196:             sys::fs::openFileForWrite(Twine(ResultPath.begin()), ResultFD,

208:         sys::fs::access(ResultPath.begin(), sys::fs::AccessMode::Exist);

218:             sys::fs::create_directory(ResultPath.begin(), false)) {

260:   // Both POSIX and Windows treat paths that begin with exactly two separators

532:   if (!OrigPath.startswith(OldPrefix))

541:   StringRef RelPath = OrigPath.substr(OldPrefix.size());

542:   SmallString<256> NewPath;

753:                                  SmallVectorImpl<char> &ResultPath,

755:   return createUniqueEntity(Model, ResultFd, ResultPath, false, Mode, FS_File);

759:                                  SmallVectorImpl<char> &ResultPath) {

761:   return createUniqueEntity(Model, Dummy, ResultPath, false, 0, FS_Name);

766:                     llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {

772:   return createUniqueEntity(P.begin(), ResultFD, ResultPath,

778:                     llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {

780:   return createTemporaryFile(Prefix + Middle + Suffix, ResultFD, ResultPath,

786:                                     SmallVectorImpl<char> &ResultPath) {

787:   return createTemporaryFile(Prefix, Suffix, ResultFD, ResultPath, FS_File);

791:                                     SmallVectorImpl<char> &ResultPath) {

793:   return createTemporaryFile(Prefix, Suffix, Dummy, ResultPath, FS_Name);

800:                                       SmallVectorImpl<char> &ResultPath) {

802:   return createUniqueEntity(Prefix + "-%%%%%%", Dummy, ResultPath,

874:   SmallString<128> PathStorage;

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

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

8:             "type": "Path"

11:         "requiredType": "Path",

20:         "name": "pathPropertyDef"

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

561: TCL_PATH = tclsh

562: TCLTK_PATH = wish

798: 	SHELL_PATH = /bin/sh

801: 	PERL_PATH = /usr/bin/perl

804: 	PYTHON_PATH = /usr/bin/python

810: TEST_SHELL_PATH = $(SHELL_PATH)

541: pathsep = :

1175: CC_LD_DYNPATH = -Wl,-rpath,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

464: # current executable path.

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

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

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

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

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

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

570: export TCL_PATH TCLTK_PATH

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

797: ifndef SHELL_PATH

800: ifndef PERL_PATH

803: ifndef PYTHON_PATH

807: export PERL_PATH

808: export PYTHON_PATH

940: LIB_OBJS += path.o

1254: ifdef SANE_TOOL_PATH

1402: ifdef ZLIB_PATH

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

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

1826: ifneq ($(PROCFS_EXECUTABLE_PATH),)

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

1831: ifdef HAVE_NS_GET_EXECUTABLE_PATH

1832: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH

1849: ifeq ($(TCLTK_PATH),)

1853: ifeq ($(PERL_PATH),)

1857: ifeq ($(PYTHON_PATH),)

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

2005: ifdef SHELL_PATH

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

2032: export DIFF TAR INSTALL DESTDIR SHELL_PATH

2037: SHELL = $(SHELL_PATH)

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

2076: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

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

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

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

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

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

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

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

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

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

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

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

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

2165:     -e $(BROKEN_PATH_FIX) \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2716: ### Detect Python interpreter path changes

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

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

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

3139: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell

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

602: unexport CDPATH

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

825: LIB_OBJS += abspath.o

941: LIB_OBJS += pathspec.o

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

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

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

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

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

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

1747: ifdef HAVE_PATHS_H

1748: 	BASIC_CFLAGS += -DHAVE_PATHS_H

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

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

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

1371: 	char *path;

1663: 	struct strbuf path;

576: #define READ_GITFILE_ERR_NO_PATH 6

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

1365: 	struct strbuf symlink_path;

1381: #define GET_OID_RECORD_PATH     0200

473: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"

488: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"

489: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"

490: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"

491: #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))

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

492: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"

544: void set_git_dir(const char *path);

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

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

557: int is_git_directory(const char *path);

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

569: int is_nonbare_repository_dir(struct strbuf *path);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

879: extern int quote_path_fully;

890: extern const char *git_hooks_path;

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

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

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

1197: int adjust_shared_perm(const char *path);

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

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

1212:  * safe_create_leading_directories() temporarily changes path while it

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

1224: enum scld_error safe_create_leading_directories(char *path);

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

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

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

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

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

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

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

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

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

1270: int mkdir_in_gitdir(const char *path);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1291: int daemon_avoid_alias(const char *path);

1362: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,

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

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

1671: 	strbuf_release(&cache->path);

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

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

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

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

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

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

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

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

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

1881: 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)

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

678: 		   const struct pathspec *pathspec,

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

866: ...(32 bytes skipped)...(struct repository*, unsigned int refresh_flags, unsigned int write_flags, int gentle, const struct pathspec *, char *seen, const char *header_msg);

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

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

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

706: export declare type Path = string & {

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

710: export declare class PathCannotBeFragmentException extends BaseException {

722: export declare class PathIsFileException extends BaseException {

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

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

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

663: export declare const NormalizedRoot: Path;

665: export declare const NormalizedSep: Path;

684:     path?: string;

707:     __PRIVATE_DEVKIT_PATH: void;

711:     constructor(path: string);

714: export declare type PathFragment = Path & {

715:     __PRIVATE_DEVKIT_PATH_FRAGMENT: void;

719:     constructor(path: string);

723:     constructor(path: string);

727:     constructor(path: string);

732:     path: string;

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

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

749:     __PRIVATE_DEVKIT_POSIX_PATH: void;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

940:     protected _root: Path;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1036:     delete(path: Path): void;

1037:     exists(path: Path): boolean;

1038:     isDirectory(path: Path): boolean;

1039:     isFile(path: Path): boolean;

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

1041:     read(path: Path): FileBuffer;

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

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

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

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

1125:         path: Path;

1128:         from: Path;

1129:         to: Path;

1134:         readonly files: Path[];

1138:             [path: string]: string;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1200:     __PRIVATE_DEVKIT_WINDOWS_PATH: void;

1206:     readonly root: Path;

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

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

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

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

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

1233:     constructor(path: Path);

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

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

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

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

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

718: export declare class PathIsDirectoryException extends BaseException {

726: export declare class PathMustBeAbsoluteException extends BaseException {

730: export declare class PathSpecificJsonException extends JsonException {

922:     dataPath: string;

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

532:   required string path = 3;

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

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.

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