def check_older(self): """ Check is the output file need to be update. """ if posix.access(self.dvi_filename, posix.F_OK) and posix.access(self.aux_filename, posix.F_OK): if file_time(self.dvi_filename) >= file_time(self.tex_filename) and file_time(self.aux_filename) >= file_time(self.bib_filename): return False return True
def check_older(self): if posix.access(self.bbl_filename, posix.F_OK) and posix.access(self.aux_filename, posix.F_OK): if ( file_time(self.dvi_filename) >= file_time(self.tex_filename) and file_time(self.bbl_filename) >= file_time(self.aux_filename) and file_time(self.aux_filename) >= file_time(self.bib_filename) ): return False return True
def check_older(self): """ Check is the output file need to be update. """ if posix.access(self.pdf_filename, posix.F_OK): if file_time(self.pdf_filename) >= file_time(self.ps_filename): return False return True
def _init_minos_dir(self): base_dir = path.expanduser('~') if not access(base_dir, W_OK): base_dir = path.join('/tmp') minos_dir = join(base_dir, 'minos') if not path.exists(minos_dir): makedirs(minos_dir) return minos_dir
def Matches(self, comp): to_complete = comp.to_complete # Problem: .. and ../.. don't complete /. # TODO: Set display_pos before fixing this. #import os #to_complete = os.path.normpath(to_complete) dirname, basename = os_path.split(to_complete) if dirname == '': # We're completing in this directory to_list = '.' else: # We're completing in some other directory to_list = dirname if 0: log('basename %r', basename) log('to_list %r', to_list) log('dirname %r', dirname) try: names = posix.listdir(to_list) except OSError as e: return # nothing for name in names: path = os_path.join(dirname, name) if path.startswith(to_complete): if self.dirs_only: # add_slash not used here # NOTE: There is a duplicate isdir() check later to add a trailing # slash. Consolidate the checks for fewer stat() ops. This is hard # because all the completion actions must obey the same interface. # We could have another type like candidate = File | Dir | # OtherString ? if path_stat.isdir(path): yield path continue if self.exec_only: # TODO: Handle exception if file gets deleted in between listing and # check? if not posix.access(path, posix.X_OK): continue if self.add_slash and path_stat.isdir(path): yield path + '/' else: yield path
def Matches(self, comp): """ TODO: Cache is never cleared. - When we get a newer timestamp, we should clear the old one. - When PATH is changed, we can remove old entries. """ val = self.mem.GetVar('PATH') if val.tag != value_e.Str: # No matches if not a string return path_dirs = val.s.split(':') #log('path: %s', path_dirs) executables = [] for d in path_dirs: try: st = posix.stat(d) except OSError as e: # There could be a directory that doesn't exist in the $PATH. continue key = (d, st.st_mtime) dir_exes = self.cache.get(key) if dir_exes is None: entries = posix.listdir(d) dir_exes = [] for name in entries: path = os_path.join(d, name) # TODO: Handle exception if file gets deleted in between listing and # check? if not posix.access(path, posix.X_OK): continue dir_exes.append(name) # append the name, not the path self.cache[key] = dir_exes executables.extend(dir_exes) # TODO: Shouldn't do the prefix / space thing ourselves. readline does # that at the END of the line. for word in executables: if word.startswith(comp.to_complete): yield word
def Matches(self, comp): to_complete = comp.to_complete i = to_complete.rfind('/') if i == -1: # it looks like 'foo' to_list = '.' base = '' elif i == 0: # it's an absolute path to_complete like / or /b to_list = '/' base = '/' else: to_list = to_complete[:i] base = to_list #log('to_list %r', to_list) try: names = posix.listdir(to_list) except OSError as e: return # nothing for name in names: path = os_path.join(base, name) if path.startswith(to_complete): if self.dirs_only: # add_slash not used here # NOTE: There is a duplicate isdir() check later to add a trailing # slash. Consolidate the checks for fewer stat() ops. This is hard # because all the completion actions must obey the same interface. # We could have another type like candidate = File | Dir | # OtherString ? if os_path.isdir(path): yield path continue if self.exec_only: # TODO: Handle exception if file gets deleted in between listing and # check? if not posix.access(path, posix.X_OK): continue if self.add_slash and os_path.isdir(path): yield path + '/' else: yield path
def test_access(self): if hasattr(posix, 'access'): self.assert_(posix.access(test_support.TESTFN, os.R_OK))
def writable_root(): """ Check if the root partition is writable. """ if posix.access('/', posix.W_OK): return True return False
def writable_root(): """ Check if the root partition is writable. """ if posix.access('/', posix.W_OK) or os.environ['TAGS'] == ':systemd:': return True return False
def Eval(self, node): #print('!!', node.tag) if node.tag == bool_expr_e.WordTest: s = self._EvalCompoundWord(node.w) return bool(s) if node.tag == bool_expr_e.LogicalNot: b = self.Eval(node.child) return not b if node.tag == bool_expr_e.LogicalAnd: # Short-circuit evaluation if self.Eval(node.left): return self.Eval(node.right) else: return False if node.tag == bool_expr_e.LogicalOr: if self.Eval(node.left): return True else: return self.Eval(node.right) if node.tag == bool_expr_e.BoolUnary: op_id = node.op_id s = self._EvalCompoundWord(node.child) # Now dispatch on arg type arg_type = BOOL_ARG_TYPES[op_id] # could be static in the LST? if arg_type == bool_arg_type_e.Path: # Only use lstat if we're testing for a symlink. if op_id in (Id.BoolUnary_h, Id.BoolUnary_L): try: mode = posix.lstat(s).st_mode except OSError: return False return stat.S_ISLNK(mode) try: mode = posix.stat(s).st_mode except OSError: # TODO: Signal extra debug information? #log("Error from stat(%r): %s" % (s, e)) return False if op_id in (Id.BoolUnary_e, Id.BoolUnary_a): # -a is alias for -e return True if op_id == Id.BoolUnary_f: return stat.S_ISREG(mode) if op_id == Id.BoolUnary_d: return stat.S_ISDIR(mode) if op_id == Id.BoolUnary_x: return posix.access(s, posix.X_OK) if op_id == Id.BoolUnary_r: return posix.access(s, posix.R_OK) if op_id == Id.BoolUnary_w: return posix.access(s, posix.W_OK) raise NotImplementedError(op_id) if arg_type == bool_arg_type_e.Str: if op_id == Id.BoolUnary_z: return not bool(s) if op_id == Id.BoolUnary_n: return bool(s) raise NotImplementedError(op_id) if arg_type == bool_arg_type_e.Other: if op_id == Id.BoolUnary_t: try: fd = int(s) except ValueError: # TODO: Need location information of [ e_die('Invalid file descriptor %r', s) return posix.isatty(fd) raise NotImplementedError(op_id) raise NotImplementedError(arg_type) if node.tag == bool_expr_e.BoolBinary: op_id = node.op_id s1 = self._EvalCompoundWord(node.left) # Whether to glob escape do_fnmatch = op_id in (Id.BoolBinary_GlobEqual, Id.BoolBinary_GlobDEqual, Id.BoolBinary_GlobNEqual) do_ere = (op_id == Id.BoolBinary_EqualTilde) s2 = self._EvalCompoundWord(node.right, do_fnmatch=do_fnmatch, do_ere=do_ere) # Now dispatch on arg type arg_type = BOOL_ARG_TYPES[op_id] if arg_type == bool_arg_type_e.Path: st1 = posix.stat(s1) st2 = posix.stat(s2) # TODO: test newer than (mtime) if op_id == Id.BoolBinary_nt: return st1[stat.ST_MTIME] > st2[stat.ST_MTIME] if op_id == Id.BoolBinary_ot: return st1[stat.ST_MTIME] < st2[stat.ST_MTIME] raise NotImplementedError(op_id) if arg_type == bool_arg_type_e.Int: # NOTE: We assume they are constants like [[ 3 -eq 3 ]]. # Bash also allows [[ 1+2 -eq 3 ]]. i1 = self._StringToIntegerOrError(s1, blame_word=node.left) i2 = self._StringToIntegerOrError(s2, blame_word=node.right) if op_id == Id.BoolBinary_eq: return i1 == i2 if op_id == Id.BoolBinary_ne: return i1 != i2 if op_id == Id.BoolBinary_gt: return i1 > i2 if op_id == Id.BoolBinary_ge: return i1 >= i2 if op_id == Id.BoolBinary_lt: return i1 < i2 if op_id == Id.BoolBinary_le: return i1 <= i2 raise NotImplementedError(op_id) if arg_type == bool_arg_type_e.Str: if op_id in (Id.BoolBinary_GlobEqual, Id.BoolBinary_GlobDEqual): #log('Matching %s against pattern %s', s1, s2) # TODO: Respect extended glob? * and ! and ? are quoted improperly. # But @ and + are OK. return libc.fnmatch(s2, s1) if op_id == Id.BoolBinary_GlobNEqual: return not libc.fnmatch(s2, s1) if op_id in (Id.BoolBinary_Equal, Id.BoolBinary_DEqual): return s1 == s2 if op_id == Id.BoolBinary_NEqual: return s1 != s2 if op_id == Id.BoolBinary_EqualTilde: #log('Matching %r against regex %r', s1, s2) try: matches = libc.regex_match(s2, s1) except RuntimeError: # 2 means a parse error. Note this is a fatal error in OSH but not # in bash. e_die("Invalid regex %r", s2, word=node.right, status=2) if matches is None: return False self._SetRegexMatches(matches) return True if op_id == Id.Redir_Less: # pun return s1 < s2 if op_id == Id.Redir_Great: # pun return s1 > s2 raise NotImplementedError(op_id) raise AssertionError(node.tag)