Changeset 20c2ade

Timestamp:

Sep 11, 2024, 3:49:00 PM (2 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

5b95e67

Parents:

6325bd4

Message:

Parse string literals to get their length, taking into account escape sequences. Getting this from the lexer would avoid redundent work, but that is not set up. This corrects some typeof evaluations which lead to incorrect sizeof expressions.

File:

• src/Parser/ExpressionNode.cpp (modified) (2 diffs)

src/Parser/ExpressionNode.cpp

@@ -461 +461 @@
 } // build_constantChar
 
+static bool isoctal( char ch ) {
+        return ('0' <= ch && ch <= '7');
+}
+
+static bool ishexadecimal( char ch ) {
+        return (('0' <= ch && ch <= '9')
+                || ('a' <= ch && ch <= 'f')
+                || ('A' <= ch && ch <= 'F'));
+}
+
+// A "sequence" is the series of characters in a character/string literal
+// that becomes a single character value in the runtime value.
+static size_t sequenceLength( const std::string & str, size_t pos ) {
+        // Most "sequences" are just a single character, filter those out:
+        if ( '\\' != str[pos] ) return 1;
+        switch ( str[pos + 1] ) {
+        // Simple Escape Sequence (\_ where _ is one of the following):
+        case '\'': case '\"': case '?': case '\\':
+        case 'a': case 'b': case 'f': case 'n': case 'r': case 't': case 'v':
+        // GCC Escape Sequence (as simple, just some different letters):
+        case 'e':
+                return 2;
+        // Numeric Escape Sequence (\___ where _ is 1-3 octal digits):
+        case '0': case '1': case '2': case '3':
+        case '4': case '5': case '6': case '7':
+                return ( !isoctal( str[pos + 2] ) ) ? 2 :
+                       ( !isoctal( str[pos + 3] ) ) ? 3 : 4;
+        // Numeric Escape Sequence (\x_ where _ is 1 or more hexadecimal digits):
+        case 'x': {
+                size_t length = 2;
+                while ( ishexadecimal( str[pos + length] ) ) ++length;
+                return length;
+        }
+        // Uniersal Character Name (\u____ where _ is 4 decimal digits):
+        case 'u':
+                return 6;
+        // Uniersal Character Name (\U________ where _ is 8 decimal digits):
+        case 'U':
+                return 10;
+        default:
+                assertf( false, "Unknown escape sequence (start %c).", str[pos] );
+                return 1;
+        }
+}
+
 ast::Expr * build_constantStr(
                 const CodeLocation & location,
@@ -485 +530 @@
                 strtype = new ast::BasicType( ast::BasicKind::Char );
         } // switch
+
+        // The dimension value of the type is equal to the number of "sequences"
+        // not including the openning and closing quotes in the literal plus 1
+        // for the implicit null terminator.
+        size_t dimension = 1;
+        for ( size_t pos = 1 ; pos < str.size() - 1 ;
+                        pos += sequenceLength( str, pos ) ) {
+                dimension += 1;
+        }
+
         ast::ArrayType * at = new ast::ArrayType(
                 strtype,
-                // Length is adjusted: +1 for '\0' and -2 for '"'
-                ast::ConstantExpr::from_ulong( location, str.size() + 1 - 2 ),
+                ast::ConstantExpr::from_ulong( location, dimension ),
                 ast::FixedLen,
                 ast::DynamicDim );