ToString() reimplementation #1843

SandorDobos · 2021-02-28T15:37:31Z

Numeric ToString() related managed code parts moved from lib-CoreLibrary to native code in nf-interpreter.

Description

Logic in native code reimplemented.
Some deviances from official ToString() behaviour fixed, like rounding, digit count, e+x format, etc.
Related with ToString() reimplementation CoreLibrary#118.

Code changes impact in flash usage:
nanoCLR (MinSizeRel build): +1872 byte
mscorlib.pe (release build): -880 byte

Motivation and Context

Fixes Bug in formatting numbers into a string with D5 format Home#679 and various other formatting deviances not yet reported at all.

How Has This Been Tested?

      I create an nf project in VS and added the following class to it:

      public static class ToStringAsserts
      {
          public static void Run()
          {
              //AssertToConsole("(123.456).ToString(\"C\"))","",(123.456).ToString("C"));
              //AssertToConsole("(-123.456).ToString(\"C\"))","",(-123.456).ToString("C"));
              //AssertToConsole("(123.456).ToString(\"C3\"))","",(123.456).ToString("C3"));
              //AssertToConsole("(-123.456).ToString(\"C3\"))","",(-123.456).ToString("C3"));
              AssertToConsole("(1).ToString(\"Da1x\")", "Da1x", (1).ToString("Da1x"));
              AssertToConsole("(1).ToString(\"D\")", "1", (1).ToString("D"));
              AssertToConsole("(-1).ToString(\"D\")", "-1", (-1).ToString("D"));
              AssertToConsole("(1234).ToString(\"D\")", "1234", (1234).ToString("D"));
              AssertToConsole("(-1234).ToString(\"D\")", "-1234", (-1234).ToString("D"));
              AssertToConsole("(1234).ToString(\"D6\")", "001234", (1234).ToString("D6"));
              AssertToConsole("(-1234).ToString(\"D6\")", "-001234", (-1234).ToString("D6"));
              AssertToConsole("(Int32.MaxValue).ToString(\"D\")", "2147483647", (Int32.MaxValue).ToString("D"));
              AssertToConsole("(Int32.MinValue).ToString(\"D\")", "-2147483648", (Int32.MinValue).ToString("D"));
              AssertToConsole("(Int32.MaxValue).ToString(\"D21\")", "000000000002147483647",
      (Int32.MaxValue).ToString("D21")); AssertToConsole("(Int32.MinValue).ToString(\"D21\")",
      "-000000000002147483648", (Int32.MinValue).ToString("D21"));
              AssertToConsole("(Int64.MaxValue).ToString(\"D\")", "9223372036854775807",
      (Int64.MaxValue).ToString("D")); AssertToConsole("(Int64.MinValue).ToString(\"D\")", "-9223372036854775808",
      (Int64.MinValue).ToString("D")); AssertToConsole("(Int64.MaxValue).ToString(\"D21\")",
      "009223372036854775807", (Int64.MaxValue).ToString("D21"));
              AssertToConsole("(Int64.MinValue).ToString(\"D21\")", "-009223372036854775808",
      (Int64.MinValue).ToString("D21")); AssertToConsole("(Int32.MaxValue+100).ToString(\"D\")", "2147483747",
      ((Int64)Int32.MaxValue + 100).ToString("D")); AssertToConsole("(Int32.MinValue-100).ToString(\"D\")",
      "-2147483748", ((Int64)Int32.MinValue - 100).ToString("D"));
              AssertToConsole("(Int32.MaxValue+100).ToString(\"D21\")", "000000000002147483747",
      ((Int64)Int32.MaxValue + 100).ToString("D21")); AssertToConsole("(Int32.MinValue-100).ToString(\"D21\")",
      "-000000000002147483748", ((Int64)Int32.MinValue - 100).ToString("D21"));
              //AssertToConsole("(1052.0329112756).ToString(\"E\"))","",(1052.0329112756).ToString("E"));
              //AssertToConsole("(-1052.0329112756).ToString(\"E\"))","",(-1052.0329112756).ToString("E"));
              //AssertToConsole("(1052.0329112756).ToString(\"E2\"))","",(1052.0329112756).ToString("E2"));
              //AssertToConsole("(-1052.0329112756).ToString(\"E2\"))","",(-1052.0329112756).ToString("E2"));
              //AssertToConsole("(1052.0329112756).ToString(\"e\"))","",(1052.0329112756).ToString("e"));
              //AssertToConsole("(-1052.0329112756).ToString(\"e\"))","",(-1052.0329112756).ToString("e"));
              //AssertToConsole("(1052.0329112756).ToString(\"e2\"))","",(1052.0329112756).ToString("e2"));
              //AssertToConsole("(-1052.0329112756).ToString(\"e2\"))","",(-1052.0329112756).ToString("e2"));
              AssertToConsole("(1234.567).ToString(\"F\"))", "1234.57", (1234.567).ToString("F"));
              AssertToConsole("(-1234.567).ToString(\"F\"))", "-1234.57", (-1234.567).ToString("F"));
              AssertToConsole("(1234.567).ToString(\"F0\"))", "1235", (1234.567).ToString("F0"));
              AssertToConsole("(-1234.567).ToString(\"F0\"))", "-1235", (-1234.567).ToString("F0"));
              AssertToConsole("(1234).ToString(\"F1\"))", "1234.0", (1234).ToString("F1"));
              AssertToConsole("(-1234).ToString(\"F1\"))", "-1234.0", (-1234).ToString("F1"));
              AssertToConsole("(1234.56).ToString(\"F4\"))", "1234.5600", (1234.56).ToString("F4"));
              AssertToConsole("(-1234.56).ToString(\"F4\"))", "-1234.5600", (-1234.56).ToString("F4"));
              AssertToConsole("(1234.56).ToString(\"F1\"))", "1234.6", (1234.56).ToString("F1"));
              AssertToConsole("(-1234.56).ToString(\"F1\"))", "-1234.6", (-1234.56).ToString("F1"));
              AssertToConsole("(1234.0056).ToString(\"F1\"))", "1234.0", (1234.0056).ToString("F1"));
              AssertToConsole("(-1234.0056).ToString(\"F1\"))", "-1234.0", (-1234.0056).ToString("F1"));
              AssertToConsole("(1).ToString()", "1", (1).ToString());
              AssertToConsole("(1).ToString(null)", "1", (1).ToString((string)null));
              AssertToConsole("(1).ToString(String.Empty)", "1", (1).ToString(String.Empty));
              AssertToConsole("(1234.567).ToString())", "1234.567", (1234.567).ToString());
              AssertToConsole("(123.456).ToString(\"G\"))", "123.456", (123.456).ToString("G"));
              AssertToConsole("(-123.456).ToString(\"G\"))", "-123.456", (-123.456).ToString("G"));
              AssertToConsole("(123.4546).ToString(\"G2\"))", "1.2E+02", (123.4546).ToString("G2"));
              AssertToConsole("(-123.4546).ToString(\"G2\"))", "-1.2E+02", (-123.4546).ToString("G2"));
              AssertToConsole("(123.4546).ToString(\"G4\"))", "123.5", (123.4546).ToString("G4"));
              AssertToConsole("(-123.4546).ToString(\"G4\"))", "-123.5", (-123.4546).ToString("G4"));
              AssertToConsole("(123.4546).ToString(\"G10\"))", "123.4546", (123.4546).ToString("G10"));
              AssertToConsole("(-123.4546).ToString(\"G10\"))", "-123.4546", (-123.4546).ToString("G10"));
              AssertToConsole("(99.9999).ToString(\"G4\"))", "100", (99.9999).ToString("G4"));
              AssertToConsole("(-99.9999).ToString(\"G4\"))", "-100", (-99.9999).ToString("G4"));
              AssertToConsole("(1234567890).ToString(\"G\"))", "1234567890", (1234567890).ToString("G"));
              AssertToConsole("(-1234567890).ToString(\"G\"))", "-1234567890", (-1234567890).ToString("G"));
              AssertToConsole("(1234567890).ToString(\"G4\"))", "1.235E+09", (1234567890).ToString("G4"));
              AssertToConsole("(-1234567890).ToString(\"G4\"))", "-1.235E+09", (-1234567890).ToString("G4"));
              AssertToConsole("(9876543210).ToString(\"G4\"))", "9.877E+09", (9876543210).ToString("G4"));
              AssertToConsole("(-9876543210).ToString(\"G4\"))", "-9.877E+09", (-9876543210).ToString("G4"));
              AssertToConsole("(1234567890).ToString(\"G15\"))", "1234567890", (1234567890).ToString("G15"));
              AssertToConsole("(-1234567890).ToString(\"G15\"))", "-1234567890", (-1234567890).ToString("G15"));
              AssertToConsole("(1234.567).ToString(\"N\"))", "1,234.57", (1234.567).ToString("N"));
              AssertToConsole("(-1234.567).ToString(\"N\"))", "-1,234.57", (-1234.567).ToString("N"));
              AssertToConsole("(0).ToString(\"N0\"))", "0", (0).ToString("N0"));
              AssertToConsole("(1234).ToString(\"N0\"))", "1,234", (1234).ToString("N0"));
              AssertToConsole("(-1234).ToString(\"N0\"))", "-1,234", (-1234).ToString("N0"));
              AssertToConsole("(12).ToString(\"N1\"))", "12.0", (12).ToString("N1"));
              AssertToConsole("(-12).ToString(\"N1\"))", "-12.0", (-12).ToString("N1"));
              AssertToConsole("(1234).ToString(\"N1\"))", "1,234.0", (1234).ToString("N1"));
              AssertToConsole("(-1234).ToString(\"N1\"))", "-1,234.0", (-1234).ToString("N1"));
              AssertToConsole("(1234.56).ToString(\"N3\"))", "1,234.560", (1234.56).ToString("N3"));
              AssertToConsole("(-1234.56).ToString(\"N3\"))", "-1,234.560", (-1234.56).ToString("N3"));
              AssertToConsole("(34561234.56).ToString(\"N3\"))", "34,561,234.560", (34561234.56).ToString("N3"));
              AssertToConsole("(-34561234.56).ToString(\"N3\"))", "-34,561,234.560", (-34561234.56).ToString("N3"));
              //AssertToConsole("(1).ToString(\"P\"))","",(1).ToString("P"));
              //AssertToConsole("(-0.39678).ToString(\"P\"))","",(-0.39678).ToString("P"));
              //AssertToConsole("(123456789.12345678).ToString(\"R\"))","",(123456789.12345678).ToString("R"));
              //AssertToConsole("(-123456789.12345678).ToString(\"R\"))","",(-123456789.12345678).ToString("R"));
              AssertToConsole("(255).ToString(\"X\"))", "FF", (255).ToString("X"));
              AssertToConsole("((Int32)1).ToString(\"X\"))", "1", ((Int32)1).ToString("X"));
              AssertToConsole("((Int32)(-1)).ToString(\"x\"))", "ffffffff", ((Int32)(-1)).ToString("x"));
              AssertToConsole("((byte)1).ToString(\"x\"))", "1", (unchecked((byte)1)).ToString("x"));
              AssertToConsole("((byte)(-1)).ToString(\"x\"))", "ff", (unchecked((byte)(-1))).ToString("x"));
              AssertToConsole("((short)1).ToString(\"x\"))", "1", ((short)1).ToString("x"));
              AssertToConsole("((short)1).ToString(\"x2\"))", "01", ((short)1).ToString("x2"));
              AssertToConsole("((short)(-1)).ToString(\"x\"))", "ffff", ((short)(-1)).ToString("x"));
              AssertToConsole("(255).ToString(\"x4\"))", "00ff", (255).ToString("x4"));
              AssertToConsole("((Int32)(-1)).ToString(\"X4\"))", "FFFFFFFF", ((Int32)(-1)).ToString("X4"));
              AssertToConsole("(Int64.MaxValue-10).ToString(\"x\"))", "7ffffffffffffff5", (Int64.MaxValue -
      10).ToString("x")); AssertToConsole("((Int64)10).ToString(\"x\"))", "a", ((Int64)10).ToString("x"));
              AssertToConsole("((Int64)10).ToString(\"x5\"))", "0000a", ((Int64)10).ToString("x5"));
          }

          private static void AssertToConsole(string lbl, string expected, string str)
          {
              if (str != expected)
              {
                  Debug.WriteLine($"BAD: {lbl} expected: {expected} found: {str}");
              }
              else
              {
                  Debug.WriteLine($" OK: {lbl} expected: {expected}");
              }
          }
      }

      All expectations in assert lines above was captured during execution of the above under official .net runtime, see below.

      From the Main() call this class:
        ToStringAsserts.Run();

      I added a second old-school (running on "official" .net environment, like a Windows Console app) project to the
      solution. Added ToStringAsserts.cs as existing item via link to it. 
      Call from it's main() the test class as above. Execute this second project. You will see how the
      official implementation formats the various things. Adjust the "expected" strings to reflect the received
      output. E.g. if you want to check how we format (255).ToString("X") then add the following line:

        AssertToConsole("(255).ToString(\"X\"))", "dunnoyet", (255).ToString("X"));

      Execute the old-school project and you will see this line:
        BAD: (255).ToString("X")) expected: dunnoyet found: FF

      Now replace the "dunnoyet" with "FF" and the test case ready.
      Now execute the nf project and check what nanoCLR formats for you.
      Implement, fix, etc.
      But always check your test project results in OK on all lines!

