Parser Class Reference

Parser module for the GSC programming language. More...

#include <parser.hpp>

Collaboration diagram for Parser:

Classes
struct	ParseError

Public Member Functions
	Parser (const std::vector< Token > &tokens)
	Constructs a Parser object.
std::vector< std::shared_ptr< Stmt > >	parse ()
	Parses the tokens and returns a vector of statements.

Private Member Functions
std::vector< std::shared_ptr< Stmt > >	block ()
std::shared_ptr< Stmt >	declaration ()
std::shared_ptr< Stmt >	statement ()
std::shared_ptr< Stmt >	printStatement ()
std::shared_ptr< Stmt >	ifStatement ()
std::shared_ptr< Stmt >	whileStatement ()
std::shared_ptr< Stmt >	forStatement ()
std::shared_ptr< Stmt >	varDeclaration ()
std::shared_ptr< Stmt >	expressionStatement ()
std::shared_ptr< Expr >	assignment ()
std::shared_ptr< Expr >	orLogical ()
std::shared_ptr< Expr >	andLogical ()
std::shared_ptr< Expr >	expression ()
std::shared_ptr< Expr >	equality ()
std::shared_ptr< Expr >	comparison ()
std::shared_ptr< Expr >	term ()
std::shared_ptr< Expr >	factor ()
std::shared_ptr< Expr >	unary ()
std::shared_ptr< Expr >	primary ()
template<class... T>
bool	match (T... types)
bool	check (TokenType type) const
bool	isAtEnd () const
Token	consume (TokenType type, std::string_view message)
Token	advance ()
Token	peek () const
Token	previous () const
ParseError	error (const Token &token, std::string_view message)
void	synchronize ()

Private Attributes
const std::vector< Token > &	tokens
int	current = 0

Detailed Description

Parser module for the GSC programming language.

Parser is responsible for parsing the tokens generated by the Scanner and constructing an abstract syntax tree (AST) from them.

Definition at line 16 of file parser.hpp.

Constructor & Destructor Documentation

Parser()

Parser::Parser

(

const std::vector< Token > &

tokens

)

Constructs a Parser object.

Parameters

tokens

The vector of tokens to parse.

Definition at line 5 of file parser.cpp.

: tokens(tokens) {}

Member Function Documentation

advance()

Token Parser::advance ( )

private

Definition at line 286 of file parser.cpp.

                      {
  if (!isAtEnd())
    current++;
  return previous();
}

andLogical()

std::shared_ptr< Expr > Parser::andLogical ( )

private

Definition at line 163 of file parser.cpp.

                                       {
  std::shared_ptr<Expr> expr = equality();
 
  while (match(TokenType::AND)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = equality();
    expr = std::make_shared<Logical>(expr, std::move(operatorToken), right);
  }
 
  return expr;
}

assignment()

std::shared_ptr< Expr > Parser::assignment ( )

private

Definition at line 133 of file parser.cpp.

                                       {
  std::shared_ptr<Expr> expr = orLogical();
 
  if (match(TokenType::EQUAL)) {
    Token equals = previous();
    std::shared_ptr<Expr> value = assignment();
 
    if (std::shared_ptr<Variable> var =
            std::dynamic_pointer_cast<Variable>(expr)) {
      return std::make_shared<Assign>(var->getName(), value);
    }
 
    throw error(equals, "Invalid assignment target.");
  }
 
  return expr;
}

block()

std::vector< std::shared_ptr< Stmt > > Parser::block ( )

private

Definition at line 122 of file parser.cpp.

                                             {
  std::vector<std::shared_ptr<Stmt>> statements;
 
  while (!isAtEnd() && !check(TokenType::RIGHT_BRACE)) {
    statements.push_back(declaration());
  }
 
  consume(TokenType::RIGHT_BRACE, "Expect '}' after block.");
  return statements;
}

check()

bool Parser::check ( TokenType  type ) const

private

Definition at line 269 of file parser.cpp.

                                       {
  if (isAtEnd())
    return false;
  return peek().getType() == type;
}

comparison()

std::shared_ptr< Expr > Parser::comparison ( )

private

Definition at line 189 of file parser.cpp.

                                       {
  std::shared_ptr<Expr> expr = term();
 
  while (match(TokenType::GREATER, TokenType::GREATER_EQUAL, TokenType::LESS,
               TokenType::LESS_EQUAL)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = term();
    expr = std::make_shared<Binary>(expr, std::move(operatorToken), right);
  }
 
  return expr;
}

consume()

Token Parser::consume ( TokenType  type, std::string_view  message  )

private

Definition at line 279 of file parser.cpp.

                                                            {
  if (check(type))
    return advance();
 
  throw error(peek(), message);
}

declaration()

std::shared_ptr< Stmt > Parser::declaration ( )

private

