converting a number to a string, formatted like with "print using"

[madscijr]

Quick question (though I am not under the illusion there may be a quick answer! lol).

If you have a numberic variable (Integer, Long, etc.), how might you convert it to a string like with

Code: QB64: [Select]

1. MyString$ = _Trim$(Str$(MyNumber))

except formatted like wtih

Code: QB64: [Select]

1. Print Using "###,###,###,###,###,###"; MyNumber

Is there a command for this, or do you just have to write a function to do it?
Example / attempt below. I defined a custom function to format the number.
(Actually, I had to define 3 separate functions for Integer, Long, and _Integer64. So a bonus question: is there a way to do that all with one function?)

Help me, Obi Wan!

Code: QB64: [Select]

1. ' Question 1: Is there an alternative to Print Using?
2.  
3. Dim MyInteger%
4. Dim MyLong&
5. Dim My_Integer64&&
6.  
7. 'Screen _NewImage(1024, 768, 32): _ScreenMove 0, 0
8. Cls
9.  
10. Print "Attempt to format integer:"
11. MyInteger% = 32767
12. Print "MyInteger%=" + _Trim$(Str$(MyInteger%))
13. Print "FormatInteger$(" + _Trim$(Str$(MyInteger%)) + ") returns " + Chr$(34) + FormatInteger$(MyInteger%) + Chr$(34)
14. Print Using "MyInteger with PrintUsing: ###,###,###,###,###,###"; MyInteger%
15. Print
16. Print "PRESS ANY KEY TO CONTINUE": Sleep
17.  
18. MyLong& = 2147483647
19. Print "MyLong&=" + _Trim$(Str$(MyLong&))
20. Print "FormatLong$(" + _Trim$(Str$(MyLong&)) + ") returns " + Chr$(34) + FormatLong$(MyLong&) + Chr$(34)
21. Print Using "MyLong with PrintUsing: ###,###,###,###,###,###"; MyLong&
22. Print
23. Print "PRESS ANY KEY TO CONTINUE": Sleep
24.  
25. My_Integer64&& = 9223372036854775807
26. Print "My_Integer64&&=" + _Trim$(Str$(My_Integer64&&))
27. Print "Format_Integer64$(" + _Trim$(Str$(My_Integer64&&)) + ") returns " + Chr$(34) + Format_Integer64$(My_Integer64&&) + Chr$(34)
28. Print Using "My_Integer64 with PrintUsing: ###,###,###,###,###,###,###"; My_Integer64&&
29. Print
30. Print "PRESS ANY KEY TO CONTINUE": Sleep
31.  
32. 'Screen 0
33. End
34.  
35. ' Question 2 (BONUS): Is there a way to define just one function that receives
36. '                     a variant (like in VB6/VBA) so you don't have to define
37. '                     seperate nearly identical functions for each type?
38.  
39. Function FormatInteger$ (MyValue%)
40.     Dim StringValue$: StringValue$ = ""
41.     Dim TempString$: TempString$ = _Trim$(Str$(MyValue%))
42.     Dim iLoop As Long
43.     Dim iCount As Integer: iCount = 0
44.     'Print "TempString$=" + TempString$
45.     For iLoop = Len(TempString$) To 1 Step -1
46.         iCount = iCount + 1: If iCount > 3 Then StringValue$ = "," + StringValue$: iCount = 1 ': Print "added comma: " + StringValue$
47.         StringValue$ = Mid$(TempString$, iLoop, 1) + StringValue$ ': Print "next value: " + StringValue$
48.     Next iLoop
49.     FormatInteger$ = StringValue$
50. End Function ' FormatInteger$
51.  
52. Function FormatLong$ (MyValue&)
53.     Dim StringValue$: StringValue$ = ""
54.     Dim TempString$: TempString$ = _Trim$(Str$(MyValue&))
55.     Dim iLoop As Long
56.     Dim iCount As Integer: iCount = 0
57.     'Print "TempString$=" + TempString$
58.     For iLoop = Len(TempString$) To 1 Step -1
59.         iCount = iCount + 1: If iCount > 3 Then StringValue$ = "," + StringValue$: iCount = 1 ': Print "added comma: " + StringValue$
60.         StringValue$ = Mid$(TempString$, iLoop, 1) + StringValue$ ': Print "next value: " + StringValue$
61.     Next iLoop
62.     FormatLong$ = StringValue$
63. End Function ' FormatLong$
64.  
65. Function Format_Integer64$ (MyValue&&)
66.     Dim StringValue$: StringValue$ = ""
67.     Dim TempString$: TempString$ = _Trim$(Str$(MyValue&&))
68.     Dim iLoop As Long
69.     Dim iCount As Integer: iCount = 0
70.     'Print "TempString$=" + TempString$
71.     For iLoop = Len(TempString$) To 1 Step -1
72.         iCount = iCount + 1: If iCount > 3 Then StringValue$ = "," + StringValue$: iCount = 1 ': Print "added comma: " + StringValue$
73.         StringValue$ = Mid$(TempString$, iLoop, 1) + StringValue$ ': Print "next value: " + StringValue$
74.     Next iLoop
75.     Format_Integer64$ = StringValue$
76. End Function ' Format_Integer64$
77.  

[RhoSigma]

Anwer to question 1: yes

Code: QB64: [Select]

1. 'number as is
2. PRINT IndexFormat$("MyInteger% = 0{R}", STR$(32767), "~")
3. 'number with thousands separator ,
4. PRINT IndexFormat$("MyInteger% = 0{#####,}", STR$(32767), "~")
5. 'number with thousands separator flipped to .
6. PRINT IndexFormat$("MyInteger% = 0{?,:#####,}", STR$(32767), "~")
7. 'number as grouped Hex/Oct/Bin
8. PRINT IndexFormat$("MyInteger% = 0{?2:H8}", STR$(32767), "~")
9. PRINT IndexFormat$("MyInteger% = 0{?4:O8}", STR$(32767), "~")
10. PRINT IndexFormat$("MyInteger% = 0{?4:B16}", STR$(32767), "~")
11. END
12.  
13. 'insert FUNCTION IndexFormat$ here, get it from:
14. 'https://qb64forum.alephc.xyz/index.php?topic=2932.msg121898#msg121898
15. '(7z inclusive example and docs)
16.  
17.  

Answer to question 2: not familiar with VB6/VBA, sorry

[madscijr]

