42_EXT_05_computorv1/src/lexer.c

#include "lexer.h"
#include "errors.h"
#include <stdbool.h>

static int skip_whitespace(const char *input, int input_pos)
{
    while (ft_isspace(input[input_pos]))
    {
        input_pos++;
    }
    return input_pos;
}

static bool token_is_variable(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == 'x' || input[input_pos] == 'X')
    {
        return false;
    }
    if (ft_isalpha(input[input_pos]))
    {
        *token_size = 1;
        return true;
    }
    return false;
}

static bool token_is_number(const char *input, int input_pos, int *token_size)
{
    int number_size;
    int max_number_size;
    int is_number;

    if (!ft_isnumber(input[input_pos]))
    {
        return false;
    }

    number_size = 1;
    max_number_size = 129; // max size for double double is 128 bits, + the coma
    while (number_size <= max_number_size)
    {
        if (ft_isnumber(input[input_pos + number_size]))
        {
            number_size++;
        }
        else if (input[input_pos] == '.')
        {
            number_size++;
        }
    }
    if (number_size > max_number_size)
    {
        stop_errors(ERROR_NUMBER_TOO_BIG);
    }
    *token_size = number_size;
    return true;
}

static bool token_is_plus(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == '+')
    {
        *token_size = 1;
        return true;
    }
    return false;
}

static bool token_is_plus(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == '+')
    {
        *token_size = 1;
        return true;
    }
    return false;
}

static bool token_is_plus(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == '+')
    {
        *token_size = 1;
        return true;
    }
    return false;
}

static bool token_is_plus(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == '+')
    {
        *token_size = 1;
        return true;
    }
    return false;
}

static bool token_is_plus(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == '+')
    {
        *token_size = 1;
        return true;
    }
    return false;
}

static bool token_is_plus(const char *input, int input_pos, int *token_size)
{
    if (input[input_pos] == '+')
    {
        *token_size = 1;
        return true;
    }
    return false;
}

int lexerize(const char *input, token tokens[MAX_TOKENS])
{
    int token_count;
    int input_pos;
    int token_size;

    token_count = 0;
    input_pos = 0;
    while (input[input_pos])
    {
        token_size = 0;
        input_pos = skip_whitespace(input, input_pos);

        if (input[input_pos] == '\0')
        {
            break;
        }

        if (token_is_variable(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_VARIABLE;
            tokens[token_count].var_value = 'x';
        }
        else if (token_is_number(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_NUMBER;
            tokens[token_count].num_value = ft_atoi(input[input_pos]);
        }
        else if (token_is_power(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_POWER;
            tokens[token_count].var_value = '^';
        }
        else if (token_is_plus(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_PLUS;
            tokens[token_count].var_value = '+';
        }
        else if (token_is_minus(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_MINUS;
            tokens[token_count].var_value = '-';
        }
        else if (token_is_multiplication(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_MULTIPLICATION;
            tokens[token_count].var_value = '*';
        }
        else if (token_is_division(input, input_pos, &token_size))
        {
            tokens[token_count].type = TOKEN_DIVISION;
            tokens[token_count].var_value = '/';
        }
        else
        {
            stop_errors(ERROR_UNKNOWN_TOKEN);
        }

        token_count++;
        if (token_size == 0)
        {
            stop_errors(ERROR_UNKNOWN_TOKEN);
        }
        input_pos += token_size;
    }

    tokens[token_count].type = TOKEN_END;
    tokens[token_count].var_value = '\0';

    return 1;
}