Screenshots

Types of changes

Improvement (non-breaking change that improves a feature, code or algorithm)
Bug fix (non-breaking change which fixes an issue)
New feature (non-breaking change which adds functionality)
Breaking change (fix or feature that would cause existing functionality to change)
Config and build (change in the configuration and build system, has no impact on code or features)
Dependencies (update dependencies and changes associated, has no impact on code or features)

Checklist:

My code follows the code style of this project.
My change requires a change to the documentation.
I have updated the documentation accordingly.
I have read the CONTRIBUTING document.
I have added tests to cover my changes.
All new and existing tests passed.

sprintf isn't supported by nanoprintf, using snprintf instead everywhere.

Automated fixes for code style.

…8b6-d532-48ba-a4cb-e3c8449108e2 Code style fixes for nanoframework/nf-interpreter PR#1841

…614-b9c3-4de5-a376-4f3f25cf0cd9 Code style fixes for nanoframework/nf-interpreter PR#1841

…)) expected: 1.235E+09 found: 1235

precision value -1 means nothing set. common funcs extracted.

Legacy code removed.

Automated fixes for code style.

nfbot · 2021-02-28T15:40:10Z

@SandorDobos there are issues with the code style on the source files.
A PR was submitted with the code style fixes. Please review and merge the changes. See SandorDobos#3.

