Index: src/Parser/ExpressionNode.cpp
===================================================================
--- src/Parser/ExpressionNode.cpp	(revision c494b84f8d8be86bded8840569749f2bc29a8458)
+++ src/Parser/ExpressionNode.cpp	(revision 0bda8d707434c296565beb1edaff2d377450550c)
@@ -9,7 +9,7 @@
 // Author           : Peter A. Buhr
 // Created On       : Sat May 16 13:17:07 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Fri Aug 23 10:22:00 2024
-// Update Count     : 1088
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Thu Sep 12 22:40:35 2024
+// Update Count     : 1090
 //
 
@@ -381,6 +381,6 @@
 		const CodeLocation & location, string & str ) {
 	static const ast::BasicKind kind[2][12] = {
-		{ ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x },
-		{ ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex },
+		{ ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::Float80, ast::BasicKind::uuFloat128, ast::BasicKind::Float16, ast::BasicKind::Float32, ast::BasicKind::Float32x, ast::BasicKind::Float64, ast::BasicKind::Float64x, ast::BasicKind::Float128, ast::BasicKind::Float128x },
+		{ ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::NUMBER_OF_BASIC_TYPES, ast::BasicKind::Float16Complex, ast::BasicKind::Float32Complex, ast::BasicKind::Float32xComplex, ast::BasicKind::Float64Complex, ast::BasicKind::Float64xComplex, ast::BasicKind::Float128Complex, ast::BasicKind::Float128xComplex },
 	};
 
@@ -460,4 +460,43 @@
 	return ret;
 } // build_constantChar
+
+static bool isoctal( char ch ) {
+	return ('0' <= ch && ch <= '7');
+}
+
+// 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 ( isxdigit( str[pos + length] ) ) ++length;
+		  return length;
+	  }
+		// Universal Character Name (\u____ where _ is 4 decimal digits):
+	  case 'u':
+		return 6;
+		// Universal 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(
@@ -485,8 +524,17 @@
 		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 );
Index: src/Parser/StatementNode.cpp
===================================================================
--- src/Parser/StatementNode.cpp	(revision c494b84f8d8be86bded8840569749f2bc29a8458)
+++ src/Parser/StatementNode.cpp	(revision 0bda8d707434c296565beb1edaff2d377450550c)
@@ -11,6 +11,6 @@
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep  9 11:28:07 2024
-// Update Count     : 430
+// Last Modified On : Mon Sep  9 21:49:15 2024
+// Update Count     : 431
 //
 
