Method parsePrefix

src/script_parser.cpp:163–252

Prefix: atoms and unary prefix operators

  /// Prefix: atoms and unary prefix operators
  Ast::expr_ptr parsePrefix()
  {
    const auto& tok = peek();

    // Unary minus
    if(tok.type == TokenType::Minus)
    {
      advance();
      auto operand = parseExpr(kPrefixBP);
      return std::make_shared<Ast::ExprUnaryArithmetic>(Ast::ExprUnaryArithmetic::negate,
                                                        std::move(operand));
    }
    // Bitwise complement
    if(tok.type == TokenType::Tilde)
    {
      advance();
      auto operand = parseExpr(kPrefixBP);
      return std::make_shared<Ast::ExprUnaryArithmetic>(
          Ast::ExprUnaryArithmetic::complement, std::move(operand));
    }
    // Logical NOT
    if(tok.type == TokenType::Bang)
    {
      advance();
      auto operand = parseExpr(kPrefixBP);
      return std::make_shared<Ast::ExprUnaryArithmetic>(
          Ast::ExprUnaryArithmetic::logical_not, std::move(operand));
    }
    // Parenthesized expression
    if(tok.type == TokenType::LeftParen)
    {
      advance();
      auto expr = parseExpr(0);
      expect(TokenType::RightParen, "expected ')'");
      return expr;
    }
    // Boolean literal
    if(tok.type == TokenType::Boolean)
    {
      advance();
      double val = (tok.text == "true") ? 1.0 : 0.0;
      return std::make_shared<Ast::ExprLiteral>(Any(val));
    }
    // Integer literal
    if(tok.type == TokenType::Integer)
    {
      advance();
      int64_t val = 0;
      const char* first = tok.text.data();
      const char* last = first + tok.text.size();
      if(tok.text.size() > 2 && tok.text[0] == '0' &&
         (tok.text[1] == 'x' || tok.text[1] == 'X'))
      {
        std::from_chars(first + 2, last, val, 16);
      }
      else
      {
        std::from_chars(first, last, val, 10);