lexer/string.cpp

   1 #include <fridh/lexer.hpp>
   2 #include <ail/string.hpp>
   3
   4 namespace fridh
   5 {
   6         bool lexer::parse_string(line_of_code & output, std::string & error_message, std::string error_prefix)
   7         {
   8                 std::string string;
   9                 char string_character = input[i];
  10                 i++;
  11                 std::size_t start = i;
  12                 for(; i < end; i++)
  13                 {
  14                         char byte = input[i];
  15                         switch(byte)
  16                         {
  17                                 case '\\':
  18                                 {
  19                                         if(end - i < 2)
  20                                         {
  21                                                 error_message = lexer_error(error_prefix + "Backslash at the end of the input");
  22                                                 return false;
  23                                         }
  24
  25                                         i++;
  26
  27                                         char next_byte = input[i];
  28
  29                                         switch(next_byte)
  30                                         {
  31                                                 case 'r':
  32                                                         string.push_back('\r');
  33                                                         continue;
  34
  35                                                 case 'n':
  36                                                         string.push_back('\n');
  37                                                         continue;
  38                                         }
  39
  40                                         if(ail::is_hex_digit(next_byte))
  41                                         {
  42                                                 if(end - i < 2)
  43                                                 {
  44                                                         error_message = lexer_error(error_prefix + "Incomplete hex number escape sequence at the end of the input");
  45                                                         return false;
  46                                                 }
  47                                                 if(!ail::is_hex_digit(input[i + 1]))
  48                                                 {
  49                                                         error_message = lexer_error(error_prefix + "Invalid hex number escape sequence");
  50                                                         return false;
  51                                                 }
  52                                                 std::string hex_string = input.substr(i, 2);
  53                                                 i++;
  54                                                 char new_byte = ail::string_to_number<char>(hex_string, std::ios_base::hex);
  55                                                 string.push_back(new_byte);
  56                                         }
  57                                         else
  58                                         {
  59                                                 error_message = lexer_error(error_prefix + "Invalid escape sequence: " + ail::hex_string_8(static_cast<uchar>(next_byte)));
  60                                                 return false;
  61                                         }
  62                                         break;
  63                                 }
  64
  65                                 case '\n':
  66                                         error_message = lexer_error(error_prefix + "Detected a newline in a string");
  67                                         return false;
  68
  69                                 case '\'':
  70                                 case '"':
  71                                         if(byte == string_character)
  72                                         {
  73                                                 output.lexemes.push_back(lexeme(string, string));
  74                                                 i++;
  75                                                 return true;
  76                                         }
  77                                         string.push_back(byte);
  78                                         break;
  79
  80                                 default:
  81                                         string.push_back(byte);
  82                                         break;
  83                         }
  84                 }
  85                 error_message = lexer_error(error_prefix + "String lacks terminator");
  86                 return false;
  87         }
  88 }