artichoke-lang/lib/src/Parser/Literals.cpp

//============================================================================//
//                                                                            //
//                       artichoke programming language                       //
//                                                                            //
//      Copyright (C) 2025 Erick Saul Guzman Ramos, whoami.artichoke.dev      //
//                                                                            //
//                                                                            //
//  This program is free software: you can redistribute it and/or modify      //
//  it under the terms of the GNU Affero General Public License as published  //
//  by the Free Software Foundation, either version 3 of the License, or      //
//  (at your option) any later version.                                       //
//                                                                            //
//  This program is distributed in the hope that it will be useful,           //
//  but WITHOUT ANY WARRANTY; without even the implied warranty of            //
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             //
//  GNU Affero General Public License for more details.                       //
//                                                                            //
//  You should have received a copy of the GNU Affero General Public License  //
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.    //
//                                                                            //
//============================================================================//

#include <artichoke/Parser/Parser.hpp>

namespace arti::lang {

  Expected<ast::CharLtrlNode>
  Parser::parseCharLiteral() {
    auto node = ast::MakeNode<ast::CharLtrlNode>();

    if (auto ltrl = consume(TokenV::tkCharacter, "character literal"); ! ltrl) {
      return Unexpected<>{ std::move(ltrl).error() };
    }
    else {
      node->location = {
        .line = ltrl->line,
        .column = ltrl->column
      };
      node->value = static_cast<uint8_t>(ltrl->strValue[1]);
    }

    return node;
	}

  Expected<ast::NullLtrlNode>
  Parser::parseNullLiteral() {
    auto node = ast::MakeNode<ast::NullLtrlNode>();

    if (auto ltrl = consume(TokenV::kwNull, "null keyword"); ! ltrl) {
      return Unexpected<>{ std::move(ltrl).error() };
    }
    else {
      node->location = {
        .line = ltrl->line,
        .column = ltrl->column
      };
    }

    return node;
	}

  Expected<ast::StringLtrlNode>
  Parser::parseStringLiteral() {
    auto node = ast::MakeNode<ast::StringLtrlNode>();

    if (auto ltrl = consume(TokenV::tkString, "string literal"); ! ltrl) {
      return Unexpected<>{ std::move(ltrl).error() };
    }
    else {
      node->location = {
        .line = ltrl->line,
        .column = ltrl->column
      };

      ltrl->strValue.remove_suffix(1);
      ltrl->strValue.remove_prefix(1);

      node->value = ltrl->strValue;
    }

    return node;
	}

  Expected<ast::FloatLtrlNode>
  Parser::parseFloatLiteral() {
    auto node = ast::MakeNode<ast::FloatLtrlNode>();

    if (auto ltrl = consume(TokenV::tkDecimal, "number literal"); ! ltrl) {
      return Unexpected<>{ std::move(ltrl).error() };
    }
    else {
      node->location = {
        .line = ltrl->line,
        .column = ltrl->column
      };
      /* TODO: This could throw? */
      std::string value{ ltrl->strValue };
      node->value = std::stold(value); 
    }

    return node;
	}

  Expected<ast::IntegerLtrlNode>
  Parser::parseIntegerLiteral() {
    auto node = ast::MakeNode<ast::IntegerLtrlNode>();

    if (auto ltrl = consume(TokenV::tkInteger, "integer literal"); ! ltrl) {
      return Unexpected<>{ std::move(ltrl).error() };
    }
    else {
      node->location = {
        .line = ltrl->line,
        .column = ltrl->column
      };
      /* TODO: This could throw? */
      std::string value{ ltrl->strValue };
      node->value = std::stoul(value);
    }

    return node;
	}

  Expected<ast::BooleanLtrlNode>
  Parser::parseBooleanLiteral() {
    auto node = ast::MakeNode<ast::BooleanLtrlNode>();

    auto peekToken = tokenizer.peek();

    if (! peekToken) {
      return Unexpected<>{ std::move(peekToken).error() };
    }

    node->location = {
      .line = peekToken->line,
      .column = peekToken->column
    };

    if (peekToken->value == TokenV::kwTrue) {
      node->value = true;
    }
    else if (peekToken->value == TokenV::kwFalse) {
      node->value = false;
    }
    else {
      return langException<ExceptCode::ecUnexpectedToken>(
        peekToken->line,
        peekToken->column,
        toString(*peekToken),
        "boolean literal, i.e. "
        "any of ( true, false )"
      );
    }

    std::ignore = tokenizer.consume();

    return node;
	}

  Expected<ast::IdentifierExprNode>
  Parser::parseIdentifierExpression() {
    auto node = ast::MakeNode<ast::IdentifierExprNode>();

    if (auto ltrl = consume(TokenV::tkIdentifier, "identifier"); ! ltrl) {
      return Unexpected<>{ std::move(ltrl).error() };
    }
    else {
      node->location = {
        .line = ltrl->line,
        .column = ltrl->column
      };
      node->identifierName = ltrl->strValue;
    }

    return node;
	}

} // namespace arti::lang