Make sure you are using the project code style. Check the details here.

…fe9-518b-4334-b98b-f07ab8c8a0c8 Code style fixes for nanoframework/nf-interpreter PR#1843

josesimoes

Great work on this!! Congrats and thankyou. 👍🏻 💯

src/CLR/CorLib/corlib_native.cpp

josesimoes · 2021-03-01T08:49:45Z

@SandorDobos if you could squash all the commits into a single one, that would be great.

…eter into issue-679

SandorDobos and others added 25 commits February 23, 2021 15:16

TinyPrintf replaced with nanoprintf.

32d5624

sprintf isn't supported by nanoprintf, using snprintf instead everywhere.

nanoprintf floats upgraded to double.

ed2b778

Merge branch 'develop' into develop

e1291c3

Code style fixes

683c7f5

Automated fixes for code style.

Code style fixes

852b2d8

Automated fixes for code style.

Merge pull request #1 from nanoframework/nfbot/clang-format-fix/2f8ef…

f1ecdd4

…8b6-d532-48ba-a4cb-e3c8449108e2 Code style fixes for nanoframework/nf-interpreter PR#1841

Merge pull request #2 from nanoframework/nfbot/clang-format-fix/bcea9…

1904d98

…614-b9c3-4de5-a376-4f3f25cf0cd9 Code style fixes for nanoframework/nf-interpreter PR#1841

