line.go

Documentation: github.com/twitchyliquid64/golang-asm/objabi

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package objabi
     6  
     7  import (
     8  	"os"
     9  	"path/filepath"
    10  	"strings"
    11  )
    12  
    13  // WorkingDir returns the current working directory
    14  // (or "/???" if the directory cannot be identified),
    15  // with "/" as separator.
    16  func WorkingDir() string {
    17  	var path string
    18  	path, _ = os.Getwd()
    19  	if path == "" {
    20  		path = "/???"
    21  	}
    22  	return filepath.ToSlash(path)
    23  }
    24  
    25  // AbsFile returns the absolute filename for file in the given directory,
    26  // as rewritten by the rewrites argument.
    27  // For unrewritten paths, AbsFile rewrites a leading $GOROOT prefix to the literal "$GOROOT".
    28  // If the resulting path is the empty string, the result is "??".
    29  //
    30  // The rewrites argument is a ;-separated list of rewrites.
    31  // Each rewrite is of the form "prefix" or "prefix=>replace",
    32  // where prefix must match a leading sequence of path elements
    33  // and is either removed entirely or replaced by the replacement.
    34  func AbsFile(dir, file, rewrites string) string {
    35  	abs := file
    36  	if dir != "" && !filepath.IsAbs(file) {
    37  		abs = filepath.Join(dir, file)
    38  	}
    39  
    40  	start := 0
    41  	for i := 0; i <= len(rewrites); i++ {
    42  		if i == len(rewrites) || rewrites[i] == ';' {
    43  			if new, ok := applyRewrite(abs, rewrites[start:i]); ok {
    44  				abs = new
    45  				goto Rewritten
    46  			}
    47  			start = i + 1
    48  		}
    49  	}
    50  	if hasPathPrefix(abs, GOROOT) {
    51  		abs = "$GOROOT" + abs[len(GOROOT):]
    52  	}
    53  
    54  Rewritten:
    55  	if abs == "" {
    56  		abs = "??"
    57  	}
    58  	return abs
    59  }
    60  
    61  // applyRewrite applies the rewrite to the path,
    62  // returning the rewritten path and a boolean
    63  // indicating whether the rewrite applied at all.
    64  func applyRewrite(path, rewrite string) (string, bool) {
    65  	prefix, replace := rewrite, ""
    66  	if j := strings.LastIndex(rewrite, "=>"); j >= 0 {
    67  		prefix, replace = rewrite[:j], rewrite[j+len("=>"):]
    68  	}
    69  
    70  	if prefix == "" || !hasPathPrefix(path, prefix) {
    71  		return path, false
    72  	}
    73  	if len(path) == len(prefix) {
    74  		return replace, true
    75  	}
    76  	if replace == "" {
    77  		return path[len(prefix)+1:], true
    78  	}
    79  	return replace + path[len(prefix):], true
    80  }
    81  
    82  // Does s have t as a path prefix?
    83  // That is, does s == t or does s begin with t followed by a slash?
    84  // For portability, we allow ASCII case folding, so that hasPathPrefix("a/b/c", "A/B") is true.
    85  // Similarly, we allow slash folding, so that hasPathPrefix("a/b/c", "a\\b") is true.
    86  // We do not allow full Unicode case folding, for fear of causing more confusion
    87  // or harm than good. (For an example of the kinds of things that can go wrong,
    88  // see http://article.gmane.org/gmane.linux.kernel/1853266.)
    89  func hasPathPrefix(s string, t string) bool {
    90  	if len(t) > len(s) {
    91  		return false
    92  	}
    93  	var i int
    94  	for i = 0; i < len(t); i++ {
    95  		cs := int(s[i])
    96  		ct := int(t[i])
    97  		if 'A' <= cs && cs <= 'Z' {
    98  			cs += 'a' - 'A'
    99  		}
   100  		if 'A' <= ct && ct <= 'Z' {
   101  			ct += 'a' - 'A'
   102  		}
   103  		if cs == '\\' {
   104  			cs = '/'
   105  		}
   106  		if ct == '\\' {
   107  			ct = '/'
   108  		}
   109  		if cs != ct {
   110  			return false
   111  		}
   112  	}
   113  	return i >= len(s) || s[i] == '/' || s[i] == '\\'
   114  }
   115
View as plain text