Definition at line 16 of file parser.cpp.

                                        {
  try {
    if (match(TokenType::VAR))
      return varDeclaration();
    return statement();
  } catch (ParseError &error) {
    synchronize();
    return nullptr; // Return null on error
  }
}

equality()

std::shared_ptr< Expr > Parser::equality ( )

private

Definition at line 177 of file parser.cpp.

                                     {
  std::shared_ptr<Expr> expr = comparison();
 
  while (match(TokenType::BANG_EQUAL, TokenType::EQUAL_EQUAL)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = comparison();
    expr = std::make_shared<Binary>(expr, std::move(operatorToken), right);
  }
 
  return expr;
}

error()

Parser::ParseError Parser::error ( const Token &  token, std::string_view  message  )

private

Definition at line 299 of file parser.cpp.

                                                                         {
  ::error(token, std::string(message));
  return ParseError("");
}

expression()

std::shared_ptr< Expr > Parser::expression ( )

private

Definition at line 175 of file parser.cpp.

{ return assignment(); }

expressionStatement()

std::shared_ptr< Stmt > Parser::expressionStatement ( )

private

Definition at line 116 of file parser.cpp.

                                                {
  std::shared_ptr<Expr> expr = expression();
  consume(TokenType::SEMICOLON, "Expect ';' after expression.");
  return std::make_shared<Expression>(expr);
}

factor()

std::shared_ptr< Expr > Parser::factor ( )

private

Definition at line 214 of file parser.cpp.

                                   {
  std::shared_ptr<Expr> expr = unary();
 
  while (match(TokenType::SLASH, TokenType::STAR)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = unary();
    expr = std::make_shared<Binary>(expr, std::move(operatorToken), right);
  }
 
  return expr;
}

forStatement()

std::shared_ptr< Stmt > Parser::forStatement ( )

private

Definition at line 69 of file parser.cpp.

                                         {
  consume(TokenType::LEFT_PAREN, "Expect '(' after 'for'.");
 
  std::shared_ptr<Stmt> initializer =
      match(TokenType::SEMICOLON)
          ? nullptr
          : (match(VAR) ? varDeclaration() : expressionStatement());
 
  std::shared_ptr<Expr> condition =
      check(TokenType::SEMICOLON) ? nullptr : expression();
  consume(SEMICOLON, "Expect ';' after loop condition.");
 
  std::shared_ptr<Expr> increment =
      check(TokenType::RIGHT_PAREN) ? nullptr : expression();
  consume(TokenType::RIGHT_PAREN, "Expect ')' after for parameters.");
 
  std::shared_ptr<Stmt> body = statement();
 
  // Desugaring for statement
  if (increment)
    body = std::make_shared<Block>(std::vector<std::shared_ptr<Stmt>>{
        body, std::make_shared<Expression>(increment)});
 
  if (condition == nullptr)
    condition = std::make_shared<Literal>(true);
 
  body = std::make_shared<While>(condition, body);
 
  if (initializer)
    body = std::make_shared<Block>(
        std::vector<std::shared_ptr<Stmt>>{initializer, body});
 
  return body;
}

ifStatement()

std::shared_ptr< Stmt > Parser::ifStatement ( )

private

Definition at line 48 of file parser.cpp.

                                        {
  consume(TokenType::LEFT_PAREN, "Expect '(' after 'if'.");
  std::shared_ptr<Expr> condition = expression();
  consume(TokenType::RIGHT_PAREN, "Expect ')' after if condition.");
 
  std::shared_ptr<Stmt> thenBranch = statement();
  std::shared_ptr<Stmt> elseBranch =
      match(TokenType::ELSE) ? statement() : nullptr;
 
  return std::make_shared<If>(condition, thenBranch, elseBranch);
}

isAtEnd()

bool Parser::isAtEnd ( ) const

private

Definition at line 275 of file parser.cpp.

                           {
  return peek().getType() == TokenType::END_OF_FILE;
}

match()

template<class... T>

bool Parser::match ( T...  types )

private

Definition at line 257 of file parser.cpp.

                                                   {
  assert((std::is_same_v<T, TokenType> && ...));
 
  for (TokenType type : {types...}) {
    if (check(type)) {
      advance();
      return true;
    }
  }
  return false;
}

orLogical()

std::shared_ptr< Expr > Parser::orLogical ( )

private

Definition at line 151 of file parser.cpp.

                                      {
  std::shared_ptr<Expr> expr = andLogical();
 
  while (match(TokenType::OR)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = andLogical();
    expr = std::make_shared<Logical>(expr, std::move(operatorToken), right);
  }
 
  return expr;
}

parse()

std::vector< std::shared_ptr< Stmt > > Parser::parse

(

)

Parses the tokens and returns a vector of statements.

This function processes the tokens and constructs an abstract syntax tree (AST) represented as a vector of statements.

Returns

std::vector<std::shared_ptr<Stmt>> A vector of shared pointers to the parsed statements.