Allow "ll" formats

6552871

New FormatNative: "X" implemented.

7cac6d9

New FormatNative: "D" implemented.

8292a19

"D" comment and small refactor

61c593d

refactor: nf_PrintfOnDataType

b8e5616

Fix rounding logic causing problem on 0 precision

62f01a5

New FormatNative: "G" implemented, except: (1234567890).ToString("G4"…

7251f92

…)) expected: 1.235E+09 found: 1235

Added 'E+exp' results to appropriate 'G' precisions

97ac9eb

Honor negativeSign param

5650bed

Honor DecimalSeparator.

3188959

precision value -1 means nothing set. common funcs extracted.

BUFFER_SIZE constants introduced

1f868b8

nf_GetPrintfLengthModifier extracted

2dc21ff

Fix rounding logic

f4be330

New FormatNative: "F" implemented

d380f5a

New FormatNative: "N" implemented

65d4bc0

Code structure: private class methods

2a17289

Legacy code removed.

Added a comment about testing method.

fc9850f

Merge remote-tracking branch 'upstream/develop' into issue-679

0518808

nfbot added Type: bug Type: enhancement Breaking-change labels Feb 28, 2021

Code style fixes

45c1fef

Automated fixes for code style.

SandorDobos mentioned this pull request Feb 28, 2021