Anwer to question 1: yes
...
Answer to question 2: not familiar with VB6/VBA, sorry

Thanks for your reply.

Re: question 2
Point is, other than the input parameters, the 3 functions in my example are identical. So, instead of having to make a separate function for every parameter type, is there a way to just make _one_ general purpose function, where the parameter can be _any_ type? In VBA there is a type called Variant which means it can hold any type you put in it (and in JavaScript and Python, there are no type declarations, ALL variables are "variants", which I think is insane, but that's another discussion). In those languages, you can just declare one function, where the input is of type Variant, meaning it can receive any type, and then inside the function, if need be, you can type check and handle the input differently (or not). Kabish?

Anyway, thank you for your reply and explaining how to set a string variable formatted like Print Using does.

[RhoSigma]

Ah, so you talk about function overloading. Not possible in QB64 as is, but look on IndexFormat$, it's a function which needs to handle several different arguments/types too, it takes all the different parameters in the argument string, all added together, strings as is, numbers via STR$(). Then, inside the functions you need to parse that whole argument string to get what you need.

Another way would be a user defined type:

Code: QB64: [Select]

1. Type aNumber
2.     typ AS STRING * 3
3.     n8 AS _BYTE
4.     n16 AS INTEGER
5.     n32 AS LONG
6.     n64 AS _INTEGER64
7.     ns AS SINGLE
8.     nd AS DOUBLE
9.     nf AS _FLOAT
10. END TYPE
11.  
12. DIM num AS aNumber
13. num.typ = "n16"
14. num.n16 = 32767
15. res = DoSomthingWithNumber(num)
16.  
17. FUNCTION DoSomthingWithNumber (x AS aNumber)
18. SELECT CASE _TRIM$(x.typ)
19.     CASE "n8"
20.         'do _BYTE stuff here
21.     CASE "n16"
22.         'do INTEGER stuff here
23.     CASE "n32"
24.         'do LONG stuff here
25.     CASE "n64"
26.         'do _INTEGER64 stuff here
27.     CASE "ns"
28.         'do SINGLE stuff here
29.     CASE "nd"
30.         'do DOUBLE stuff here
31.     CASE "nf"
32.         'do _FLOAT stuff here
33. END SELECT
34. END FUNCTION
35.  
36.  

As you can see, there are multiple ways to build universal functions, but unfortunately no such easy thing like a 'variants" type. Somewhere you have to go in and do your own coding.

Guess @SMcNeill could also show you a variant doing this with _MEM variables. He made a universal QuickSort function somewhere here in the forum, using _MEM variables to determine the array type which is to be sorted in his function.

EDIT:
here's the _MEM sort, maybe you can derive something useful for your needs...
https://qb64forum.alephc.xyz/index.php?topic=1601.0

[madscijr]

Ah, so you talk about function overloading. Not possible in QB64 as is, but look on IndexFormat$, it's a function which needs to handle several different arguments/types too,
...
Guess @SMcNeill could also show you a variant doing this with _MEM variables. He made a universal QuickSort function somewhere here in the forum, using _MEM variables to determine the array type which is to be sorted in his function.
EDIT:
here's the _MEM sort, maybe you can derive something useful for your needs...
https://qb64forum.alephc.xyz/index.php?topic=1601.0

Good to know - thanks!
I guess the convenience of only having one function has to be weighed against the performance hit of unpacking/converting the input into the needed type, type checking, etc.
I will definitely play with your examples, thanks again.

[bplus]

Seems like Double parameter can handle various Types:

Code: QB64: [Select]

1. Dim i%
2. i% = 100000 * Rnd - 50000
3. Print commaD$(i%, 2)
4. j& = 10000000 * Rnd - 5000000
5. Print commaD$(j&, 2)
6. k## = 100000 * Rnd - 50000
7. Print commaD$(k##, 4)
8.  
9. Function commaD$ (n#, nDecPlaces%) 'only works right for double# type
10.     Dim place As Long, s$, front$, back$, func$
11.     func$ = _Trim$(Str$(n#))
12.     If Left$(func$, 1) = "-" Then s$ = "-": func$ = Mid$(func$, 2) Else s$ = ""
13.     place = InStr(func$, ".")
14.     If place = 0 Then place = Len(func$) + 1
15.     While place > 4
16.         func$ = Mid$(func$, 1, place - 4) + "," + Mid$(func$, place - 3)
17.         place = InStr(func$, ",")
18.     Wend
19.     'fix to nDecPlaces
20.     place = InStr(func$, ".")
21.     If nDecPlaces% Then
22.         If place Then
23.             front$ = Mid$(func$, 1, place)
24.             back$ = Mid$(func$, place + 1)
25.             If Len(back$) > nDecPlaces% Then func$ = front$ + Left$(back$, nDecPlaces%)
26.             If Len(back$) < nDecPlaces% Then func$ = front$ + Left$(back$ + String$(nDecPlaces%, "0"), nDecPlaces%)
27.         Else
28.             func$ = func$ + "." + String$(nDecPlaces%, "0")
29.         End If
30.     Else
31.         If place Then func$ = Mid$(func$, 1, place - 1)
32.     End If
33.     commaD$ = s$ + func$
34. End Function
35.  
36.  

[SMcNeill]

Try something like this:

Code: QB64: [Select]

1. Print "FOO: "; format$("###.###", "123.456789")
2. Print format$("###,.##", "123456789.987654321")
3.  
4.  
5. Function format$ (template As String, text As String)
6.     d = _Dest: s = _Source
7.     n = _NewImage(80, 80, 0)
8.     _Dest n: _Source n
9.     Print Using template; Val(text)
10.     For i = 1 To 79
11.         t$ = t$ + Chr$(Screen(1, i))
12.     Next
13.     If Left$(t$, 1) = "%" Then t$ = Mid$(t$, 2)
14.     format$ = _Trim$(t$)
15.     _Dest d: _Source s
16.     _FreeImage n
17. End Function

Pass it the same format string you'd use with PRINT USING, and then the STR$ value of your number.  It'll return a string formatted just as PRINT USING would do.

[bplus]

Try something like this:

Code: QB64: [Select]

1. Print "FOO: "; format$("###.###", "123.456789")
2. Print format$("###,.##", "123456789.987654321")
3.  
4.  
5. Function format$ (template As String, text As String)
6.     d = _Dest: s = _Source
7.     n = _NewImage(80, 80, 0)
8.     _Dest n: _Source n
9.     Print Using template; Val(text)
10.     For i = 1 To 79
11.         t$ = t$ + Chr$(Screen(1, i))
12.     Next
13.     If Left$(t$, 1) = "%" Then t$ = Mid$(t$, 2)
14.     format$ = _Trim$(t$)
15.     _Dest d: _Source s
16.     _FreeImage n
17. End Function

Pass it the same format string you'd use with PRINT USING, and then the STR$ value of your number.  It'll return a string formatted just as PRINT USING would do.

Oh! that looks like it gets around the Type problem.
 n = _NewImage(80, 80, 0)
0 the one mode you can read characters from, a point for Pete ;-))

[Juanjogomez]

Try something like this:

Code: QB64: [Select]

1. Print "FOO: "; format$("###.###", "123.456789")
2. Print format$("###,.##", "123456789.987654321")
3.  
4.  
5. Function format$ (template As String, text As String)
6.     d = _Dest: s = _Source
7.     n = _NewImage(80, 80, 0)
8.     _Dest n: _Source n
9.     Print Using template; Val(text)
10.     For i = 1 To 79
11.         t$ = t$ + Chr$(Screen(1, i))
12.     Next
13.     If Left$(t$, 1) = "%" Then t$ = Mid$(t$, 2)
14.     format$ = _Trim$(t$)
15.     _Dest d: _Source s
16.     _FreeImage n
17. End Function

Pass it the same format string you'd use with PRINT USING, and then the STR$ value of your number.  It'll return a string formatted just as PRINT USING would do.

Very original, simple and effective

[madscijr]

Thanks everyone for your replies. I have been away on spring break, so have some catching up to do. I will gove
this all a look and try out the various examples as soon as I can get to it. Thanks again!

[madscijr]

I played around with the examples, so far so good but I have run out of time for today.
Here is everything in one handy dandy test program...

Code: QB64: [Select]

1. ' Formatting numbers (alternatives to Print using)
2. ' https://qb64forum.alephc.xyz/index.php?topic=4703.msg141127#msg141127
3.  
4. ' BOOLEAN VALUES
5. Const FALSE = 0
6. Const TRUE = Not FALSE
7.  
8. ' Used by RhoSigma's operator overloading workaround example:
9. Type aNumber
10.     typ As String * 3
11.     n8 As _Byte
12.     n16 As Integer
13.     n32 As Long
14.     n64 As _Integer64
15.     ns As Single
16.     nd As Double
17.     nf As _Float
18. End Type ' aNumber
19.  
20. ' Global variables
21. Dim Shared m_ProgramPath$: m_ProgramPath$ = Left$(Command$(0), _InStrRev(Command$(0), "\"))
22. Dim Shared m_ProgramName$: m_ProgramName$ = Mid$(Command$(0), _InStrRev(Command$(0), "\") + 1)
23.  
24. ' Start main menu
25. main
26.  
27. ' Exit program
28. 'Screen 0
29. End
30.  
31. ' /////////////////////////////////////////////////////////////////////////////
32.  
33. Sub main
34.     Dim RoutineName As String: RoutineName = "main"
35.     Dim in$
36.     Dim bFinished As Integer: bFinished = FALSE
37.     Dim result$: result$ = ""
38.     Do
39.         Screen 0: _ScreenMove 0, 0
40.         Cls
41.         Print m_ProgramName$
42.         Print
43.         Print "converting a number to a string, formatted like with 'print using'"
44.         Print
45.  
46.         Print "1) Format Numbers Manually (parse string, insert commas)"
47.         Print "2) IndexFormat$ by RhoSigma example #1"
48.         Print "3) IndexFormat$ by RhoSigma example #2"
49.         Print "4) commaD$ by bplus"
50.         Print "5) format$ by SMcNeill"
51.         Print
52.         Print "Q) Exit program"
53.  
54.         Do
55.             in$ = InKey$
56.             If UCase$(in$) = "Q" Then
57.                 bFinished = TRUE: Exit Do
58.             ElseIf UCase$(in$) = "1" Then
59.                 FormatNumbersManually: Exit Do
60.             ElseIf UCase$(in$) = "2" Then
61.                 IndexFormatTest1: Exit Do
62.             ElseIf UCase$(in$) = "3" Then
63.                 IndexFormatTest2: Exit Do
64.             ElseIf UCase$(in$) = "4" Then
65.                 commaD_Test: Exit Do
66.             ElseIf UCase$(in$) = "5" Then
67.                 FormatStringTest: Exit Do
68.             End If
69.         Loop
70.     Loop Until bFinished = TRUE
71. End Sub ' main
72.  
73. ' /////////////////////////////////////////////////////////////////////////////
74. ' Question 1: Is there an alternative to Print Using?
75.  
76. ' Answer 1: Format numbers the manual way!
77.  
78. Sub FormatNumbersManually
79.     Dim MyInteger%
80.     Dim MyLong&
81.     Dim My_Integer64&&
82.  
83.     'Screen _NewImage(1024, 768, 32): _ScreenMove 0, 0
84.     'Cls
85.  
86.     Print "-------------------------------------------------------------------------------"
87.     Print "Format numbers (add commas) by manually parsing the string:"
88.     Print
89.  
90.     Print "Attempt to format integer:"
91.     MyInteger% = 32767
92.     Print "MyInteger%=" + _Trim$(Str$(MyInteger%))
93.     Print "FormatInteger$(" + _Trim$(Str$(MyInteger%)) + ") returns " + Chr$(34) + FormatInteger$(MyInteger%) + Chr$(34)
94.     Print Using "MyInteger with PrintUsing: ###,###,###,###,###,###"; MyInteger%
95.     Print
96.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
97.  
98.     MyLong& = 2147483647
99.     Print "MyLong&=" + _Trim$(Str$(MyLong&))
100.     Print "FormatLong$(" + _Trim$(Str$(MyLong&)) + ") returns " + Chr$(34) + FormatLong$(MyLong&) + Chr$(34)
101.     Print Using "MyLong with PrintUsing: ###,###,###,###,###,###"; MyLong&
102.     Print
103.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
104.  
105.     My_Integer64&& = 9223372036854775807
106.     Print "My_Integer64&&=" + _Trim$(Str$(My_Integer64&&))
107.     Print "Format_Integer64$(" + _Trim$(Str$(My_Integer64&&)) + ") returns " + Chr$(34) + Format_Integer64$(My_Integer64&&) + Chr$(34)
108.     Print Using "My_Integer64 with PrintUsing: ###,###,###,###,###,###,###"; My_Integer64&&
109.     Print
110.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
111.  
112.     Print "-------------------------------------------------------------------------------"
113. End Sub ' FormatNumbersManually
114.  
115. ' Question 2 (BONUS): Is there a way to define just one function that receives
116. '                     a variant (like in VB6/VBA) so you don't have to define
117. '                     seperate nearly identical functions for each type?
118.  
119. Function FormatInteger$ (MyValue%)
120.     Dim StringValue$: StringValue$ = ""
121.     Dim TempString$: TempString$ = _Trim$(Str$(MyValue%))
122.     Dim iLoop As Long
123.     Dim iCount As Integer: iCount = 0
124.     'Print "TempString$=" + TempString$
125.     For iLoop = Len(TempString$) To 1 Step -1
126.         iCount = iCount + 1: If iCount > 3 Then StringValue$ = "," + StringValue$: iCount = 1 ': Print "added comma: " + StringValue$
127.         StringValue$ = Mid$(TempString$, iLoop, 1) + StringValue$ ': Print "next value: " + StringValue$
128.     Next iLoop
129.     FormatInteger$ = StringValue$
130. End Function ' FormatInteger$
131.  
132. Function FormatLong$ (MyValue&)
133.     Dim StringValue$: StringValue$ = ""
134.     Dim TempString$: TempString$ = _Trim$(Str$(MyValue&))
135.     Dim iLoop As Long
136.     Dim iCount As Integer: iCount = 0
137.     'Print "TempString$=" + TempString$
138.     For iLoop = Len(TempString$) To 1 Step -1
139.         iCount = iCount + 1: If iCount > 3 Then StringValue$ = "," + StringValue$: iCount = 1 ': Print "added comma: " + StringValue$
140.         StringValue$ = Mid$(TempString$, iLoop, 1) + StringValue$ ': Print "next value: " + StringValue$
141.     Next iLoop
142.     FormatLong$ = StringValue$
143. End Function ' FormatLong$
144.  
145. Function Format_Integer64$ (MyValue&&)
146.     Dim StringValue$: StringValue$ = ""
147.     Dim TempString$: TempString$ = _Trim$(Str$(MyValue&&))
148.     Dim iLoop As Long
149.     Dim iCount As Integer: iCount = 0
150.     'Print "TempString$=" + TempString$
151.     For iLoop = Len(TempString$) To 1 Step -1
152.         iCount = iCount + 1: If iCount > 3 Then StringValue$ = "," + StringValue$: iCount = 1 ': Print "added comma: " + StringValue$
153.         StringValue$ = Mid$(TempString$, iLoop, 1) + StringValue$ ': Print "next value: " + StringValue$
154.     Next iLoop
155.     Format_Integer64$ = StringValue$
156. End Function ' Format_Integer64$
157.  
158. ' /////////////////////////////////////////////////////////////////////////////
159. ' Format$ function with indexed & reusable arguments by RhoSigma
160. ' https://qb64forum.alephc.xyz/index.php?topic=2932.msg121898#msg121898
161.  
162. ' As the title says,
163. ' this is a Format$ function (PRINT USING style), which allows for explicit
164. ' argument indexing in the given format template. The indexing feature lets
165. ' you change the template being processed while keeping the arguments stream
166. ' the same.
167.  
168. ' This can be an invaluable tool in some situations, just think about
169. ' different date formats. With PRINT USING alone you would probably need to
170. ' reorder your day, month, year, weekday etc. arguments for every date format
171. ' to match the order of the respective format tokens in the template, but not
172. ' so with this function. Another example is when it comes to localizing your
173. ' programs, where it helps when translating template strings to different
174. ' languages and the sentence structure and thus the order of the arguments
175. ' changes.
176.  
177. ' Beside the indexing, which this function got its name from, it has a couple
178. ' other useful extensions compared to the regular PRINT USING conventions,
179. ' such as bin/hex/oct formatting, use of escape sequences to insert control
180. ' or extended ASCII chars and more. All of this is detailed in the
181. ' comprehensive HTML Documentation available for download below the example
182. ' code block.
183.  
184. ' As it is required to preserve the UTF-8 encoding of the HTML Documentation
185. ' and some preformatted examples, it is packed into an 7-zip archive file
186. ' attached below. The archive does also contain the example from the codebox
187. ' above.
188.  
189. '--- Full description available in separate HTML document.
190.  
191. ' My Projects:   https://qb64forum.alephc.xyz/index.php?topic=809
192. ' GuiTools - A graphic UI framework (can do multiple UI forms/windows in one program)
193. ' Libraries - ImageProcess, StringBuffers (virt. files), MD5/SHA2-Hash, LZW etc.
194. ' Bonus - Blankers, QB64/Notepad++ setup pack
195.  
196. Function IndexFormat$ (fmt$, arg$, sep$)
197.     '--- option _explicit requirements ---
198.     Dim args$, shan&, dhan&, than&, idx%, cpos&, res$, lit%, tok%, ft$, cch$
199.     Dim och$, opos&, tmp$, fp$, tyl%, typ$, oval&&, temp~&&, curr%, high%
200.     '--- init ---
201.     args$ = arg$ 'avoid side effects
202.     shan& = _Source: dhan& = _Dest: than& = _NewImage(256, 1, 0)
203.     _Source than&: _Dest than&
204.     ReDim argArr$(0 To 35) 'all args empty
205.     '--- parse arguments ---
206.     If Right$(args$, Len(sep$)) <> sep$ Then args$ = args$ + sep$
207.     For idx% = 0 To 35
208.         cpos& = InStr(args$, sep$): If cpos& = 0 Then Exit For
209.         argArr$(idx%) = Left$(args$, cpos& - 1)
210.         args$ = Mid$(args$, cpos& + Len(sep$))
211.     Next idx%
212.     '--- process format template ---
213.     res$ = "": lit% = 0: tok% = 0: ft$ = "": idx% = -1
214.     For cpos& = 1 To Len(fmt$)
215.         cch$ = Mid$(fmt$, cpos&, 1)
216.         If cch$ = "_" And lit% = 0 Then 'take next \{} as literal
217.             If Not tok% Then lit% = -1
218.         ElseIf cch$ = "\" And lit% = 0 And tok% = 0 Then 'insert esc sequence
219.             If cpos& < Len(fmt$) Then
220.                 Select Case UCase$(Mid$(fmt$, cpos& + 1, 1))
221.                     Case "A": och$ = Chr$(7) ' audio bell
222.                     Case "B": och$ = Chr$(8) ' backspace
223.                     Case "T": och$ = Chr$(9) ' tabulator
224.                     Case "N": och$ = Chr$(10) 'line feed
225.                     Case "V": och$ = Chr$(11) 'vertical tabulator
226.                     Case "F": och$ = Chr$(12) 'form feed
227.                     Case "R": och$ = Chr$(13) 'carriage return
228.                     Case "E": och$ = Chr$(27) 'escape
229.                     Case "0", "1", "2", "3" '  octal ASCII (3 digits)
230.                         och$ = Chr$(Val("&O" + Mid$(fmt$, cpos& + 1, 3)))
231.                         cpos& = cpos& + 2
232.                     Case "X" '                 hex ASCII (x + 2 digits)
233.                         och$ = Chr$(Val("&H" + Mid$(fmt$, cpos& + 2, 2)))
234.                         cpos& = cpos& + 2
235.                     Case Else: och$ = "" '     ignore unknowns
236.                 End Select
237.                 res$ = res$ + och$
238.                 cpos& = cpos& + 1: opos& = cpos&
239.             End If
240.         ElseIf cch$ = "{" And lit% = 0 Then 'begin of formatting token
241.             If idx% = -1 Then
242.                 och$ = UCase$(Mid$(fmt$, cpos& - 1, 1)): tok% = -1
243.                 If ((cpos& - 1) = opos&) Or ((och$ < "0" Or och$ > "9") And (och$ < "A" Or och$ > "Z")) Then och$ = "-"
244.                 If och$ = "-" Then och$ = "0": Else res$ = Left$(res$, Len(res$) - 1)
245.                 If och$ >= "A" Then idx% = Asc(och$) - 55: Else idx% = Val(och$)
246.             End If
247.         ElseIf cch$ = "}" And lit% = 0 Then 'end of formatting token
248.             If idx% >= 0 Then
249.                 GoSub doArgFormat: res$ = res$ + tmp$
250.                 tok% = 0: ft$ = "": idx% = -1
251.             End If
252.         Else 'accumulate chars/symbols in correct channel
253.             If lit% And InStr("\{}", cch$) = 0 Then cch$ = "_" + cch$
254.             If tok% Then ft$ = ft$ + cch$: Else res$ = res$ + cch$
255.             lit% = 0
256.         End If
257.     Next cpos&
258.     '--- cleanup & set result ---
259.     Erase argArr$
260.     _Source shan&: _Dest dhan&: _FreeImage than&
261.     IndexFormat$ = res$
262.     Exit Function
263.     '-----------------------------
264.     doArgFormat:
265.     'Cls:
266.     tmp$ = "": fp$ = "": ft$ = LTrim$(RTrim$(ft$))
267.     If Left$(ft$, 1) = "?" Then
268.         tyl% = InStr(2, ft$, ":")
269.         If tyl% > 0 Then fp$ = Left$(Mid$(ft$, 2, tyl% - 2), 2): ft$ = LTrim$(Mid$(ft$, tyl% + 1)) 'extract format prefs
270.     End If
271.     If ft$ = "" Then Return 'empty token = empty formatted
272.     Select Case UCase$(Left$(ft$, 1))
273.         Case "!", "&", "\" 'regular string formatting
274.             If Left$(ft$, 1) = "\" Then
275.                 tyl% = InStr(2, ft$, "\"): If tyl% = 0 Then ft$ = "\" + ft$: tyl% = 2
276.                 If LTrim$(fp$) <> "" And Len(argArr$(idx%)) < tyl% Then
277.                     Select Case Left$(LTrim$(fp$), 1)
278.                         Case "C", "c": tyl% = (tyl% - Len(argArr$(idx%))) \ 2
279.                         Case "R", "r": tyl% = tyl% - Len(argArr$(idx%))
280.                         Case Else: tyl% = 0 'L or Unknown is default (left)
281.                     End Select
282.                     argArr$(idx%) = Space$(tyl%) + argArr$(idx%)
283.                 End If
284.             End If
285.             Print Using ft$; argArr$(idx%);: fp$ = ""
286.         Case "B", "D", "H", "O", "R" 'extended number formatting (bin/dec/hex/oct/real)
287.             typ$ = Left$(ft$, 1): tyl% = Val(Mid$(ft$, 2))
288.             Select Case typ$
289.                 Case "B", "b": GoSub doBinString
290.                 Case "D", "d": tmp$ = LTrim$(Str$(_Round(Val(argArr$(idx%)))))
291.                 Case "H", "h"
292.                     tmp$ = Hex$(Val(argArr$(idx%)))
293.                     If typ$ = "H" Then tmp$ = UCase$(tmp$): Else tmp$ = LCase$(tmp$)
294.                 Case "O", "o": tmp$ = Oct$(Val(argArr$(idx%)))
295.                 Case "R", "r": tmp$ = LTrim$(Str$(Val(argArr$(idx%)))): fp$ = ""
296.             End Select
297.             If tyl% > 0 Then 'adjust field length (if any)
298.                 If Len(tmp$) <= tyl% Then
299.                     tmp$ = Right$(String$(tyl%, "0") + tmp$, tyl%): idx% = InStr(tmp$, "-")
300.                     If idx% > 0 Then
301.                         typ$ = UCase$(Mid$(tmp$, idx% - 1, 1))
302.                         If typ$ <> "E" And typ$ <> "D" Then tmp$ = "-" + Left$(tmp$, idx% - 1) + Mid$(tmp$, idx% + 1)
303.                     End If
304.                 Else
305.                     tmp$ = "%" + tmp$
306.                 End If
307.             End If
308.             If LTrim$(fp$) <> "" Then 'apply grouping (if any)
309.                 typ$ = "": tyl% = 0
310.                 For idx% = Len(tmp$) To 1 Step -1
311.                     typ$ = Mid$(tmp$, idx%, 1) + typ$: tyl% = tyl% + 1
312.                     If tyl% = Val(fp$) Then typ$ = " " + typ$: tyl% = 0
313.                 Next idx%
314.                 tmp$ = LTrim$(typ$): If Left$(tmp$, 2) = "- " Then tmp$ = "-" + Mid$(tmp$, 3)
315.             End If
316.             Return
317.         Case Else 'regular number formatting (or invalid nonsense)
318.             If InStr(ft$, "**") = 0 And InStr(ft$, "$$") = 0 And InStr(ft$, "#") = 0 Then
319.                 Print ft$; 'take nonsense as is
320.             Else
321.                 Print Using ft$; Val(argArr$(idx%));
322.             End If
323.     End Select
324.     tyl% = InStr(fp$, ","): If tyl% > 0 Then Mid$(fp$, tyl%, 1) = " "
325.     fp$ = LTrim$(RTrim$(fp$))
326.     For idx% = 1 To Pos(0) - 1
327.         typ$ = Chr$(Screen(1, idx%)): ft$ = typ$
328.         If fp$ <> "" And typ$ = "$" Then ft$ = fp$
329.         If tyl% > 0 And typ$ = "," Then ft$ = "."
330.         If tyl% > 0 And typ$ = "." Then ft$ = ","
331.         tmp$ = tmp$ + ft$
332.     Next idx%
333.     Return
334.     '-----------------------------
335.     doBinString:
336.     oval&& = Val(argArr$(idx%)): temp~&& = oval&&
337.     tmp$ = String$(64, "0"): curr% = 64: high% = 64
338.     Do
339.         If (temp~&& And 1) Then Asc(tmp$, curr%) = 49: high% = curr%
340.         curr% = curr% - 1: temp~&& = temp~&& \ 2
341.     Loop Until temp~&& = 0
342.     If oval&& < 0 Then
343.         If -oval&& < &H0080000000~&& Then high% = 33
344.         If -oval&& < &H0000008000~&& Then high% = 49
345.         If -oval&& < &H0000000080~&& Then high% = 57
346.     End If
347.     tmp$ = Mid$(tmp$, high%)
348.     Return
349. End Function ' IndexFormat$
350.  
351. ' An example using the new IndexFormat function:
352. ' Save as: FormatExample.bas (or whatever)
353.  
354. Sub IndexFormatTest1
355.     Dim RoutineName As String: RoutineName = "Example of IndexFormat$ by RhoSigma"
356.  
357.     '_Title "FormatExample"
358.  
359.     '=== Full description for the IndexFormat$() function is available
360.     '=== in the separate HTML document.
361.     '=====================================================================
362.     'Width , 30
363.  
364.     '-- The following format templates need its arguments in different order,
365.     '-- no problem with indexing, no need to reorder the given arguments.
366.     '-- You may even use different formatting for the same argument, as long
367.     '-- as its types are compatible (ie. string vs. number).
368.     dateDE$ = "Date format Germany: 0{#}. 1{&} 2{####}" ' 1{} = full string
369.     dateUS$ = "Date format US     : 1{\ \}/0{#} 2{####}" '1{} = first 3 chars only
370.  
371.     '-- The easiest way to pass a variable number of arguments, which may
372.     '-- even be of different types, to a user function is using a string.
373.     '-- All arguments will be concatenated in this string, separated by a
374.     '-- designated char/string which does not appear in the arguments itself.
375.     '-- Strings can be added as is, numbers can be added as literal strings
376.     '-- too, or in the form STR$(variable).
377.     year% = 2021
378.     argStr$ = "2|Januar|" + Str$(year%)
379.     '-- In this example the | is the argument separator. Use whatever is
380.     '-- suitable for your needs, maybe even a CHR$(0).
381.  
382.     '-- Now let's test the whole thing, we've different token orders in the
383.     '-- format templates, but use the same argument string for both calls.
384.     Cls: Print RoutineName: Print
385.     Print "DATE FORMATTING:"
386.     Print "dateDE$=" + Chr$(34) + IndexFormat$(dateDE$, argStr$, "|") + Chr$(34)
387.     Print "dateUS$=" + Chr$(34) + IndexFormat$(dateUS$, argStr$, "|") + Chr$(34)
388.     Print
389.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
390.  
391.     '-- And here the examples from the function description, which also
392.     '-- shows the reuse of arguments without the need to pass more arguments
393.     '-- for the additional "feet" and "toes" format tokens.
394.     head = 1: hands = 2: fingers = 10
395.     Cls: Print RoutineName: Print
396.     Print "WITH PRINT USING:"
397.     Print Using "## head, ## hands and ## fingers"; head, hands, fingers
398.     Print Using "## fingers, ## head and ## hands"; head, hands, fingers
399.  
400.     Print
401.     Print "WITH IndexFormat$:"
402.     argStr$ = Str$(head) + "|" + Str$(hands) + "|" + Str$(fingers)
403.     Print IndexFormat$("2{##} fingers, 0{##} head and 1{##} hands", argStr$, "|")
404.     Print
405.     Print IndexFormat$("0{##} head, 1{##} hands and 2{##} fingers, also 1{##} feet and 2{##} toes", argStr$, "|")
406.     Print
407.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
408.  
409.     '-- The function can also handle escape sequences as known from C/C++,
410.     '-- so you may use those sequences within your format templates.
411.     Cls: Print RoutineName: Print
412.     Print "EXAMPLE OF ESCAPE SEQUENCES:"
413.     Print
414.     Print IndexFormat$("Column-1\tColumn-2\tColumn-3\n0{#.##}\t\t1{#.##}\t\t2{#.##}", "1.11|2.22|3.33", "|")
415.     Print
416.     Print IndexFormat$("This is a \x220{&}\x22 section.", "quoted", "|")
417.     Print
418.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
419.  
420.     Cls: Print RoutineName: Print
421.     Print "EXAMPLE OF ESCAPE SEQUENCES and the new bin/dec/hex/oct/real formatting:"
422.     '-- Using escape sequences and the new bin/dec/hex/oct/real formatting,
423.     '-- while reusing the same argument for all tokens. Also showing the use
424.     '-- of preferences specifiers to group bin and hex outputs.
425.     Print IndexFormat$(" Bin: 0{?4:B16}\n Dec: 0{D}\n Hex: 0{?2:H8}\n Oct: 0{O}\nReal: 0{R}\n", "2021.00548", "|")
426.     Print
427.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
428.  
429.     '-- Alignment of strings in a fixed length field, the square brackets are
430.     '-- just used to better visualize the field.
431.     Cls: Print RoutineName: Print
432.     Print "ALIGNMENT OF STRINGS:"
433.     Print IndexFormat$("[0{?L:\             \}]", "RhoSigma", "|")
434.     Print IndexFormat$("[0{?C:\             \}]", "RhoSigma", "|")
435.     Print IndexFormat$("[0{?R:\             \}]", "RhoSigma", "|")
436.     Print
437.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
438.  
439.     '-- Finally a currency example with replaced dollar sign and flipped
440.     '-- comma/dot notation. I'd like to get that much for this function ;)
441.     Cls: Print RoutineName: Print
442.     Print "CURRENCY EXAMPLE:"
443.     Print IndexFormat$("Account balance: 0{?î,:**$#####,.##}", "12345.67", "|")
444.     Print
445.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
446. End Sub ' IndexFormatTest1
447.  
448. ' /////////////////////////////////////////////////////////////////////////////
449. 'insert FUNCTION IndexFormat$ here, get it from:
450. 'https://qb64forum.alephc.xyz/index.php?topic=2932.msg121898#msg121898
451. '(7z inclusive example and docs)
452.  
453. Sub IndexFormatTest2
454.     Print "-------------------------------------------------------------------------------"
455.     Print "IndexFormat$ by RhoSigma:"
456.     Print
457.  
458.     Print "number as is:"
459.     Print IndexFormat$("MyInteger% = 0{R}", Str$(32767), "~")
460.     Print "number with thousands separator:"
461.     Print IndexFormat$("MyInteger% = 0{#####,}", Str$(32767), "~")
462.     Print "number with thousands separator flipped to:"
463.     Print IndexFormat$("MyInteger% = 0{?,:#####,}", Str$(32767), "~")
464.     Print "number as grouped Hex/Oct/Bin:"
465.     Print IndexFormat$("MyInteger% = 0{?2:H8}", Str$(32767), "~")
466.     Print IndexFormat$("MyInteger% = 0{?4:O8}", Str$(32767), "~")
467.     Print IndexFormat$("MyInteger% = 0{?4:B16}", Str$(32767), "~")
468.     Print "-------------------------------------------------------------------------------"
469.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
470. End Sub ' IndexFormatTest2
471.  
472. ' /////////////////////////////////////////////////////////////////////////////
473. ' Re: converting a number to a string, formatted like with "print using"
474.  
475. ' RhoSigma
476. ' « Reply #3 on: March 05, 2022, 04:49:33 pm »
477. ' « Last Edit: March 05, 2022, 04:55:02 pm »
478.  
479. ' Ah, so you talk about function overloading. Not possible in QB64 as is,
480. ' but look on IndexFormat$, it's a function which needs to handle several
481. ' different arguments/types too, it takes all the different parameters in
482. ' the argument string, all added together, strings as is, numbers via STR$().
483. ' Then, inside the functions you need to parse that whole argument string
484. ' to get what you need.
485.  
486. ' Another way would be a user defined type.
487.  
488. ' As you can see, there are multiple ways to build universal functions,
489. ' but unfortunately no such easy thing like a 'variants" type.
490. ' Somewhere you have to go in and do your own coding.
491.  
492. ' Guess [member=9]SMcNeill[/member] could also show you a variant doing this with _MEM variables.
493. ' He made a universal QuickSort function somewhere here in the forum,
494. ' using _MEM variables to determine the array type which is to be sorted
495. ' in his function.
496.  
497. ' EDIT:
498. ' here's the _MEM sort, maybe you can derive something useful for your needs...
499. ' https://qb64forum.alephc.xyz/index.php?topic=1601.0
500.  
501. 'Type aNumber
502. '    typ AS STRING * 3
503. '    n8 AS _BYTE
504. '    n16 AS INTEGER
505. '    n32 AS LONG
506. '    n64 AS _INTEGER64
507. '    ns AS SINGLE
508. '    nd AS DOUBLE
509. '    nf AS _FLOAT
510. 'END TYPE
511.  
512. Function DoSomthingWithNumber$ (x As aNumber)
513.     Select Case _Trim$(x.typ)
514.         Case "n8"
515.             'do _BYTE stuff here
516.             DoSomthingWithNumber$ = "type _BYTE"
517.         Case "n16"
518.             'do INTEGER stuff here
519.             DoSomthingWithNumber$ = "type INTEGER"
520.         Case "n32"
521.             'do LONG stuff here
522.             DoSomthingWithNumber$ = "type LONG"
523.         Case "n64"
524.             'do _INTEGER64 stuff here
525.             DoSomthingWithNumber$ = "type _INTEGER64"
526.         Case "ns"
527.             'do SINGLE stuff here
528.             DoSomthingWithNumber$ = "type SINGLE"
529.         Case "nd"
530.             'do DOUBLE stuff here
531.             DoSomthingWithNumber$ = "type DOUBLE"
532.         Case "nf"
533.             'do _FLOAT stuff here
534.             DoSomthingWithNumber$ = "type _FLOAT"
535.         Case Else
536.             'unsupported type
537.             DoSomthingWithNumber$ = "type unknown"
538.     End Select
539. End Function ' DoSomthingWithNumber$
540.  
541. Sub DoSomthingWithNumber_Test
542.     Dim num As aNumber
543.     Dim res As String
544.  
545.     Print "-------------------------------------------------------------------------------"
546.     Print "Function overloading example by RhoSigma:"
547.     num.typ = "n16"
548.     num.n16 = 32767
549.     res = DoSomthingWithNumber$(num)
550.     Print res
551.     Print "-------------------------------------------------------------------------------"
552.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
553.  
554. End Sub ' DoSomthingWithNumber_Test
555.  
556. ' /////////////////////////////////////////////////////////////////////////////
557. ' bplus
558. ' « Reply #5 on: March 05, 2022, 08:00:10 pm »
559. ' Seems like Double parameter can handle various Types:
560.  
561. Function commaD$ (n#, nDecPlaces%) 'only works right for double# type
562.     Dim place As Long, s$, front$, back$, func$
563.     func$ = _Trim$(Str$(n#))
564.     If Left$(func$, 1) = "-" Then s$ = "-": func$ = Mid$(func$, 2) Else s$ = ""
565.     place = InStr(func$, ".")
566.     If place = 0 Then place = Len(func$) + 1
567.     While place > 4
568.         func$ = Mid$(func$, 1, place - 4) + "," + Mid$(func$, place - 3)
569.         place = InStr(func$, ",")
570.     Wend
571.     'fix to nDecPlaces
572.     place = InStr(func$, ".")
573.     If nDecPlaces% Then
574.         If place Then
575.             front$ = Mid$(func$, 1, place)
576.             back$ = Mid$(func$, place + 1)
577.             If Len(back$) > nDecPlaces% Then func$ = front$ + Left$(back$, nDecPlaces%)
578.             If Len(back$) < nDecPlaces% Then func$ = front$ + Left$(back$ + String$(nDecPlaces%, "0"), nDecPlaces%)
579.         Else
580.             func$ = func$ + "." + String$(nDecPlaces%, "0")
581.         End If
582.     Else
583.         If place Then func$ = Mid$(func$, 1, place - 1)
584.     End If
585.     commaD$ = s$ + func$
586. End Function
587.  
588. Sub commaD_Test
589.     Dim i%
590.     Dim j&
591.     Dim k##
592.  
593.     Print "-------------------------------------------------------------------------------"
594.     Print "commaD$ by bplus:"
595.  
596.     i% = 100000 * Rnd - 50000
597.     Print "i%=" + _Trim$(Str$(i%))
598.     Print "commaD$(i%, 2) returns " + Chr$(34) + commaD$(i%, 2) + Chr$(34)
599.  
600.     j& = 10000000 * Rnd - 5000000
601.     Print "j&=" + _Trim$(Str$(j&))
602.     Print "commaD$(j&, 2) returns " + Chr$(34) + commaD$(j&, 2) + Chr$(34)
603.  
604.     k## = 100000 * Rnd - 50000
605.     Print "k##=" + _Trim$(Str$(k##))
606.     Print "commaD$(k##, 4) returns " + Chr$(34) + commaD$(k##, 4) + Chr$(34)
607.     Print "-------------------------------------------------------------------------------"
608.  
609.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
610. End Sub ' commaD_Test
611.  
612. ' /////////////////////////////////////////////////////////////////////////////
613. ' SMcNeill
614. ' « Reply #6 on: March 05, 2022, 10:26:57 pm »
615. ' Try something like this:
616. '     Print "FOO: "; format$("###.###", "123.456789")
617. '     Print format$("###,.##", "123456789.987654321")
618. ' Pass it the same format string you'd use with PRINT USING, and then
619. ' the STR$ value of your number.  It'll return a string formatted just as
620. ' PRINT USING would do.
621.  
622. ' bplus
623. ' « Reply #7 on: March 06, 2022, 11:52:41 am »
624. ' Oh! that looks like it gets around the Type problem.
625. '     n = _NewImage(80, 80, 0)
626. ' 0 the one mode you can read characters from, a point for Pete ;-))
627.  
628. ' Juanjogomez
629. ' « Reply #8 on: March 14, 2022, 08:52:16 am »
630. ' Re: converting a number to a string, formatted like with "print using"
631. ' Very original, simple and effective
632.  
633. Function format$ (template As String, text As String)
634.     d = _Dest: s = _Source
635.     n = _NewImage(80, 80, 0)
636.     _Dest n: _Source n
637.     Print Using template; Val(text)
638.     For i = 1 To 79
639.         t$ = t$ + Chr$(Screen(1, i))
640.     Next
641.     If Left$(t$, 1) = "%" Then t$ = Mid$(t$, 2)
642.     format$ = _Trim$(t$)
643.     _Dest d: _Source s
644.     _FreeImage n
645. End Function ' format$
646.  
647. Sub FormatStringTest
648.     Dim MySingle As Single
649.     Dim MyDouble As Double
650.     Dim MyString As String
651.  
652.     Print "-------------------------------------------------------------------------------"
653.     Print "format$ by SMcNeill:"
654.     Print
655.  
656.     MySingle = 123.456789
657.     Print "MySingle=" + _Trim$(Str$(MySingle))
658.     MyString = format$("###.###", _Trim$(Str$(MySingle)))
659.     Print "format$(" + Chr$(34) + "###.###" + Chr$(34) + ", _Trim$(Str$(MySingle))) returns " + Chr$(34) + MyString + Chr$(34)
660.     Print
661.  
662.     MyDouble = 123456789.987654321
663.     Print "MyDouble=" + _Trim$(Str$(MyDouble))
664.     MyString = format$("###,.##", _Trim$(Str$(MyDouble)))
665.     Print "format$(" + Chr$(34) + "###,.##" + Chr$(34) + ", _Trim$(Str$(MyDouble))) returns " + Chr$(34) + MyString + Chr$(34)
666.  
667.     Print "-------------------------------------------------------------------------------"
668.     Print "PRESS ANY KEY TO CONTINUE": Sleep: _KeyClear
669.  
670. End Sub ' FormatStringTest
671.  

[Pete]

Quote from bplus: "0 the one mode you can read characters from, a point for Pete ;-))"

Yep, SCREEN 0 rules! Back in good old QBasic days, I used to place data on the screen in color 0, 0, at the end of one program, and then used RUN to start a new, related program. The new program would read the data from the screen, clear the screen, and use the data to determine the actions of the program. I never used CHAIN. I think it might be racist! :D

Pete

[bplus]

Quote from bplus: "0 the one mode you can read characters from, a point for Pete ;-))"

Yep, SCREEN 0 rules! Back in good old QBasic days, I used to place data on the screen in color 0, 0, at the end of one program, and then used RUN to start a new, related program. The new program would read the data from the screen, clear the screen, and use the data to determine the actions of the program. I never used CHAIN. I think it might be racist! :D

Pete

Wow that is pretty cool idea for old QB stuff!

@madscijr I think my commaD$ does fail somewhere if you don't use double for sure (not even sure how far with doubles you can go). And if you just need to overcome Types use Steve's suggested approach, looks quite promising though I haven't tested limits. But if you want a great all purpose Format$ that does even more than QB original go with Rho Sigma's; it carries extra LOC and a little learning curve but what great versatility!

[madscijr]

@madscijr I think my commaD$ does fail somewhere if you don't use double for sure (not even sure how far with doubles you can go). And if you just need to overcome Types use Steve's suggested approach, looks quite promising though I haven't tested limits. But if you want a great all purpose Format$ that does even more than QB original go with Rho Sigma's; it carries extra LOC and a little learning curve but what great versatility!

Sounds good - I have them in my toolbox now!

[madscijr]

Back in good old QBasic days, I used to place data on the screen in color 0, 0, at the end of one program, and then used RUN to start a new, related program. The new program would read the data from the screen, clear the screen, and use the data to determine the actions of the program.

That's a neat little hack there!
"Pretty sneaky, sis!" lol