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)
def writable_root():
""" Check if the root partition is writable. """
if posix.access('/', posix.W_OK):
return True
return False
