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