15: package path

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

45: 	Path() *Any

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

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

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

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

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

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

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

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

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

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

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

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

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

497: // NewField returns a new Field path.

504: // NewArrayIndex returns a new ArrayIndex path.

511: // NewMapIndex returns a new MapIndex path.

521: // NewSlice returns a new Slice path.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

25: 	Path []PathStep

30: 	PathStep interface {

187: 	pathStep struct {

192: 		pathStep

196: 		pathStep

200: 		pathStep

203: 		pathStep

215: 		pathStep

218: 		pathStep

270: func (pathStep) isPathStep()           {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

38: 		PathStep

56: 		PathStep

62: 		PathStep

67: 		PathStep

74: 		PathStep

79: 		PathStep

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

114: 		return pathStep{}

142: 		var nextStep PathStep

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

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

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

286: 	_ PathStep = sliceIndex{}

287: 	_ PathStep = mapIndex{}

288: 	_ PathStep = typeAssertion{}

289: 	_ PathStep = structField{}

290: 	_ PathStep = indirect{}

291: 	_ PathStep = transform{}

33: 		isPathStep()

6: package path

76: 		o.Array = obj.(Path)

113: 	Package: "path",

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

163: 	Package: "path",

218: 	Package: "path",

284: 	Package: "path",

334: 	Package: "path",

383: 	Package: "path",

412: 		o.Struct = obj.(Path)

449: 	Package: "path",

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

505: 	Package: "path",

554: 	Package: "path",

592: 		o.Map = obj.(Path)

633: 	Package: "path",

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

722: 	Package: "path",

780: 	Package: "path",

812: 		o.Array = obj.(Path)

857: 	Package: "path",

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

914: 	Package: "path",

963: 	Package: "path",

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

14:   pathMismatch(npmRoot) {

29: function fixPath(filepath) {

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

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

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

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

22:       path: process.env.NODE_PATH,

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

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

18:       msgPath += '-windows';

21:     return message.get(msgPath, {

33:     fixedPath = fs.realpathSync(fixedPath);

40:   return fixedPath;

57:     const npmRoot = fixPath(stdout);

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

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

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

25:   string path_;

17: class ScopedTempPath {

19:   ScopedTempPath() {}

6: #define CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

5: #ifndef CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

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

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

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

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

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

53: #endif  // CHROMIUMOS_WIDE_PROFILING_SCOPED_TEMP_PATH_H_

21:   virtual ~ScopedTempPath();

28:   DISALLOW_COPY_AND_ASSIGN(ScopedTempPath);

31: class ScopedTempFile : public ScopedTempPath {

41: class ScopedTempDir : public ScopedTempPath {

11: 	Path

1: package jsonpath

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

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

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

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

75: 		Path:        *p,

99: 	// run path function for each path

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

59: 	for _, p := range paths {

76: 		state:       pathMatchOp,

232: 		return pathEndValue

238: 		return pathMatchOp

282: 		return pathMatchOp

284: 	return pathEndValue

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

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

60: class Path : public ThreadCapture<Path> {

56:   std::ostringstream path_;

34: class PathBuilder {

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

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

95: class InRootPath : public Path {

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

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

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

116: class InLocalPath : public Path {

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

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

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

111:   const std::string root_path_;

137:   const std::string local_path_;

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

41:         path_.str("");

42:         path_ << component;

45:           path_ << '/';

47:         path_ << component;

86:     return path.RootPath();

90:     path.AppendLocalPath(builder);

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

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

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

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

133:     builder->Add(local_path_);

143:   InLocalPath path("bin");

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

152:   InLocalPath path("lib");

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

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

161:   InRootPath root(path);

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

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

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

59: // Tracks persistent root and local paths.

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

72:       PathBuilder builder;

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

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

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

106:       DelegateLocalPath(*previous, builder);

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

131:       DelegateLocalPath(*previous, builder);

145:     InLocalPath file(target);

154:     InLocalPath file(target);

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

43: type Path struct {

44: 	path string

30: package paths

84: func (p *Path) JoinPath(paths ...*Path) *Path {

37: 	"path/filepath"

42: // Path represents a path

47: // New creates a new Path object. If path is the empty string

49: func New(path ...string) *Path {

50: 	if len(path) == 0 {

53: 	res := &Path{path: path[0]}

54: 	if len(path) > 1 {

55: 		return res.Join(path[1:]...)

60: // NewFromFile creates a new Path object using the path name

62: func NewFromFile(file *os.File) *Path {

69: func (p *Path) Stat() (os.FileInfo, error) {

70: 	return os.Stat(p.path)

73: // Clone create a copy of the Path object

74: func (p *Path) Clone() *Path {

75: 	return New(p.path)

78: // Join create a new Path by joining the provided paths

79: func (p *Path) Join(paths ...string) *Path {

80: 	return New(filepath.Join(p.path, filepath.Join(paths...)))

83: // JoinPath create a new Path by joining the provided paths

86: 	for _, path := range paths {

87: 		res = res.Join(path.path)

92: // Base returns the last element of path

93: func (p *Path) Base() string {

94: 	return filepath.Base(p.path)

97: // Ext returns the file name extension used by path

98: func (p *Path) Ext() string {

99: 	return filepath.Ext(p.path)

105: func (p *Path) HasPrefix(prefixes ...string) bool {

117: func (p *Path) HasSuffix(suffixies ...string) bool {

127: // RelTo returns a relative Path that is lexically equivalent to r when

128: // joined to the current Path

129: func (p *Path) RelTo(r *Path) (*Path, error) {

130: 	rel, err := filepath.Rel(p.path, r.path)

137: // Abs returns the absolute path of the current Path

138: func (p *Path) Abs() (*Path, error) {

139: 	abs, err := filepath.Abs(p.path)

146: // IsAbs returns true if the Path is absolute

147: func (p *Path) IsAbs() bool {

148: 	return filepath.IsAbs(p.path)

151: // ToAbs transofrm the current Path to the corresponding absolute path

152: func (p *Path) ToAbs() error {

153: 	abs, err := filepath.Abs(p.path)

157: 	p.path = abs

161: // Clean Clean returns the shortest path name equivalent to path by

163: func (p *Path) Clean() *Path {

164: 	return New(filepath.Clean(p.path))

167: // IsInsideDir returns true if the current path is inside the provided

169: func (p *Path) IsInsideDir(dir *Path) (bool, error) {

170: 	rel, err := filepath.Rel(dir.path, p.path)

177: // Parent returns all but the last element of path, typically the path's

178: // directory or the parent directory if the path is already a directory

179: func (p *Path) Parent() *Path {

180: 	return New(filepath.Dir(p.path))

183: // Mkdir create a directory denoted by the current path

184: func (p *Path) Mkdir() error {

185: 	return os.Mkdir(p.path, 0755)

188: // MkdirAll creates a directory named path, along with any necessary

190: func (p *Path) MkdirAll() error {

191: 	return os.MkdirAll(p.path, os.FileMode(0755))

195: func (p *Path) Remove() error {

196: 	return os.Remove(p.path)

199: // RemoveAll removes path and any children it contains. It removes

201: // the path does not exist, RemoveAll returns nil (no error).

202: func (p *Path) RemoveAll() error {

203: 	return os.RemoveAll(p.path)

206: // Rename renames (moves) the path to newpath. If newpath already exists

210: func (p *Path) Rename(newpath *Path) error {

211: 	return os.Rename(p.path, newpath.path)

214: // MkTempDir creates a new temporary directory inside the path

215: // pointed by the Path object with a name beginning with prefix

216: // and returns the path of the new directory.

217: func (p *Path) MkTempDir(prefix string) (*Path, error) {

218: 	return MkTempDir(p.path, prefix)

221: // FollowSymLink transforms the current path to the path pointed by the

222: // symlink if path is a symlink, otherwise it does nothing

223: func (p *Path) FollowSymLink() error {

224: 	resolvedPath, err := filepath.EvalSymlinks(p.path)

228: 	p.path = resolvedPath

232: // Exist return true if the file denoted by this path exists, false

234: func (p *Path) Exist() bool {

239: // NotExist return true if the file denoted by this path DO NOT exists, false

241: func (p *Path) NotExist() bool {

246: // ExistCheck return true if the path exists or false if the path doesn't exists.

248: func (p *Path) ExistCheck() (bool, error) {

259: // IsDir returns true if the path exists and is a directory. In all the other

261: func (p *Path) IsDir() bool {

266: // IsNotDir returns true if the path exists and is NOT a directory. In all the other

268: func (p *Path) IsNotDir() bool {

273: // IsDirCheck return true if the path exists and is a directory or false

274: // if the path exists and is not a directory. In all the other case false and

276: func (p *Path) IsDirCheck() (bool, error) {

288: // pointed by the current Path

289: func (p *Path) ReadDir() (PathList, error) {

290: 	infos, err := ioutil.ReadDir(p.path)

296: 		path := p.Clone().Join(info.Name())

297: 		paths.Add(path)

307: func (p *Path) CopyTo(dst *Path) error {

308: 	in, err := os.Open(p.path)

314: 	out, err := os.Create(dst.path)

333: 	err = os.Chmod(dst.path, si.Mode())

341: // CopyDirTo recursively copies the directory denoted by the current path to

342: // the destination path. The source directory must exist and the destination

345: func (p *Path) CopyDirTo(dst *Path) error {

368: 	if err := os.Chmod(dst.path, srcInfo.Mode()); err != nil {

401: func (p *Path) Chtimes(atime, mtime time.Time) error {

402: 	return os.Chtimes(p.path, atime, mtime)

406: func (p *Path) ReadFile() ([]byte, error) {

407: 	return ioutil.ReadFile(p.path)

413: func (p *Path) WriteFile(data []byte) error {

414: 	return ioutil.WriteFile(p.path, data, os.FileMode(0644))

420: func (p *Path) ReadFileAsLines() ([]string, error) {

430: // Truncate create an empty file named by path or if the file already

432: func (p *Path) Truncate() error {

437: func (p *Path) EqualsTo(other *Path) bool {

438: 	return p.path == other.path

443: func (p *Path) EquivalentTo(other *Path) bool {

444: 	return p.Clean().path == other.Clean().path

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

448: 	return p.path

2:  * This file is part of PathsHelper library.

6:  * PathsHelper library is free software; you can redistribute it and/or modify

174: 	return !strings.Contains(rel, ".."+string(os.PathSeparator)) && rel != ".." && rel != ".", nil

208: // may apply when oldpath and newpath are in different directories. If

287: // ReadDir returns a PathList containing the content of the directory

294: 	paths := PathList{}

299: 	return paths, nil

372: 	for _, srcPath := range srcFiles {

373: 		srcPathInfo, err := srcPath.Stat()

375: 			return fmt.Errorf("getting stat info for %s: %s", srcPath, err)

377: 		dstPath := dst.Join(srcPath.Base())

380: 			if err := srcPath.CopyDirTo(dstPath); err != nil {

381: 				return fmt.Errorf("copying %s to %s: %s", srcPath, dstPath, err)

392: 		if err := srcPath.CopyTo(dstPath); err != nil {

393: 			return fmt.Errorf("copying %s to %s: %s", srcPath, dstPath, err)

436: // EqualsTo return true if both paths are equal

441: // EquivalentTo return true if both paths are equivalent (they points to the

379: 		if srcPathInfo.IsDir() {

387: 		if srcPathInfo.Mode()&os.ModeSymlink != 0 {

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,

1: package path;

39: message Path {

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

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

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

8:             "type": "Path"

11:         "requiredType": "Path",

20:         "name": "pathPropertyDef"

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

559: TCL_PATH = tclsh

560: TCLTK_PATH = wish

803: 	SHELL_PATH = /bin/sh

806: 	PERL_PATH = /usr/bin/perl

809: 	PYTHON_PATH = /usr/bin/python

815: TEST_SHELL_PATH = $(SHELL_PATH)

540: pathsep = :

1260: 		CC_LD_DYNPATH = -Wl,-rpath,

1262: 		CC_LD_DYNPATH = -R

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

458: # current executable path.

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

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

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

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

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

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

569: export TCL_PATH TCLTK_PATH

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

802: ifndef SHELL_PATH

805: ifndef PERL_PATH

808: ifndef PYTHON_PATH

812: export PERL_PATH

813: export PYTHON_PATH

945: LIB_OBJS += path.o

1204: ifdef SANE_TOOL_PATH

1259: 		# the runtime dynamic library path.

1357: ifdef ZLIB_PATH

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

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

1763: ifneq ($(PROCFS_EXECUTABLE_PATH),)

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

1768: ifdef HAVE_NS_GET_EXECUTABLE_PATH

1769: 	BASIC_CFLAGS += -DHAVE_NS_GET_EXECUTABLE_PATH

1776: ifeq ($(TCLTK_PATH),)

1780: ifeq ($(PERL_PATH),)

1784: ifeq ($(PYTHON_PATH),)

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

1932: ifdef SHELL_PATH

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

1959: export DIFF TAR INSTALL DESTDIR SHELL_PATH

1964: SHELL = $(SHELL_PATH)

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

2003: shell_compatibility_test: please_set_SHELL_PATH_to_a_more_modern_shell

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

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

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

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

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

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

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

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

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

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

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

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

2090:     -e $(BROKEN_PATH_FIX) \

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2632: ### Detect Python interpreter path changes

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

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

2994: .PHONY: shell_compatibility_test please_set_SHELL_PATH_to_a_more_modern_shell

259: # that tells runtime paths to dynamic libraries;

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

609: unexport CDPATH

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

829: LIB_OBJS += abspath.o

946: LIB_OBJS += pathspec.o

1256: ifndef CC_LD_DYNPATH

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

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

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

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

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

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

1684: ifdef HAVE_PATHS_H

1685: 	BASIC_CFLAGS += -DHAVE_PATHS_H

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

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

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

1317: 	char *path;

1547: 	struct strbuf path;

584: #define READ_GITFILE_ERR_NO_PATH 6

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

1311: 	struct strbuf symlink_path;

1327: #define GET_OID_RECORD_PATH     0200

481: #define EXEC_PATH_ENVIRONMENT "GIT_EXEC_PATH"

496: #define GIT_LITERAL_PATHSPECS_ENVIRONMENT "GIT_LITERAL_PATHSPECS"

497: #define GIT_GLOB_PATHSPECS_ENVIRONMENT "GIT_GLOB_PATHSPECS"

498: #define GIT_NOGLOB_PATHSPECS_ENVIRONMENT "GIT_NOGLOB_PATHSPECS"

499: #define GIT_ICASE_PATHSPECS_ENVIRONMENT "GIT_ICASE_PATHSPECS"

15: #include "path.h"

360: 				     const char *path,

374: 					       const char *path,

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

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

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

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

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

500: #define GIT_QUARANTINE_ENVIRONMENT "GIT_QUARANTINE_PATH"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

846: extern int quote_path_fully;

857: extern const char *git_hooks_path;

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

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

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

1143: int adjust_shared_perm(const char *path);

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

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

1158:  * safe_create_leading_directories() temporarily changes path while it

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

1170: enum scld_error safe_create_leading_directories(char *path);

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

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

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

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

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

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

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

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

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

1216: int mkdir_in_gitdir(const char *path);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1237: int daemon_avoid_alias(const char *path);

1308: 	 * symlink_path is only used by get_tree_entry_follow_symlinks,

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

1555: 	strbuf_release(&cache->path);

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

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

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

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

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

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

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

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

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

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

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

221: struct pathspec;

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

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

665: 			  const struct pathspec *pathspec,

668: 			      const struct pathspec *pathspec,

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

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

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

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

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

321:     path: 4

466:   var pathVertexPositionBuffer;

467:   var pathVertexColorBuffer;

1076:     function SubPath(x, y) {

1082:     gl.beginPath = function beginPath() {

1087:     gl.closePath = function closePath() {

1130:     function fillSubPath(index) {

1159:     function strokeSubPath(index) {

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

1074:     var subPaths = [];

483:     pathVertexPositionBuffer  = gl.createBuffer();

484:     pathVertexColorBuffer     = gl.createBuffer();

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

1089:         // Mark last subpath closed.

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

1091:         prevPath.closed = true;

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

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

1095:         subPaths.push(newPath);

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

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

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

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

1125:       gl.closePath();

1134:       var subPath = subPaths[index];

1135:       var verts = subPath.verts;

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

1155:         fillSubPath(i);

1163:       var subPath = subPaths[index];

1164:       var verts = subPath.verts;

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

1177:       if (subPath.closed) {

1188:         strokeSubPath(i);

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

1083:       subPaths.length = 0;

1088:       if (subPaths.length) {

1105:       if (subPaths.length) {

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

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

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

127:   required string path = 1;

485:   required string path = 1;

527:   optional string path = 2;

651:   required string path = 1;

659:   required string path = 1;

667:   required string path = 1;

706:   required string path = 1;

787:   required string path = 1;

817:   optional string path = 3;

822:   required string path = 2;

709:   optional string targetPath = 1;

752:   required string snapshotPath = 1;

999:   rpc getEZForPath(GetEZForPathRequestProto)

1000:       returns(GetEZForPathResponseProto);

56:   required string path = 1;

91:   required string path = 1;

421:   optional string path = 3;

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

540:   required bytes parent_fullpath = 4;

554:   required bytes fullpath = 1;

556:   optional bytes targetPath = 3;

574:   required bytes fullpath = 1;

577:   optional bytes targetPath = 4;

582:   required bytes startPath = 1;

418: message HdfsPathHandleProto {

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

532:  * the full path of the parent directory. 

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

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

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

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

114:     outputPath: baseOutputPath,

137:     outputPath: baseOutputPath,

257:     outputPath: baseOutputPath,

285:     outputPath: baseOutputPath,

305:     outputPath: baseOutputPath,

329:     outputPath: baseOutputPath,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

207:     outputFile = path.join(

213:     template = path.join(

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

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

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

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

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

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

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

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

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

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

354:   const template = path.join(

362:   const outFile = path.join(

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

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

182:   options.outputPath = baseOutputPath;

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

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

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

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

371:     outputPath: baseOutputPath,

184:       "path": "./dist/extension/scripts/lighthouse-ext-bundle.js",

188:       "path": "./dist/viewer/src/viewer.js",

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

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

411: 	Path uint64

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

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

423: 	q.Path = b.Read64()

430: 	b.Write64(q.Path)

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

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

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

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

223: 	Path   [UnixPathMax]int8

218: const UnixPathMax = 108

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5074: google.maps.SymbolPath = {

5627:  * @param {string} encodedPath

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

1711:   includePaths: [

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

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

1710:   // include paths for css preprocessor support

10: const path = require('path')

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

142:   refreshFile (path) {

143:     return this._fileList ? this._fileList.changeFile(path) : Promise.resolve()

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

206:       const configPath = config.browserConsoleLogOptions.path

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5288: google.maps.SymbolPath = {

5812:  * @param {string} encodedPath

778:   uint32_t path;

775: struct rpath_command {

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

1185: inline void swapStruct(rpath_command &r) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

5204: google.maps.SymbolPath = {

5720:  * @param {string} encodedPath

154:   optional string path = 3;

450:     optional string path = 2;

529:     optional string path = 2;

1434:         PATH = 1;

1442:       message Path {

1458:       optional Path path = 2;

2961:       required string path = 1;

2981:       required string path = 2;

3559:   required string path = 1;

3591:   optional string path = 1;

2919:   required string container_path = 1;

2926:   optional string host_path = 2;

2943:       HOST_PATH = 4;

2944:       SANDBOX_PATH = 2;

2993:     optional HostPath host_path = 5;

2994:     optional SandboxPath sandbox_path = 3;

2960:     message HostPath {

2970:     message SandboxPath {

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

449:     // HTTP request path.

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

528:     // HTTP request path.

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

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

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

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

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

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

1981:     // created on ROOT/PATH disk.

1989:     // created on ROOT/PATH disk.

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

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

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

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

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

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

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

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

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

3558:   // Absolute path to the file.

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

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