Change WordParser.ReadWord to throw an exception.

BoolParser now consumes it like this, and is greatly simplified.

Addresses issue #103.

osh/bool_parse.py

@@ -65,25 +65,21 @@ def __init__(self, w_parser):
    self.error_stack = []

  def _NextOne(self, lex_mode=lex_mode_e.DBRACKET):
    #print('_Next', self.cur_word)
    n = len(self.words)
    if n == 2:
      assert lex_mode == lex_mode_e.DBRACKET
      self.words[0] = self.words[1]
      self.cur_word = self.words[0]
      del self.words[1]
    elif n in (0, 1):
      w = self.w_parser.ReadWord(lex_mode)
      if not w:
        err = self.w_parser.Error()
        self.error_stack.extend(err)
        return False
      w = self.w_parser.ReadWord(lex_mode)  # may raise
      if n == 0:
        self.words.append(w)
      else:
        self.words[0] = w
      self.cur_word = w

    assert self.cur_word is not None
    self.op_id = word.BoolId(self.cur_word)
    self.b_kind = LookupKind(self.op_id)
    #log('--- word %s', self.cur_word)
@@ -98,9 +94,7 @@ def _Next(self, lex_mode=lex_mode_e.DBRACKET):
    it's Id.WS_Newline -- we might have to unread tokens, etc.
    """
    while True:
      w = self._NextOne(lex_mode=lex_mode)
      if not w:
        return False
      self._NextOne(lex_mode=lex_mode)
      if self.op_id != Id.Op_Newline:
        break
    return True
@@ -110,12 +104,12 @@ def _LookAhead(self):
    if n != 1:
      raise AssertionError(self.words)

    w = self.w_parser.ReadWord(lex_mode_e.DBRACKET)
    w = self.w_parser.ReadWord(lex_mode_e.DBRACKET)  # may raise
    self.words.append(w)  # Save it for _Next()
    return w

  def Parse(self):
    if not self._Next(): return None
    self._Next()

    node = self.ParseExpr()
    if self.op_id != Id.Lit_DRightBracket:
@@ -131,7 +125,7 @@ def _TestAtEnd(self):

  def ParseForBuiltin(self):
    """For test builtin."""
    if not self._Next(): return None
    self._Next()

    node = self.ParseExpr()
    if self.op_id != Id.Eof_Real:
@@ -149,13 +143,10 @@ def ParseExpr(self):
    Expr    : Term (OR Expr)?
    """
    left = self.ParseTerm()
    if not left:
      return None  # TODO: An exception should handle this case.
    # [[ uses || while [ uses -o
    # [[ uses || but [ uses -o
    if self.op_id in (Id.Op_DPipe, Id.BoolUnary_o):
      if not self._Next(): return None
      self._Next()
      right = self.ParseExpr()
      if not right: return None
      return ast.LogicalOr(left, right)
    else:
      return left
@@ -168,13 +159,10 @@ def ParseTerm(self):
    Term    : Negated (AND Term)?
    """
    left = self.ParseNegatedFactor()
    if not left:
      return None  # TODO: An exception should handle this case.
    # [[ uses && while [ uses -a
    # [[ uses && but [ uses -a
    if self.op_id in (Id.Op_DAmp, Id.BoolUnary_a):
      if not self._Next(): return None
      self._Next()
      right = self.ParseTerm()
      if not right: return None
      return ast.LogicalAnd(left, right)
    else:
      return left
@@ -184,9 +172,8 @@ def ParseNegatedFactor(self):
    Negated : '!'? Factor
    """
    if self.op_id == Id.KW_Bang:
      if not self._Next(): return None
      self._Next()
      child = self.ParseFactor()
      if not child: return None
      return ast.LogicalNot(child)
    else:
      return self.ParseFactor()
@@ -201,9 +188,9 @@ def ParseFactor(self):
    if self.b_kind == Kind.BoolUnary:
      # Just save the type and not the token itself?
      op = self.op_id
      if not self._Next(): return None
      self._Next()
      w = self.cur_word
      if not self._Next(): return None
      self._Next()
      node = ast.BoolUnary(op, w)
      return node

@@ -218,16 +205,16 @@ def ParseFactor(self):
      if t2_b_kind in (Kind.BoolBinary, Kind.Redir):
        left = self.cur_word

        if not self._Next(): return None
        self._Next()
        op = self.op_id

        # TODO: Need to change to lex_mode_e.BASH_REGEX.
        # _Next(lex_mode) then?
        is_regex = t2_op_id == Id.BoolBinary_EqualTilde
        if is_regex:
          if not self._Next(lex_mode=lex_mode_e.BASH_REGEX): return None
          self._Next(lex_mode=lex_mode_e.BASH_REGEX)
        else:
          if not self._Next(): return None
          self._Next()

        right = self.cur_word
        if is_regex:
@@ -238,24 +225,25 @@ def ParseFactor(self):

          ok, regex_str, unused_quoted = word.StaticEval(right)

          # TODO: Should raise exception with error?
          # doesn't contain $foo, etc.
          if ok and not libc.regex_parse(regex_str):
            p_die("Invalid regex: %r" % regex_str, word=right)

        if not self._Next(): return None
        self._Next()
        return ast.BoolBinary(op, left, right)
      else:
        # [[ foo ]]
        w = self.cur_word
        if not self._Next(): return None
        self._Next()
        return ast.WordTest(w)

    if self.op_id == Id.Op_LParen:
      if not self._Next(): return None
      self._Next()
      node = self.ParseExpr()
      if self.op_id != Id.Op_RParen:
        p_die('Expected ), got %s', self.cur_word, word=self.cur_word)
      if not self._Next(): return None
      self._Next()
      return node

    # It's not WORD, UNARY_OP, or '('

osh/word_parse.py

@@ -1215,8 +1215,10 @@ def ReadWord(self, lex_mode):
      if not need_more:
        break

    # TODO: Just let it raise
    if not w:  # Assumes AddErrorContext was already called
      return None
      error_stack = self.Error()
      p_die('ReadWord: %s', error_stack[-1])

    self.cursor = w