All unit tests are once again passing

molsonkiko · molsonkiko · commit 99b60f82219a · 2025-07-22T14:16:19.000-07:00
Some unit tests had to be removed, because they were only relevant when integers had bounded size.
I still haven't decided whether to merge this into main,
because parsing of integers is considerably slower than it was before.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -49,6 +49,12 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Since v7.0, holding down `Enter` in a multiline textbox (like the [tree viewer query box](/docs/README.md#remespath)) only adds one newline when the key is lifted.
 - Maybe use pre-7.1 (dictionary-based rather than indicator-based) [selection remembering](/docs/README.md#working-with-selections) for Notepad++ 8.5.5 and earlier? Indicators are risky with those older NPP's because of the lack of `NPPM_ALLOCATEINDICATOR`.
 
+## [9.0.0] - (UNRELEASED) YYYY-MM-DD
+
+### Changed
+
+1. Internally represent integers as BigIntegers instead of 64-bit integers, __meaning that JsonTools can correctly parse integers of unlimited size.__ 
+
 ## [8.4.0] - 2025-05-04
 
 ### Added
diff --git a/JsonToolsNppPlugin/Forms/TreeViewer.cs b/JsonToolsNppPlugin/Forms/TreeViewer.cs
@@ -1235,10 +1235,11 @@ public string KeyOfTreeNode(TreeNode node, KeyStyle style, char separator = JNod
         }
 
         /// <summary>
-        /// how long we think the UTF8-encoded representations of a list of JNodes is in regex mode.<br></br>
+        /// <paramref name="utf8Lengths"/> is populated with a list of how long we think the UTF8-encoded representations of a list of JNodes is in regex mode.<br></br>
         /// if delim is '\x00' (not in CSV mode) and nodes are all strings, these are just the lengths of their UTF8 reprs.<br></br>
         /// Otherwise, we do some special casing.<br></br>
-        /// returns true unless there was some error (e.g., probably b/c of nodes was a JObject or JArray)
+        /// Returns true unless there was some error (e.g., probably b/c of nodes was a JObject or JArray)<br></br>
+        /// If false was returned, the utf8Lengths array is useless.
         /// </summary>
         /// <param name="nodes">THESE MUST BE ORDERED BY POSITION ASCENDING</param>
         /// <param name="delim"></param>
@@ -1260,13 +1261,20 @@ public static bool LengthOfStringInRegexMode(JNode[] nodes, char delim, char quo
                     return false;
                 }
                 IComparable value = jnode.value;
+
+                bool isNum = value is double;
+                double d = isNum ? (double)value : 0;
+                if (value is BigInteger bi)
+                {
+                    isNum = true;
+                    d = (double)bi;
+                }
                 
-                if (value is BigInteger || value is double)
+                if (isNum)
                 {
                     // two equal numbers may have several valid representations
                     // we will try to find the length of the representation used in the document,
                     // but we will quit and use the JSON string length if our first attempt fails to find the length
-                    double d = (double)value;
                     int nodepos = jnode.position;
                     if (documentText is null)
                         documentText = selectionEnd < 0
diff --git a/JsonToolsNppPlugin/JSONTools/Dson.cs b/JsonToolsNppPlugin/JSONTools/Dson.cs
@@ -42,13 +42,13 @@ private static string FormatInteger(BigInteger val)
                 val = BigInteger.DivRem(val, 8, out BigInteger rem);
                 sb.Append((int)rem);
             }
-            int sblenM1 = sb.Length - 1;
+            int sblen = sb.Length;
             string s;
-            if (sblenM1 > 0)
+            if (sblen > 1)
             {
-                var chars = new char[sblenM1 + 1];
-                for (int ii = 0; ii <= sblenM1; ii--)
-                    chars[ii] = sb[sblenM1 - ii];
+                var chars = new char[sblen];
+                for (int ii = 0; ii < sblen; ii++)
+                    chars[ii] = sb[sblen - 1 - ii];
                 s = new string(chars);
             }
             else
diff --git a/JsonToolsNppPlugin/JSONTools/JNode.cs b/JsonToolsNppPlugin/JSONTools/JNode.cs
@@ -490,14 +490,18 @@ public bool TryGetValueAsBigInteger(out BigInteger bi)
         public bool TryGetValueAsInt32(out int i)
         {
             i = 0;
-            if (value is BigInteger bi && bi >= int.MinValue && bi <= int.MaxValue)
+            if (value is BigInteger bi && bi >= Int32MinValueAsBigInt && bi <= Int32MaxValueAsBigInt)
             {
                 i = (int)bi;
                 return true;
             }
             return false;
         }
 
+        public static readonly BigInteger Int32MaxValueAsBigInt = (BigInteger)int.MaxValue;
+
+        public static readonly BigInteger Int32MinValueAsBigInt = (BigInteger)int.MinValue;
+
         public static readonly BigInteger DoubleMaxValueAsBigInt = (BigInteger)double.MaxValue;
 
         public static readonly BigInteger DoubleMinValueAsBigInt = (BigInteger)double.MinValue;
diff --git a/JsonToolsNppPlugin/JSONTools/JsonTabularize.cs b/JsonToolsNppPlugin/JSONTools/JsonTabularize.cs
@@ -6,6 +6,7 @@ Uses an algorithm to flatten nested JSON.
 */
 using System;
 using System.Collections.Generic;
+using System.Numerics;
 using System.Text;
 
 namespace JSON_Tools.JSON_Tools
@@ -307,7 +308,7 @@ private void FindTabsInSchemaHelper(Dictionary<string, object> schema, List<obje
 				{
 					if (node is int && (int)node == 0)
 					{
-						patharr.children.Add(new JNode(0L, Dtype.INT, 0));
+						patharr.children.Add(new JNode(BigInteger.Zero, Dtype.INT, 0));
 					}
 					else
 					{
diff --git a/JsonToolsNppPlugin/JSONTools/RemesPathFunctions.cs b/JsonToolsNppPlugin/JSONTools/RemesPathFunctions.cs
@@ -233,6 +233,8 @@ public static JNode Mul(JNode a, JNode b)
             }
             if (!JNode.BothTypesIntersect(atype, btype, Dtype.NUM))
                 throw new RemesPathException($"Can't multiply objects of type {JNode.FormatDtype(atype)} and {JNode.FormatDtype(btype)}");
+            if (aval is BigInteger abi && bval is BigInteger bbi_)
+                return new JNode(abi * bbi_);
             return new JNode(JNode.ConvertJNodeValueToDouble(aval) * JNode.ConvertJNodeValueToDouble(bval));
         }
 
@@ -1202,9 +1204,9 @@ private static (JNode elt, char printStyle, bool sortKeys, int indent, char inde
             char printStyle = args[1].type == Dtype.NULL ? 'm' : ((string)args[1].value)[0];
             bool sortKeys = args[2].type == Dtype.NULL || (bool)args[2].value;
             JNode arg3 = args[3];
-            int indent = 4;
+            int indent = arg3.TryGetValueAsInt32(out int i) ? i : 4;
             char indentChar = ' ';
-            if (!arg3.TryGetValueAsInt32(out indent) && arg3.value is string s && s[0] is char c && c == '\t')
+            if (arg3.value is string s && s[0] is char c && c == '\t')
             {
                 indent = 1;
                 indentChar = c;
@@ -1601,7 +1603,7 @@ public static JNode MinBy(List<JNode> args)
             }
             else if (key is BigInteger kbi)
             {
-                int kint = (int)key;
+                int kint = (int)kbi;
                 for (int ii = 0; ii < itbl.Count; ii++)
                 {
                     var x = (JArray)itbl[ii];
@@ -1629,8 +1631,8 @@ public static JNode RandomFrom0To1(List<JNode> args)
         public static JNode RandomFromSchema(List<JNode> args)
         {
             JNode node = args[0];
-            int minArrayLength = args.Count >= 2 && args[1].value is BigInteger l && l < int.MaxValue && l >= 0 ? (int)l : 0;
-            int maxArrayLength = args.Count >= 3 && args[2].value is BigInteger l2 && l2 < int.MaxValue && l2 >= 0 ? (int)l2 : 10;
+            int minArrayLength = args.Count > 1 && args[1].TryGetValueAsInt32(out int minArrLen) ? minArrLen : 0;
+            int maxArrayLength = args.Count > 2 && args[2].TryGetValueAsInt32(out int maxArrLen) ? maxArrLen : 10;
             bool extendedAsciiStrings = args.Count >= 4 && args[3].value is bool b && b;
             bool usePatterns = args.Count >= 5 && args[4].value is bool b2 && b2;
             return RandomJsonFromSchema.RandomJson(node, minArrayLength, maxArrayLength, extendedAsciiStrings, usePatterns);
@@ -1694,49 +1696,53 @@ public static JNode LoopCount(List<JNode> args)
         /// </summary>
         public static JNode Range(List<JNode> args)
         {
-            var start = (BigInteger?)args[0].value;
-            var end = (BigInteger?)args[1].value;
-            var step = (BigInteger?)args[2].value;
-            var nums = new JArray();
-            if (start == null)
+            if (!args[0].TryGetValueAsBigInteger(out BigInteger start))
             {
                 throw new RemesPathException("First argument for 'range' function cannot be null.");
             }
+            var stepNode = args[2];
+            int step = stepNode.TryGetValueAsInt32(out int step_) ? step_ : -1;
             if (step == 0)
             {
                 throw new RemesPathException("Can't have a step size of 0 for the 'range' function");
             }
-            if (end == null && start > 0)
-            {
-                for (BigInteger ii = 0; ii < start; ii++)
-                {
-                    nums.children.Add(new JNode(ii, Dtype.INT, 0));
-                }
-            }
-            else if (step == null && start < end)
-            {
-                for (BigInteger ii = start.Value; ii < end; ii++)
-                {
-                    nums.children.Add(new JNode(ii, Dtype.INT, 0));
-                }
-            }
-            else
+            var nums = new JArray();
+            if (args[1].TryGetValueAsBigInteger(out BigInteger end))
             {
-                if (start > end && step < 0)
+                if (stepNode.type == Dtype.NULL)
                 {
-                    for (BigInteger ii = start.Value; ii > end; ii += step.Value)
+                    // step is unspecified, so default to step size 1
+                    for (BigInteger ii = start; ii < end; ii++)
                     {
                         nums.children.Add(new JNode(ii, Dtype.INT, 0));
                     }
                 }
-                else if (start < end && step > 0)
+                else
                 {
-                    for (BigInteger ii = start.Value; ii < end; ii += step.Value)
+                    if (start > end && step < 0)
                     {
-                        nums.children.Add(new JNode(ii, Dtype.INT, 0));
+                        for (BigInteger ii = start; ii > end; ii += step)
+                        {
+                            nums.children.Add(new JNode(ii, Dtype.INT, 0));
+                        }
+                    }
+                    else if (start < end && step > 0)
+                    {
+                        for (BigInteger ii = start; ii < end; ii += step)
+                        {
+                            nums.children.Add(new JNode(ii, Dtype.INT, 0));
+                        }
                     }
                 }
             }
+            else if (start > 0)
+            {
+                // end is unspecified, so just list all integers in range [0, start)
+                for (BigInteger ii = 0; ii < start; ii++)
+                {
+                    nums.children.Add(new JNode(ii, Dtype.INT, 0));
+                }
+            }
             return nums;
         }
 
@@ -3523,7 +3529,7 @@ public static JNode ToStr(List<JNode> args)
         /// <summary>
         /// float(x: anything) -> float<br></br>
         /// converts all numeric JNodes to an equal double.<br></br>
-        /// Converts all decimal string representations of floating point numbers to the corresponding double.
+        /// Converts all base 10 string representations of floating point numbers to the corresponding double.
         /// </summary>
         public static JNode ToFloat(List<JNode> args)
         {
diff --git a/JsonToolsNppPlugin/Tests/DsonTests.cs b/JsonToolsNppPlugin/Tests/DsonTests.cs
@@ -24,7 +24,7 @@ public static bool TestDump()
                 ("{\"aჿ\":[true,false,{\"c\": 3},\"оa\",[1, -2]], \"b\\\"\": \"z\", \"c\": {\"d\": 1.13}, \"d\": 50, \"e\": 0.76, \"f\": null}",
                     "such \"aჿ\" is so yes and no also such \"c\" is 3 wow and \"оa\" also so 1 and -2 many many, \"b\\\"\" is \"z\". " +
                     "\"c\" is such \"d\" is 1.15 wow! \"d\" is 62? \"e\" is 0.114, \"f\" is empty wow"),
-                ("[-9223372036854775808, 9223372036854775807]", "so 1000000000000000000000 and 777777777777777777777 many"),
+                ("[-9223372036854775808, 9223372036854775807]", "so -1000000000000000000000 and 777777777777777777777 many"),
             };
             int testsFailed = 0;
             int ii = 0;
diff --git a/JsonToolsNppPlugin/Tests/JsonGrepperTests.cs b/JsonToolsNppPlugin/Tests/JsonGrepperTests.cs
@@ -147,7 +147,7 @@ public static async Task<bool> TestApiRequester()
             int testsFailed = 0;
 
             string[] urls = new string[] {
-                "https://api.weather.gov",
+                "https://api.weather.gov/stations/KCCR",
                 "https://api.weather.gov/points/37.68333333333334,-121.92500000000001", // Alameda
                 "https://api.weather.gov/points/37.75833333333334,-122.43333333333334", // San Francisco
             };
@@ -156,7 +156,7 @@ public static async Task<bool> TestApiRequester()
             ii = testResult[0];
             testsFailed = testResult[1];
             // test when requesting from only one url
-            string[] firstUrl = new string[] { "https://api.weather.gov" };
+            string[] firstUrl = new string[] { "https://api.weather.gov/stations/KCCR" };
             testResult = await TestApiRequesterHelper(firstUrl, ii, testsFailed, grepper);
             ii = testResult[0];
             testsFailed = testResult[1];
diff --git a/JsonToolsNppPlugin/Tests/YamlDumperTests.cs b/JsonToolsNppPlugin/Tests/YamlDumperTests.cs
@@ -56,7 +56,7 @@ public static bool Test()
                 new string[] { "\"a \"", "\"a \"\n", "scalar string" },
                 new string[] { "9", "9\n", "scalar int" },
                 new string[] { "-940.3", "-940.3\n", "scalar float" },
-                new string[] { "[true, false]", "- True\n- False\n", "scalar bools" },
+                new string[] { "[true, false]", "- true\n- false\n", "scalar bools" },
                 new string[] { "[null, Infinity, -Infinity, NaN]", "- null\n- .inf\n- -.inf\n- .nan\n", "null, +/-infinity, NaN" },
                 // in the below case, there's actually a bit of an error;
                 // it is better to dump the float 2.0 as '2.0', but this algorithm dumps it
diff --git a/most recent errors.txt b/most recent errors.txt

Original file line number	Diff line number	Diff line change
`@@ -42,13 +42,13 @@ private static string FormatInteger(BigInteger val)`
`42`	`42`	`val = BigInteger.DivRem(val, 8, out BigInteger rem);`
`43`	`43`	`sb.Append((int)rem);`
`44`	`44`	`}`
`45`		`- int sblenM1 = sb.Length - 1;`
	`45`	`+ int sblen = sb.Length;`
`46`	`46`	`string s;`
`47`		`- if (sblenM1 > 0)`
	`47`	`+ if (sblen > 1)`
`48`	`48`	`{`
`49`		`- var chars = new char[sblenM1 + 1];`
`50`		`- for (int ii = 0; ii <= sblenM1; ii--)`
`51`		`- chars[ii] = sb[sblenM1 - ii];`
	`49`	`+ var chars = new char[sblen];`
	`50`	`+ for (int ii = 0; ii < sblen; ii++)`
	`51`	`+ chars[ii] = sb[sblen - 1 - ii];`
`52`	`52`	`s = new string(chars);`
`53`	`53`	`}`
`54`	`54`	`else`
Original file line number	Diff line number	Diff line change
`@@ -490,14 +490,18 @@ public bool TryGetValueAsBigInteger(out BigInteger bi)`
`490`	`490`	`public bool TryGetValueAsInt32(out int i)`
`491`	`491`	`{`
`492`	`492`	`i = 0;`
`493`		`- if (value is BigInteger bi && bi >= int.MinValue && bi <= int.MaxValue)`
	`493`	`+ if (value is BigInteger bi && bi >= Int32MinValueAsBigInt && bi <= Int32MaxValueAsBigInt)`
`494`	`494`	`{`
`495`	`495`	`i = (int)bi;`
`496`	`496`	`return true;`
`497`	`497`	`}`
`498`	`498`	`return false;`
`499`	`499`	`}`
`500`	`500`
	`501`	`+ public static readonly BigInteger Int32MaxValueAsBigInt = (BigInteger)int.MaxValue;`
	`502`	`+`
	`503`	`+ public static readonly BigInteger Int32MinValueAsBigInt = (BigInteger)int.MinValue;`
	`504`	`+`
`501`	`505`	`public static readonly BigInteger DoubleMaxValueAsBigInt = (BigInteger)double.MaxValue;`
`502`	`506`
`503`	`507`	`public static readonly BigInteger DoubleMinValueAsBigInt = (BigInteger)double.MinValue;`
Original file line number	Diff line number	Diff line change
`@@ -6,6 +6,7 @@ Uses an algorithm to flatten nested JSON.`
`6`	`6`	`*/`
`7`	`7`	`using System;`
`8`	`8`	`using System.Collections.Generic;`
	`9`	`+using System.Numerics;`
`9`	`10`	`using System.Text;`
`10`	`11`
`11`	`12`	`namespace JSON_Tools.JSON_Tools`
`@@ -307,7 +308,7 @@ private void FindTabsInSchemaHelper(Dictionary<string, object> schema, List<obje`
`307`	`308`	`{`
`308`	`309`	`if (node is int && (int)node == 0)`
`309`	`310`	`{`
`310`		`- patharr.children.Add(new JNode(0L, Dtype.INT, 0));`
	`311`	`+ patharr.children.Add(new JNode(BigInteger.Zero, Dtype.INT, 0));`
`311`	`312`	`}`
`312`	`313`	`else`
`313`	`314`	`{`
Original file line number	Diff line number	Diff line change
`@@ -233,6 +233,8 @@ public static JNode Mul(JNode a, JNode b)`
`233`	`233`	`}`
`234`	`234`	`if (!JNode.BothTypesIntersect(atype, btype, Dtype.NUM))`
`235`	`235`	`throw new RemesPathException($"Can't multiply objects of type {JNode.FormatDtype(atype)} and {JNode.FormatDtype(btype)}");`
	`236`	`+ if (aval is BigInteger abi && bval is BigInteger bbi_)`
	`237`	`+ return new JNode(abi * bbi_);`
`236`	`238`	`return new JNode(JNode.ConvertJNodeValueToDouble(aval) * JNode.ConvertJNodeValueToDouble(bval));`
`237`	`239`	`}`
`238`	`240`
`@@ -1202,9 +1204,9 @@ private static (JNode elt, char printStyle, bool sortKeys, int indent, char inde`
`1202`	`1204`	`char printStyle = args[1].type == Dtype.NULL ? 'm' : ((string)args[1].value)[0];`
`1203`	`1205`	`bool sortKeys = args[2].type == Dtype.NULL \|\| (bool)args[2].value;`
`1204`	`1206`	`JNode arg3 = args[3];`
`1205`		`- int indent = 4;`
	`1207`	`+ int indent = arg3.TryGetValueAsInt32(out int i) ? i : 4;`
`1206`	`1208`	`char indentChar = ' ';`
`1207`		`- if (!arg3.TryGetValueAsInt32(out indent) && arg3.value is string s && s[0] is char c && c == '\t')`
	`1209`	`+ if (arg3.value is string s && s[0] is char c && c == '\t')`
`1208`	`1210`	`{`
`1209`	`1211`	`indent = 1;`
`1210`	`1212`	`indentChar = c;`
`@@ -1601,7 +1603,7 @@ public static JNode MinBy(List<JNode> args)`
`1601`	`1603`	`}`
`1602`	`1604`	`else if (key is BigInteger kbi)`
`1603`	`1605`	`{`
`1604`		`- int kint = (int)key;`
	`1606`	`+ int kint = (int)kbi;`
`1605`	`1607`	`for (int ii = 0; ii < itbl.Count; ii++)`
`1606`	`1608`	`{`
`1607`	`1609`	`var x = (JArray)itbl[ii];`
`@@ -1629,8 +1631,8 @@ public static JNode RandomFrom0To1(List<JNode> args)`
`1629`	`1631`	`public static JNode RandomFromSchema(List<JNode> args)`
`1630`	`1632`	`{`
`1631`	`1633`	`JNode node = args[0];`
`1632`		`- int minArrayLength = args.Count >= 2 && args[1].value is BigInteger l && l < int.MaxValue && l >= 0 ? (int)l : 0;`
`1633`		`- int maxArrayLength = args.Count >= 3 && args[2].value is BigInteger l2 && l2 < int.MaxValue && l2 >= 0 ? (int)l2 : 10;`
	`1634`	`+ int minArrayLength = args.Count > 1 && args[1].TryGetValueAsInt32(out int minArrLen) ? minArrLen : 0;`
	`1635`	`+ int maxArrayLength = args.Count > 2 && args[2].TryGetValueAsInt32(out int maxArrLen) ? maxArrLen : 10;`
`1634`	`1636`	`bool extendedAsciiStrings = args.Count >= 4 && args[3].value is bool b && b;`
`1635`	`1637`	`bool usePatterns = args.Count >= 5 && args[4].value is bool b2 && b2;`
`1636`	`1638`	`return RandomJsonFromSchema.RandomJson(node, minArrayLength, maxArrayLength, extendedAsciiStrings, usePatterns);`
`@@ -1694,49 +1696,53 @@ public static JNode LoopCount(List<JNode> args)`
`1694`	`1696`	`/// </summary>`
`1695`	`1697`	`public static JNode Range(List<JNode> args)`
`1696`	`1698`	`{`
`1697`		`- var start = (BigInteger?)args[0].value;`
`1698`		`- var end = (BigInteger?)args[1].value;`
`1699`		`- var step = (BigInteger?)args[2].value;`
`1700`		`- var nums = new JArray();`
`1701`		`- if (start == null)`
	`1699`	`+ if (!args[0].TryGetValueAsBigInteger(out BigInteger start))`
`1702`	`1700`	`{`
`1703`	`1701`	`throw new RemesPathException("First argument for 'range' function cannot be null.");`
`1704`	`1702`	`}`
	`1703`	`+ var stepNode = args[2];`
	`1704`	`+ int step = stepNode.TryGetValueAsInt32(out int step_) ? step_ : -1;`
`1705`	`1705`	`if (step == 0)`
`1706`	`1706`	`{`
`1707`	`1707`	`throw new RemesPathException("Can't have a step size of 0 for the 'range' function");`
`1708`	`1708`	`}`
`1709`		`- if (end == null && start > 0)`
`1710`		`- {`
`1711`		`- for (BigInteger ii = 0; ii < start; ii++)`
`1712`		`- {`
`1713`		`- nums.children.Add(new JNode(ii, Dtype.INT, 0));`
`1714`		`- }`
`1715`		`- }`
`1716`		`- else if (step == null && start < end)`
`1717`		`- {`
`1718`		`- for (BigInteger ii = start.Value; ii < end; ii++)`
`1719`		`- {`
`1720`		`- nums.children.Add(new JNode(ii, Dtype.INT, 0));`
`1721`		`- }`
`1722`		`- }`
`1723`		`- else`
	`1709`	`+ var nums = new JArray();`
	`1710`	`+ if (args[1].TryGetValueAsBigInteger(out BigInteger end))`
`1724`	`1711`	`{`
`1725`		`- if (start > end && step < 0)`
	`1712`	`+ if (stepNode.type == Dtype.NULL)`
`1726`	`1713`	`{`
`1727`		`- for (BigInteger ii = start.Value; ii > end; ii += step.Value)`
	`1714`	`+ // step is unspecified, so default to step size 1`
	`1715`	`+ for (BigInteger ii = start; ii < end; ii++)`
`1728`	`1716`	`{`
`1729`	`1717`	`nums.children.Add(new JNode(ii, Dtype.INT, 0));`
`1730`	`1718`	`}`
`1731`	`1719`	`}`
`1732`		`- else if (start < end && step > 0)`
	`1720`	`+ else`
`1733`	`1721`	`{`
`1734`		`- for (BigInteger ii = start.Value; ii < end; ii += step.Value)`
	`1722`	`+ if (start > end && step < 0)`
`1735`	`1723`	`{`
`1736`		`- nums.children.Add(new JNode(ii, Dtype.INT, 0));`
	`1724`	`+ for (BigInteger ii = start; ii > end; ii += step)`
	`1725`	`+ {`
	`1726`	`+ nums.children.Add(new JNode(ii, Dtype.INT, 0));`
	`1727`	`+ }`
	`1728`	`+ }`
	`1729`	`+ else if (start < end && step > 0)`
	`1730`	`+ {`
	`1731`	`+ for (BigInteger ii = start; ii < end; ii += step)`
	`1732`	`+ {`
	`1733`	`+ nums.children.Add(new JNode(ii, Dtype.INT, 0));`
	`1734`	`+ }`
`1737`	`1735`	`}`
`1738`	`1736`	`}`
`1739`	`1737`	`}`
	`1738`	`+ else if (start > 0)`
	`1739`	`+ {`
	`1740`	`+ // end is unspecified, so just list all integers in range [0, start)`
	`1741`	`+ for (BigInteger ii = 0; ii < start; ii++)`
	`1742`	`+ {`
	`1743`	`+ nums.children.Add(new JNode(ii, Dtype.INT, 0));`
	`1744`	`+ }`
	`1745`	`+ }`
`1740`	`1746`	`return nums;`
`1741`	`1747`	`}`
`1742`	`1748`
`@@ -3523,7 +3529,7 @@ public static JNode ToStr(List<JNode> args)`
`3523`	`3529`	`/// <summary>`
`3524`	`3530`	`/// float(x: anything) -> float<br></br>`
`3525`	`3531`	`/// converts all numeric JNodes to an equal double.<br></br>`
`3526`		`- /// Converts all decimal string representations of floating point numbers to the corresponding double.`
	`3532`	`+ /// Converts all base 10 string representations of floating point numbers to the corresponding double.`
`3527`	`3533`	`/// </summary>`
`3528`	`3534`	`public static JNode ToFloat(List<JNode> args)`
`3529`	`3535`	`{`