Definition at line 7 of file parser.cpp.

                                             {
  std::vector<std::shared_ptr<Stmt>> statements;
  while (!isAtEnd()) {
    statements.push_back(declaration());
  }
 
  return statements;
}

peek()

Token Parser::peek ( ) const

private

Definition at line 292 of file parser.cpp.

{ return tokens[current]; }

previous()

Token Parser::previous ( ) const

private

Definition at line 294 of file parser.cpp.

                             {
  assert(current > 0);
  return tokens[current - 1];
}

primary()

std::shared_ptr< Expr > Parser::primary ( )

private

Definition at line 236 of file parser.cpp.

                                    {
  if (match(TokenType::NIL))
    return std::make_shared<Literal>(nullptr);
  else if (match(TokenType::TRUE))
    return std::make_shared<Literal>(true);
  else if (match(TokenType::FALSE))
    return std::make_shared<Literal>(false);
  else if (match(TokenType::NUMBER, TokenType::STRING)) {
    return std::make_shared<Literal>(previous().getLiteral());
  } else if (match(TokenType::IDENTIFIER)) {
    return std::make_shared<Variable>(previous());
  } else if (match(TokenType::LEFT_PAREN)) {
    std::shared_ptr<Expr> expr = expression();
    consume(TokenType::RIGHT_PAREN, "Expect ')' after expression.");
    return std::make_shared<Grouping>(std::move(expr));
  } else {
    std::string_view message = "Expect expression.";
    throw error(peek(), message);
  }
}

printStatement()

std::shared_ptr< Stmt > Parser::printStatement ( )

private

Definition at line 42 of file parser.cpp.

                                           {
  std::shared_ptr<Expr> value = expression();
  consume(TokenType::SEMICOLON, "Expect ';' after value.");
  return std::make_shared<Print>(value);
}

statement()

std::shared_ptr< Stmt > Parser::statement ( )

private

Definition at line 27 of file parser.cpp.

                                      {
  if (match(TokenType::PRINT))
    return printStatement();
  else if (match(TokenType::IF))
    return ifStatement();
  else if (match(TokenType::WHILE))
    return whileStatement();
  else if (match(TokenType::FOR))
    return forStatement();
  else if (match(TokenType::LEFT_BRACE))
    return std::make_shared<Block>(block());
  else
    return expressionStatement();
}

synchronize()

void Parser::synchronize ( )

private

Definition at line 304 of file parser.cpp.

                         {
  advance();
 
  while (!isAtEnd()) {
    if (previous().getType() == TokenType::SEMICOLON)
      return;
 
    switch (peek().getType()) {
    case TokenType::VAR:
    case TokenType::FOR:
    case TokenType::IF:
    case TokenType::WHILE:
    case TokenType::PRINT:
      return;
    default:
      break;
    }
 
    advance();
  }
}

term()

std::shared_ptr< Expr > Parser::term ( )

private

Definition at line 202 of file parser.cpp.

                                 {
  std::shared_ptr<Expr> expr = factor();
 
  while (match(TokenType::MINUS, TokenType::PLUS)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = factor();
    expr = std::make_shared<Binary>(expr, std::move(operatorToken), right);
  }
 
  return expr;
}

unary()

std::shared_ptr< Expr > Parser::unary ( )

private

Definition at line 226 of file parser.cpp.

                                  {
  if (match(TokenType::BANG, TokenType::MINUS)) {
    Token operatorToken = previous();
    std::shared_ptr<Expr> right = unary();
    return std::make_shared<Unary>(std::move(operatorToken), right);
  }
 
  return primary();
}

varDeclaration()

std::shared_ptr< Stmt > Parser::varDeclaration ( )

private

Definition at line 104 of file parser.cpp.

                                           {
  Token name = consume(TokenType::IDENTIFIER, "Expect variable name.");
  std::shared_ptr<Expr> initializer = nullptr;
 
  if (match(TokenType::EQUAL)) {
    initializer = expression();
  }
 
  consume(TokenType::SEMICOLON, "Expect ';' after variable declaration.");
  return std::make_shared<Var>(std::move(name), initializer);
}

whileStatement()

std::shared_ptr< Stmt > Parser::whileStatement ( )

private

Definition at line 60 of file parser.cpp.

                                           {
  consume(TokenType::LEFT_PAREN, "Expect '(' after 'while'.");
  std::shared_ptr<Expr> condition = expression();
  consume(TokenType::RIGHT_PAREN, "Expect ')' after while condition.");
 
  std::shared_ptr<Stmt> body = statement();
  return std::make_shared<While>(condition, body);
}

Member Data Documentation

current

int Parser::current = 0

private

Definition at line 32 of file parser.hpp.

tokens

const std::vector<Token>& Parser::tokens

private

Definition at line 31 of file parser.hpp.

---

The documentation for this class was generated from the following files:

• lib/gsc/parser.hpp
• src/parser.cpp