Commit 1ed8c54cd349497adb264b0502783a6422e4f2d1 | zig

author	Evan Haas <evan@lagerdata.com> 2021-01-26 09:08:05-08:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-01-26 21:13:06-08:00
log	1ed8c54cd349497adb264b0502783a6422e4f2d1
tree	813be35e4f0e0745451c97474970322acdc79e40
parent	79730e6f5cdf13b2514781881e69c557fd52eaea

translate-c: add wide string literal support

Adds support for wide, UTF-16, and UTF-32 string literals. If used to initialize
an incomplete array, the same logic as narrow strings is used. Otherwise they
are translated as global "anonymous" arrays of the relevant underlying char type.
A dot is used in the name to ensure the generated names do not conflict with any
other names in the translated program.

For example:

```c
void my_fn() {
    const uint32_t *foo = U"foo";
}
```

becomes:
```zig
const @"zig.UTF32_string_2" = [4]c_uint{
    '\u{66}',
    '\u{6f}',
    '\u{6f}',
    0,
};
pub export fn my_fn() void {
    var foo: [*c]const u32 = &@"zig.UTF32_string_2";
}
```

2 files changed, 65 insertions(+), 15 deletions(-)

src
- translate_c.zig
test
- run_translated_c.zig

src/translate_c.zig+41-15

 @@ -780,7 +780,7 @@ fn visitVarDecl(c: *Context, var_decl: *const clang.VarDecl, mangled_name: ?[]co
         eq_tok = try appendToken(c, .Equal, "=");
         if (decl_init) |expr| {
             const node_or_error = if (expr.getStmtClass() == .StringLiteralClass)
-                transStringLiteralAsArray(rp, &c.global_scope.base, @ptrCast(*const clang.StringLiteral, expr), type_node)
+                transStringLiteralAsArray(rp, &c.global_scope.base, @ptrCast(*const clang.StringLiteral, expr), zigArraySize(rp.c, type_node) catch 0)
             else
                 transExprCoercing(rp, scope, expr, .used, .r_value);
             init_node = node_or_error catch |err| switch (err) {
 @@ -1662,7 +1662,7 @@ fn transDeclStmtOne(
             const eq_token = try appendToken(c, .Equal, "=");
             var init_node = if (decl_init) |expr|
                 if (expr.getStmtClass() == .StringLiteralClass)
-                    try transStringLiteralAsArray(rp, scope, @ptrCast(*const clang.StringLiteral, expr), type_node)
+                    try transStringLiteralAsArray(rp, scope, @ptrCast(*const clang.StringLiteral, expr), try zigArraySize(rp.c, type_node))
                 else
                     try transExprCoercing(rp, scope, expr, .used, .r_value)
             else
 @@ -2059,16 +2059,41 @@ fn transStringLiteral(
             };
             return maybeSuppressResult(rp, scope, result_used, &node.base);
         },
-        .UTF16, .UTF32, .Wide => return revertAndWarn(
+        .UTF16, .UTF32, .Wide => {
-            rp,
+            const node = try transWideStringLiteral(rp, scope, stmt);
-            error.UnsupportedTranslation,
+            return maybeSuppressResult(rp, scope, result_used, node);
-            @ptrCast(*const clang.Stmt, stmt).getBeginLoc(),
+        },
-            "TODO: support string literal kind {s}",
-            .{kind},
-        ),
     }
 }
+/// Translates a wide string literal as a global "anonymous" array of the relevant-sized
+/// integer type + null terminator, and returns an identifier node for it
+fn transWideStringLiteral(rp: RestorePoint, scope: *Scope, stmt: *const clang.StringLiteral) TransError!*ast.Node {
+    const str_type = @tagName(stmt.getKind());
+    const mangle = rp.c.getMangle();
+    const name = try std.fmt.allocPrint(rp.c.arena, "zig.{s}_string_{d}", .{ str_type, mangle });
+    const const_tok = try appendToken(rp.c, .Keyword_const, "const");
+    const name_tok = try appendIdentifier(rp.c, name);
+    const eq_tok = try appendToken(rp.c, .Equal, "=");
+    var semi_tok: ast.TokenIndex = undefined;
+    const lit_array = try transStringLiteralAsArray(rp, scope, stmt, stmt.getLength() + 1);
+    semi_tok = try appendToken(rp.c, .Semicolon, ";");
+    const var_decl_node = try ast.Node.VarDecl.create(rp.c.arena, .{
+        .name_token = name_tok,
+        .mut_token = const_tok,
+        .semicolon_token = semi_tok,
+    }, .{
+        .visib_token = null,
+        .eq_token = eq_tok,
+        .init_node = lit_array,
+    });
+    try addTopLevelDecl(rp.c, name, &var_decl_node.base);
+    return transCreateNodeIdentifier(rp.c, name);
+}
 /// Parse the size of an array back out from an ast Node.
 fn zigArraySize(c: *Context, node: *ast.Node) TransError!usize {
     if (node.castTag(.ArrayType)) |array| {
 @@ -2081,17 +2106,18 @@ fn zigArraySize(c: *Context, node: *ast.Node) TransError!usize {
 }
 /// Translate a string literal to an array of integers. Used when an
-/// array is initialized from a string literal. `target_node` is the
+/// array is initialized from a string literal. `array_size` is the
-/// array being initialized. If the string literal is larger than the
+/// size of the array being initialized. If the string literal is larger
-/// array, truncate the string. If the array is larger than the string
+/// than the array, truncate the string. If the array is larger than the
-/// literal, pad the array with 0's
+/// string literal, pad the array with 0's
 fn transStringLiteralAsArray(
     rp: RestorePoint,
     scope: *Scope,
     stmt: *const clang.StringLiteral,
-    target_node: *ast.Node,
+    array_size: usize,
 ) TransError!*ast.Node {
-    const array_size = try zigArraySize(rp.c, target_node);
+    if (array_size == 0) return error.UnsupportedType;
     const str_length = stmt.getLength();
     const expr_base = @ptrCast(*const clang.Expr, stmt);

test/run_translated_c.zig+24

...	@@ -794,4 +794,28 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {	...	@@ -794,4 +794,28 @@ pub fn addCases(cases: *tests.RunTranslatedCContext) void {
794	\\ return 0;	794	\\ return 0;
795	\\}	795	\\}
796	, "");	796	, "");
		797
		798	cases.add("Wide, UTF-16, and UTF-32 string literals",
		799	\\#include <stdlib.h>
		800	\\#include <stdint.h>
		801	\\#include <wchar.h>
		802	\\int main(void) {
		803	\\ const wchar_t *wide_str = L"wide";
		804	\\ const wchar_t wide_hello[] = L"hello";
		805	\\ if (wcslen(wide_str) != 4) abort();
		806	\\ if (wcslen(L"literal") != 7) abort();
		807	\\ if (wcscmp(wide_hello, L"hello") != 0) abort();
		808	\\
		809	\\ const uint16_t *u16_str = u"wide";
		810	\\ const uint16_t u16_hello[] = u"hello";
		811	\\ if (u16_str[3] != u'e' \|\| u16_str[4] != 0) abort();
		812	\\ if (u16_hello[4] != u'o' \|\| u16_hello[5] != 0) abort();
		813	\\
		814	\\ const uint32_t *u32_str = U"wide";
		815	\\ const uint32_t u32_hello[] = U"hello";
		816	\\ if (u32_str[3] != U'e' \|\| u32_str[4] != 0) abort();
		817	\\ if (u32_hello[4] != U'o' \|\| u32_hello[5] != 0) abort();
		818	\\ return 0;
		819	\\}
		820	, "");
797	}	821	}