class _Builtin(object):
"""All builtins except 'command' obey this interface.
Assignment builtins use cmd_value__Assign; others use cmd_value__Argv.
"""
def Run(self, cmd_val):
# type: (cmd_value_t) -> int
raise NotImplementedError()
#
# Implementation of builtins.
#
if mylib.PYTHON:
TIMES_SPEC = arg_def.Register('times')
class Times(_Builtin):
def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
utime, stime, cutime, cstime, elapsed = posix.times()
print("%dm%1.3fs %dm%1.3fs" %
(utime / 60, utime % 60, stime / 60, stime % 60))
print("%dm%1.3fs %dm%1.3fs" %
(cutime / 60, cutime % 60, cstime / 60, cstime % 60))
return 0
# The Read builtin splits using IFS.
from mycpp.mylib import tagswitch
from osh.builtin_misc import _Builtin
import posix_ as posix
from typing import List, Dict, Any, cast, TYPE_CHECKING
if TYPE_CHECKING:
from _devbuild.gen.syntax_asdl import command_t
from core.ui import ErrorFormatter
from core.process import JobState, Waiter, SignalState
from osh.cmd_exec import Executor
from core.state import Mem
if mylib.PYTHON:
WAIT_SPEC = arg_def.Register('wait')
WAIT_SPEC.ShortFlag('-n')
class Wait(object):
"""
wait: wait [-n] [id ...]
Wait for job completion and return exit status.
Waits for each process identified by an ID, which may be a process ID or a
job specification, and reports its termination status. If ID is not
given, waits for all currently active child processes, and the return
status is zero. If ID is a a job specification, waits for all processes
in that job's pipeline.
If the -n option is supplied, waits for the next job to terminate and
from frontend import match
from frontend import reader
from mycpp import mylib
from osh import string_ops
from osh import word_compile
from typing import Dict, List, TYPE_CHECKING
if TYPE_CHECKING:
from frontend.lexer import Lexer
from frontend.parse_lib import ParseContext
from core.state import Mem
from core.ui import ErrorFormatter
if mylib.PYTHON:
PRINTF_SPEC = arg_def.Register('printf') # TODO: Don't need this?
PRINTF_SPEC.ShortFlag('-v', args.Str)
class _FormatStringParser(object):
"""
Grammar:
fmt = Format_Percent Flag? Num? (Dot Num)? Type
part = Char_* | Format_EscapedPercent | fmt
printf_format = part* Eof_Real # we're using the main lexer
Maybe: bash also supports %(strftime)T
"""
def __init__(self, lexer):
# type: (Lexer) -> None
from core.state import MutableOpts, Mem, SearchPath
class Boolean(_Builtin):
"""For :, true, false."""
def __init__(self, status):
# type: (int) -> None
self.status = status
def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
return self.status
if mylib.PYTHON:
ALIAS_SPEC = arg_def.Register('alias')
class Alias(object):
def __init__(self, aliases, errfmt):
# type: (Dict, ErrorFormatter) -> None
self.aliases = aliases
self.errfmt = errfmt
def Run(self, cmd_val):
# type: (cmd_value__Argv) -> int
argv = cmd_val.argv
if len(argv) == 1:
for name in sorted(self.aliases):
alias_exp = self.aliases[name]
# This is somewhat like bash, except we use %r for ''.
#from core.util import log
from frontend import args
from frontend import match
from core import state
from mycpp import mylib
from typing import Dict, Tuple, Any, TYPE_CHECKING
if TYPE_CHECKING:
from core.state import Mem
from core.ui import ErrorFormatter
if mylib.PYTHON:
from frontend import arg_def
if mylib.PYTHON:
EXPORT_SPEC = arg_def.Register('export')
EXPORT_SPEC.ShortFlag('-n')
EXPORT_SPEC.ShortFlag('-f') # stubbed
# Instead of Reader? Or just make everything take a reader/
# They should check for extra args?
#spec.AcceptsCmdVal()
# Later, use it like:
#
# from _devbuild.gen import arg_parse
#
# arg = arg_parse.export_cmdval(cmd_val)?
# arg = arg_parse.echo(arg_r)
# arg = arg_parse.bin_oil(arg_r)?
#
# So from arg_def you generate arg_parse.