lexer/number.cpp

   1 #include <fridh/lexer.hpp>
   2 #include <ail/string.hpp>
   3
   4 namespace fridh
   5 {
   6         bool lexer::parse_number(line_of_code & output)
   7         {
   8                 std::size_t start = i;
   9                 char byte = input[i];
  10
  11                 if(ail::is_digit(byte))
  12                 {
  13                         i++;
  14                         if(byte == '0')
  15                         {
  16                                 std::size_t remaining_bytes = end - i;
  17                                 if(remaining_bytes > 1)
  18                                 {
  19                                         char next_byte = input[i + 1];
  20                                         if(next_byte == 'x')
  21                                         {
  22                                                 i++;
  23                                                 remaining_bytes = end - i;
  24                                                 if(remaining_bytes == 0)
  25                                                         number_parsing_error("Incomplete hex number at the end of the input");
  26
  27                                                 std::size_t hex_start = i;
  28
  29                                                 for(; i < end && ail::is_hex_digit(input[i]); i++);
  30
  31                                                 std::size_t hex_length = i - hex_start;
  32                                                 if(hex_length == 0)
  33                                                         lexer_error("Incomplete hex number");
  34
  35                                                 std::string hex_string = input.substr(hex_start, i - end);
  36                                                 types::unsigned_integer value = ail::string_to_number<types::unsigned_integer>(hex_string, std::ios_base::hex);
  37                                                 output.lexemes.push_back(lexeme(value));
  38                                                 return true;
  39                                         }
  40                                 }
  41                         }
  42
  43                         char const dot = '.';
  44
  45                         bool got_dot = false;
  46                         char last_byte = byte;
  47                         for(; i < end; i++)
  48                         {
  49                                 byte = input[i];
  50                                 if(byte == dot)
  51                                 {
  52                                         if(got_dot)
  53                                                 number_parsing_error("Encountered a floating point value containing multiple dots");
  54                                         else
  55                                                 got_dot = true;
  56                                 }
  57                                 else if(!ail::is_digit(byte))
  58                                         break;
  59
  60                                 last_byte = byte;
  61                         }
  62
  63                         if(last_byte == dot)
  64                                 number_parsing_error("Encountered a floating point value ending with a dot");
  65
  66                         std::string number_string = input.substr(start, i - start);
  67                         lexeme current_lexeme;
  68                         if(got_dot)
  69                                 current_lexeme = lexeme(ail::string_to_number<types::floating_point_value>(number_string));
  70                         else
  71                                 current_lexeme = lexeme(ail::string_to_number<types::signed_integer>(number_string));
  72                         output.lexemes.push_back(current_lexeme);
  73
  74                         return true;
  75                 }
  76                 else
  77                         return false;
  78         }
  79 }