@@ -184,5 +184,5 @@
 
 ast::Stmt * build_while( const CodeLocation & location, CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
-	std::vector<ast::ptr<ast::Stmt>> astinit;						// maybe empty
+	std::vector<ast::ptr<ast::Stmt>> astinit;			// maybe empty
 	ast::Expr * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
 
Index: src/Parser/TypeData.cpp
===================================================================
--- src/Parser/TypeData.cpp	(revision c494b84f8d8be86bded8840569749f2bc29a8458)
+++ src/Parser/TypeData.cpp	(revision 0bda8d707434c296565beb1edaff2d377450550c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb 23 08:58:30 2024
-// Update Count     : 734
+// Last Modified On : Thu Sep 12 22:43:59 2024
+// Update Count     : 735
 //
 
@@ -1158,16 +1158,16 @@
 	case TypeData::Double:
 	case TypeData::LongDouble:					// not set until below
-	case TypeData::uuFloat80:
+	case TypeData::Float80:
 	case TypeData::uuFloat128:
-	case TypeData::uFloat16:
-	case TypeData::uFloat32:
-	case TypeData::uFloat32x:
-	case TypeData::uFloat64:
-	case TypeData::uFloat64x:
-	case TypeData::uFloat128:
-	case TypeData::uFloat128x:
+	case TypeData::Float16:
+	case TypeData::Float32:
+	case TypeData::Float32x:
+	case TypeData::Float64:
+	case TypeData::Float64x:
+	case TypeData::Float128:
+	case TypeData::Float128x:
 		static ast::BasicKind floattype[2][12] = {
-			{ ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::uFloat16Complex, ast::BasicKind::uFloat32Complex, ast::BasicKind::uFloat32xComplex, ast::BasicKind::uFloat64Complex, ast::BasicKind::uFloat64xComplex, ast::BasicKind::uFloat128Complex, ast::BasicKind::uFloat128xComplex, },
-			{ ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::uuFloat80, ast::BasicKind::uuFloat128, ast::BasicKind::uFloat16, ast::BasicKind::uFloat32, ast::BasicKind::uFloat32x, ast::BasicKind::uFloat64, ast::BasicKind::uFloat64x, ast::BasicKind::uFloat128, ast::BasicKind::uFloat128x, },
+			{ ast::BasicKind::FloatComplex, ast::BasicKind::DoubleComplex, ast::BasicKind::LongDoubleComplex, (ast::BasicKind)-1, (ast::BasicKind)-1, ast::BasicKind::Float16Complex, ast::BasicKind::Float32Complex, ast::BasicKind::Float32xComplex, ast::BasicKind::Float64Complex, ast::BasicKind::Float64xComplex, ast::BasicKind::Float128Complex, ast::BasicKind::Float128xComplex, },
+			{ ast::BasicKind::Float, ast::BasicKind::Double, ast::BasicKind::LongDouble, ast::BasicKind::Float80, ast::BasicKind::uuFloat128, ast::BasicKind::Float16, ast::BasicKind::Float32, ast::BasicKind::Float32x, ast::BasicKind::Float64, ast::BasicKind::Float64x, ast::BasicKind::Float128, ast::BasicKind::Float128x, },
 		};
 
@@ -1185,5 +1185,5 @@
 			genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
 		} // if
-		if ( (td->basictype == TypeData::uuFloat80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
+		if ( (td->basictype == TypeData::Float80 || td->basictype == TypeData::uuFloat128) && td->complextype == TypeData::Complex ) { // gcc unsupported
 			genTSError( TypeData::complexTypeNames[ td->complextype ], td->basictype );
 		} // if
@@ -1205,4 +1205,7 @@
 		const_cast<TypeData *>(td)->basictype = TypeData::Int;
 		goto Integral;
+
+	  case TypeData::Float32x4: case TypeData::Float64x2: case TypeData::Svfloat32: case TypeData:: Svfloat64: case TypeData::Svbool:
+		return nullptr;
 	default:
 		assertf( false, "unknown basic type" );
@@ -1483,6 +1486,6 @@
 			ast::Expr * initValue;
 			if ( ret->isCfa && ret->base ) {
-				CodeLocation location = cur->enumeratorValue->location;
-				initValue = new ast::CastExpr( location, maybeMoveBuild( cur->consume_enumeratorValue() ), ret->base );
+				initValue = new ast::CastExpr( cur->enumeratorValue->location, maybeMoveBuild( cur->consume_enumeratorValue() ),
+											   ret->base );
 			} else {
 				initValue = maybeMoveBuild( cur->consume_enumeratorValue() );
Index: src/Parser/TypeData.hpp
===================================================================
--- src/Parser/TypeData.hpp	(revision c494b84f8d8be86bded8840569749f2bc29a8458)
+++ src/Parser/TypeData.hpp	(revision 0bda8d707434c296565beb1edaff2d377450550c)
@@ -10,6 +10,6 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb 22 16:30:31 2024
-// Update Count     : 210
+// Last Modified On : Fri Sep 13 08:13:01 2024
+// Update Count     : 216
 //
 
@@ -28,7 +28,8 @@
 	enum BasicType {
 		Void, Bool, Char, Int, Int128,
-		Float, Double, LongDouble, uuFloat80, uuFloat128,
-		uFloat16, uFloat32, uFloat32x, uFloat64, uFloat64x, uFloat128, uFloat128x,
-		NoBasicType
+		Float, Double, LongDouble, Float80, uuFloat128,
+		Float16, Float32, Float32x, Float64, Float64x, Float128, Float128x,
+		NoBasicType,
+		Float32x4, Float64x2, Svfloat32, Svfloat64, Svbool,
 	};
 	static const char * basicTypeNames[];
Index: src/Parser/lex.ll
===================================================================
--- src/Parser/lex.ll	(revision c494b84f8d8be86bded8840569749f2bc29a8458)
+++ src/Parser/lex.ll	(revision 0bda8d707434c296565beb1edaff2d377450550c)
@@ -10,6 +10,6 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Thu Jun 27 14:38:27 2024
- * Update Count     : 780
+ * Last Modified On : Wed Sep 11 17:16:23 2024
+ * Update Count     : 791
  */
 
@@ -234,4 +234,5 @@
 basetypeof		{ KEYWORD_RETURN(BASETYPEOF); }			// CFA
 _Bool			{ KEYWORD_RETURN(BOOL); }				// C99
+__SVBool_t		{ KEYWORD_RETURN(SVBOOL); }				// gcc (ARM)
 break			{ KEYWORD_RETURN(BREAK); }
 case			{ KEYWORD_RETURN(CASE); }
@@ -270,15 +271,19 @@
 fixup			{ QKEYWORD_RETURN(FIXUP); }				// CFA
 float			{ KEYWORD_RETURN(FLOAT); }
-__float80		{ KEYWORD_RETURN(uuFLOAT80); }			// GCC
-float80			{ KEYWORD_RETURN(uuFLOAT80); }			// GCC
+__float80		{ KEYWORD_RETURN(FLOAT80); }			// GCC
+float80			{ KEYWORD_RETURN(FLOAT80); }			// GCC
 __float128		{ KEYWORD_RETURN(uuFLOAT128); }			// GCC
 float128		{ KEYWORD_RETURN(uuFLOAT128); }			// GCC
-_Float16		{ FLOATXX(uFLOAT16); }					// GCC
-_Float32		{ FLOATXX(uFLOAT32); }					// GCC
-_Float32x		{ FLOATXX(uFLOAT32X); }					// GCC
-_Float64		{ FLOATXX(uFLOAT64); }					// GCC
-_Float64x		{ FLOATXX(uFLOAT64X); }					// GCC
-_Float128		{ FLOATXX(uFLOAT128); }					// GCC
-_Float128x		{ FLOATXX(uFLOAT128); }					// GCC
+_Float16		{ FLOATXX(FLOAT16); }					// GCC
+_Float32		{ FLOATXX(FLOAT32); }					// GCC
+_Float32x		{ FLOATXX(FLOAT32X); }					// GCC
+_Float64		{ FLOATXX(FLOAT64); }					// GCC
+_Float64x		{ FLOATXX(FLOAT64X); }					// GCC
+_Float128		{ FLOATXX(FLOAT128); }					// GCC
+_Float128x		{ FLOATXX(FLOAT128X); }					// GCC
+__Float32x4_t	{ FLOATXX(FLOAT32X4); }					// GCC (ARM)
+__Float64x2_t	{ FLOATXX(FLOAT64X2); }					// GCC (ARM)
+__SVFloat32_t	{ FLOATXX(SVFLOAT32); }					// GCC (ARM)
+__SVFloat64_t	{ FLOATXX(SVFLOAT64); }					// GCC (ARM)
 for				{ KEYWORD_RETURN(FOR); }
 forall			{ KEYWORD_RETURN(FORALL); }				// CFA
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision c494b84f8d8be86bded8840569749f2bc29a8458)
+++ src/Parser/parser.yy	(revision 0bda8d707434c296565beb1edaff2d377450550c)
@@ -10,6 +10,6 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Aug 13 11:25:16 2024
-// Update Count     : 6740
+// Last Modified On : Thu Sep 12 22:48:32 2024
+// Update Count     : 6741
 //
 
@@ -366,6 +366,7 @@
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY							// C99
-%token INT128 UINT128 uuFLOAT80 uuFLOAT128				// GCC
-%token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
+%token INT128 UINT128 FLOAT80 uuFLOAT128				// GCC
+%token FLOAT16 FLOAT32 FLOAT32X FLOAT64 FLOAT64X FLOAT128 FLOAT128X // GCC
+%token FLOAT32X4 FLOAT64X2 SVFLOAT32 SVFLOAT64 SVBOOL	// GCC (ARM)
 %token DECIMAL32 DECIMAL64 DECIMAL128					// GCC
 %token ZERO_T ONE_T										// CFA
@@ -2364,20 +2365,32 @@
 	| DOUBLE
 		{ $$ = build_basic_type( TypeData::Double ); }
-	| uuFLOAT80
-		{ $$ = build_basic_type( TypeData::uuFloat80 ); }
+	| FLOAT80
+		{ $$ = build_basic_type( TypeData::Float80 ); }
 	| uuFLOAT128
 		{ $$ = build_basic_type( TypeData::uuFloat128 ); }
-	| uFLOAT16
-		{ $$ = build_basic_type( TypeData::uFloat16 ); }
-	| uFLOAT32
-		{ $$ = build_basic_type( TypeData::uFloat32 ); }
-	| uFLOAT32X
-		{ $$ = build_basic_type( TypeData::uFloat32x ); }
-	| uFLOAT64
-		{ $$ = build_basic_type( TypeData::uFloat64 ); }
-	| uFLOAT64X
-		{ $$ = build_basic_type( TypeData::uFloat64x ); }
-	| uFLOAT128
-		{ $$ = build_basic_type( TypeData::uFloat128 ); }
+	| FLOAT16
+		{ $$ = build_basic_type( TypeData::Float16 ); }
+	| FLOAT32
+		{ $$ = build_basic_type( TypeData::Float32 ); }
+	| FLOAT32X
+		{ $$ = build_basic_type( TypeData::Float32x ); }
+	| FLOAT64
+		{ $$ = build_basic_type( TypeData::Float64 ); }
+	| FLOAT64X
+		{ $$ = build_basic_type( TypeData::Float64x ); }
+	| FLOAT128
+		{ $$ = build_basic_type( TypeData::Float128 ); }
+	| FLOAT128X
+		{ $$ = build_basic_type( TypeData::Float128x ); }
+	| FLOAT32X4
+		{ $$ = build_basic_type( TypeData::Float32x4 ); }
+	| FLOAT64X2
+		{ $$ = build_basic_type( TypeData::Float64x2 ); }
+	| SVFLOAT32
+		{ $$ = build_basic_type( TypeData::Svfloat32 ); }
+	| SVFLOAT64
+		{ $$ = build_basic_type( TypeData::Svfloat64 ); }
+	| SVBOOL
+		{ $$ = build_basic_type( TypeData::Svbool ); }
 	| DECIMAL32
 		{ SemanticError( yylloc, "_Decimal32 is currently unimplemented." ); $$ = nullptr; }
