Today’s Little Program takes a string and tries to parse it as a 64-bit integer in formats that a programmer would likely encounter. <\/p>\n
Here’s a first stab: <\/p>\n
\nusing System;\nusing System.Globalization;\n\nclass Program\n{\n static long ParseLongSomehow(string s)\n {\n if (s.StartsWith(\"0x\", StringComparison.OrdinalIgnoreCase)) {\n return long.Parse(s.Substring(2), NumberStyles.HexNumber);\n } else {\n return long.Parse(s);\n }\n }\n\n public static void Main(string[] args)\n {\n long value = ParseLongSomehow(args[0]);\n Console.WriteLine(value);\n Console.WriteLine(\"0x{0:X}\", value);\n }\n}\n<\/pre>\nIf the string begins with 0x<\/code>, then we treat the rest of the argument as a hex value; otherwise, we treat it as a decimal value. <\/p>\nUnfortunately, this doesn’t work if the input is 9223372036854775808<\/code>, which is the value of 1 << 63<\/code>, a value that is representable as a 64-bit unsigned value but not a 64-bit signed value. <\/p>\nOur problem statement was pretty vague, so let’s write a functional specification<\/a>. It helps to know what problem you’re solving before you start to solve it. Otherwise, you’re just flailing around writing code before you have a plan<\/a>. When I tried to solve this problem, I flailed around a bit until I realized that I didn’t have a spec. <\/p>\nWhat formats would a programmer be likely to encounter as the string representation of a 64-bit integer? <\/p>\n
\n0x1234<\/code>: 64-bit number in hex format, case-insensitive. The value can range from 0 to UInt64.MaxValue<\/code>. \n12345<\/code>: 64-bit unsigned number in decimal format. The value can range from 0 to UInt64.MaxValue<\/code>. \n-12345<\/code>: 64-bit signed number in decimal format. The value can range from Int64.MinValue<\/code> to Int64.MaxValue<\/code>. \n- Other formats may be permitted, but you need to support at least the above. <\/ul>\n
Writing down exactly what I was doing and what I wasn’t doing was the part that solved my flailing. I had been worrying about things like -0x12345<\/code> and -9223372036854775809<\/code> and 9999999999999999999<\/code>, even though those numbers would not be something a programmer would be likely to encounter. <\/p>\nFrom the specification we can develop our algorithm. <\/p>\n
\n- If the string begins with
0x<\/code>, then parse what’s left as an unsigned 64-bit hexadecimal number. \n- If the string begins with a minus sign, then parse it as a 64-bit signed number in decimal format. \n
- If the string does not begin with a minus sign, then parse it as a 64-bit unsigned number in decimal format. <\/ul>\n
And that is pretty easy to implement. <\/p>\n
\n static long ParseLongSomehow(string s)\n {\n if (s.StartsWith(\"0x\", StringComparison.OrdinalIgnoreCase)) {\n return long.Parse(s.Substring(2), NumberStyles.HexNumber);\n } else if (s[0] == '-') {\n return long.Parse(s);\n } else {\n return (long)ulong.Parse(s);\n }\n }\n<\/pre>\nNote that we are a little sloppy with our treatment of whitespace. We accept leading and trailing spaces on decimal values, and allow trailing spaces on hex values (and even allow spaces between the 0x<\/code> and the first hex digit). That’s okay, because the spec allows us to accept formats beyond the ones listed. <\/p>\nNow, for bonus points, let’s revise the functional specification a little bit, specifically by adding another case: <\/p>\n
\n0x12`3456789A<\/code>: 64-bit number in hex format, case-insensitive, with backtick separating the upper 32 bits from the lower 32 bits. <\/ul>\nThis is the format used by the Windows debugger engine. <\/p>\n
\n static long ParseLongSomehow(string s)\n {\n if (s.StartsWith(\"0x\", StringComparison.OrdinalIgnoreCase)) {\n return long.Parse(s.Substring(2).Replace(\"`\", \"\")<\/font>, NumberStyles.HexNumber);\n } else if (s[0] == '-') {\n return long.Parse(s);\n } else {\n return (long)ulong.Parse(s);\n }\n }\n<\/pre>\nWe’ll leave it here for now. Next time, we’ll start putting some blocks together. <\/p>\n","protected":false},"excerpt":{"rendered":"
Signed or unsigned, I don’t care.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-45271","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Signed or unsigned, I don’t care.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/45271","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=45271"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/45271\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=45271"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=45271"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=45271"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}