Un-escaping characters

Is there anything in stdlib (?) to help format a string as a character?

For example, if I have a string like \' (say, const s = "\\'";), or \x30 (const s = "\\x30";), how would I convert such a string to a single u8 containing ASCII code of ' (in the first case), or ASCII code of 0 (in the second case)?

I’ve been tinkering with bufPrint, but can’t get it to do this. Perhaps it’s not the right tool for the job.

Any character you store in a u8 will be stored as a numerical value. The way you get the character back out is to print it from a string literal using the {s} specifier.

   const s = "\x30";
   std.debug.print("{d}\n", .{ s[0] }); // outputs 48
   std.debug.print("{s}\n", .{ s }); // outputs 0
   const i: u8 = s[0];
   std.debug.print("{d}\n", .{ i }); // outputs 48
   const t: u8 = '\x30';
   std.debug.print("{d}\n", .{ t }); // outputs 48

You would use bufprint to print the integer back into a slice to output it as the character itself

If what you’re asking is “how do I parse a string the same way the Zig compiler parses string literals”, check out the functions in the std.zig.string_literal namespace. I haven’t yet used any of them myself but parseCharLiteral seems to do exactly what you want with regard to individual characters.


Yes, this is precisely what I want.
Thank you, I will look into parseCharLiteral.

Update: parseCharLiteral does indeed work like that, but requires quite a few sanity checks before you can call it.

Otherwise you risk running into panic: reached unreachable code. For example, if your string, after the opening ' does not start with \, or a 0 byte, parseCharLiteral will just throw it at utf8Decode, which, as you can plainly see, doesn’t care much for strings longer than 4 bytes.

Also the functions called by utf8Decode, utf8Decode* - if the string you gave them is not valid UTF8… well, unreachable.

Anyway, here’s how I currently plan calling parseCharLiteral:

const std = @import("std");

pub fn main() !void
    const char_strings = [_][]const u8{ "'A'", "'\\''", "'hello'", "'\\x30'", "'⚡'", "'\\u{}'",
                                        "'abcd'", "'abc'", "'ab'", "'\\x31'", "abcde" };

    for (char_strings) |s|
        // Must ensure the preconditions are met before calling `parseCharLiteral`,
        // or get `panic: reached unreachable code`
        if (s.len < 3 or s[0] != '\'' or s[s.len - 1] != '\'' or s.len > 6
            or (s[1] != '\\' and s[1] != 0 and
                ((s.len == 6 and s[1] & 0b11111000 != 0b11110000) or
                 (s.len == 5 and s[1] & 0b11110000 != 0b11100000) or
                 (s.len == 4 and s[1] & 0b11100000 != 0b11000000))))
            std.debug.print("!!! {s} does not represent a character\n", .{ s });
        const p = std.zig.parseCharLiteral(s);
        switch (p)
            .success =>
                if (p.success > 255)
                    std.debug.print("Character value, {}, is greater than 255 (must use u21)\n", .{ p.success })
                    std.debug.print("Parsed character: {c}\n", .{ @as(u8, @intCast(p.success & 0x0000FF)) });
            .failure => std.debug.print("!!! Could not parse {s} as a character\n", .{ s })