ToString() reimplementation nanoframework/CoreLibrary#118

Merged

12 tasks

Merge pull request #3 from nanoframework/nfbot/clang-format-fix/52330…

c56fbb9

…fe9-518b-4334-b98b-f07ab8c8a0c8 Code style fixes for nanoframework/nf-interpreter PR#1843

josesimoes removed the Breaking-change label Mar 1, 2021

josesimoes reviewed Mar 1, 2021

View reviewed changes

josesimoes requested changes Mar 1, 2021

View reviewed changes

src/CLR/CorLib/corlib_native.cpp Show resolved Hide resolved

SandorDobos and others added 3 commits March 1, 2021 23:08

Added NoReflection parts too.

d7f555a

Merge branch 'issue-679' of https://github.com/SandorDobos/nf-interpr…

8161c6c

…eter into issue-679

Merge branch 'develop' into issue-679

4947fee

SandorDobos requested a review from josesimoes March 1, 2021 22:11

SandorDobos added 2 commits March 1, 2021 23:19

AssemblyNativeVersion bumped to 100.5.0.5

81816b2

Merge branch 'issue-679' of https://github.com/SandorDobos/nf-interpr…

e225c25

…eter into issue-679

josesimoes approved these changes Mar 2, 2021

View reviewed changes

josesimoes merged commit d5f01e7 into nanoframework:develop Mar 2, 2021

josesimoes added the Area: Common libs Everything related with common libraries label Mar 2, 2021

josesimoes added a commit that referenced this pull request Mar 16, 2021

ToString() reimplementation (#1843)

c9fcb42

josesimoes added a commit that referenced this pull request Mar 16, 2021

ToString() reimplementation (#1843)

b60a6d6

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

ToString() reimplementation #1843

ToString() reimplementation #1843

SandorDobos commented Feb 28, 2021 •

edited by josesimoes

Loading

nfbot commented Feb 28, 2021

josesimoes left a comment

josesimoes commented Mar 1, 2021

ToString() reimplementation #1843

ToString() reimplementation #1843

Conversation

SandorDobos commented Feb 28, 2021 • edited by josesimoes Loading

Description

Motivation and Context

How Has This Been Tested?

Screenshots

Types of changes

Checklist:

nfbot commented Feb 28, 2021

josesimoes left a comment

Choose a reason for hiding this comment

josesimoes commented Mar 1, 2021

SandorDobos commented Feb 28, 2021 •

edited by josesimoes

Loading