A simple command line tool translating DEF FN functions into FUNCTIONs

[TempodiBasic]

Hi guys
cause I see often the request  "  How to solve the porting in QB64 of program written inQbasic and QB with the DEF FN statement?"
I have developed in Qbasic and ported to QB64 this tool
it translates code from Qbasic to QB64...

after compiled into QB64 you can use the program from command line or with drag & drop ...
Here attached the code DEF2FUN.BAS and some Qbasic code with DEF FN on one line and multiline.
There are 2 compressed files .7z and .tar for different software in your possess.
Thanks to try and for feedbacks

[Pete]

Request. If this is just one QB64 file (program) would you please edit your post to also include the code?

Example:

Code: QB64: [Select]

1. PRINT "Ewwwe I hates unzippin' things, varmint!"
2. END
3.  

Pete 

[bplus]

Request. If this is just one QB64 file (program) would you please edit your post to also include the code?

Example:

Code: QB64: [Select]

1. PRINT "Ewwwe I hates unzippin' things, varmint!"
2. END
3.  

Pete 

Well I appreciate TempodiBasic having 2 different package options for the 4 bas files included, that is convenient! Thanks TempodiBasic.

But I see Pete's point, would be nice to just view the main bas code, so for that reason I offer this service:

Code: QB64: [Select]

1. DECLARE SUB OneLine (LineOfCode$, Count%)
2. DECLARE SUB Multiline (Line$, Count%)
3. DECLARE FUNCTION Incr% (Intero%)
4.  
5. '_________INFO_______________________________________
6. ' le funzioni DEF FN possono essere monoriga
7. ' DEF fnP (a%)  = a% + 1
8.  
9. ' oppure  multiriga
10. ' DEF fnP (a%)
11. '      a% = a% * 3
12. '      fnP= a% + 1
13. ' END DEF
14. ' le definizioni monoriga  o multiriga non si possono impilare a matrioska
15. ' le DEF Fn devono avere almeno un parametro
16. ' le DEF Fn non possono accedere alle variabili condivise
17. ' nŠ avere variabili con lo stesso nome delle variabili condivise o globali
18. ' ______________END of INFO___________________________
19.  
20. ' Project of program__________________________________________
21. ' pseudocodice per il traduttore di FN a FUNCTION
22. ' siccome in QB64 FN non Š un token allora lo lasciamo dov'Š
23. ' e prendiamo una strata pi— semplice
24.  
25. ' apri il file da tradurre
26. ' apri il file da tradotto da scrivere
27. ' leggi il file riga per riga fino alla fine
28. ' se c'Š un DEF FN
29. '               se c'Š = Š una funzione a singola riga
30. '                     scrivi nel file tradotto
31. '                               FUNCTION e la parte della riga da FN e =
32. '                               FNnomefunzione = la parte della riga dopo =
33. '                               END FUNCTION
34. '               altrimenti Š una funzione multiriga
35. '                     scrivi nel file tradotto
36. '                               FUNCTION e la parte della riga da FN in poi
37. '                               memorizza il nome della FN
38. '                               leggi il file riga per riga fino a quando
39. '                               trova END DEF o ottiene fine file
40. '                                       se Š presente EXIT DEF scrivi EXIT FUNCTION
41. '                                       se Š presente END DEF esci dal loop
42. '                                       scrivi la riga
43. '                               END FUNCTION
44. '
45. ' End of Project of Program____________________________________________________
46.  
47.  
48. ' constants of token to translate
49. CONST Primo = "DEF FN", Secondo = "=", Terzo = "FN"
50. CONST Quarto = "EXIT DEF", Quinto = "END DEF", Sesto = "("
51. ' variable to process lines of code
52. Counter% = 0 ' it counts how many functions are translated
53. Fi$ = "" ' File of input
54. Fo$ = "" ' File of output
55. Fdef$ = "" ' Temporary file for function translated
56. LineOfCode$ = "" ' it brings the line of code read from file
57.  
58. Fi$ = COMMAND$ ' File of input
59. IF Fi$ = "" THEN
60.     CLS
61.     PRINT "DEF2FUN Help:"
62.     PRINT " Usage: DEF2FUN NamefileToTranslate"
63.     PRINT " It needs one parameter at run "
64.     END
65. END IF
66.  
67. LenFi = LEN(Fi$)
68. IF INSTR(Fi$, ".") THEN
69.     ' name file has extention
70.     ExtFi$ = RIGHT$(Fi$, LEN(Fi$) - INSTR(Fi$, ".") + 1)
71.     NamFi$ = LEFT$(Fi$, INSTR(Fi$, ".") - 1)
72.     Fo$ = LEFT$(NamFi$, LenFi - 3) + "Tmp" + ExtFi$
73.     Fdef$ = LEFT$(NamFi$, LenFi - 3) + ".TMP"
74. ELSE
75.     ' name file has no extension
76.     Fo$ = "Tmp" + LEFT$(Fi$, 3)
77.     Fdef$ = Fo$ + ".TMP"
78. END IF
79.  
80.  
81. ' open files for input and output
82. CLS
83. PRINT "Opening files..."
84. OPEN Fi$ FOR INPUT AS #1
85. PRINT " Opened Input file..."
86. OPEN Fo$ FOR OUTPUT AS #2
87. OPEN Fdef$ FOR OUTPUT AS #3
88. PRINT " Opened output file..."
89.  
90. ' it puts author's sign
91. PRINT #2, " REM  File made by DEF2FUNC utility by TempodiBasic "
92. PRINT #2, " REM  DEF2FUNC translate any function DEF FN to the FUNCTION syntax"
93. PRINT #2, ""
94.  
95. ' main loop processing file
96. DO WHILE NOT EOF(1)
97.     PRINT " Reading file...";
98.     LINE INPUT #1, LineOfCode$
99.     PRINT LineOfCode$
100.     ' search a definition of DEF FN
101.     IF INSTR(UCASE$(LineOfCode$), Primo) THEN
102.         PRINT " Found a DEF FN: "; LineOfCode$
103.         PRINT #3, "FUNCTION ";
104.         '  is DEF FN in oneline or in multiline?
105.         IF INSTR(LineOfCode$, Secondo) THEN
106.             OneLine LineOfCode$, Counter%
107.         ELSE
108.             Multiline LineOfCode$, Counter%
109.         END IF
110.     ELSE ' no definition of DEF FN
111.         PRINT #2, LineOfCode$
112.     END IF
113. LOOP
114. PRINT "End of translation..."
115. PRINT " Rebuilding the file..."
116. CLOSE ' closes all files
117. OPEN Fo$ FOR APPEND AS #1
118. OPEN Fdef$ FOR INPUT AS #2
119. DO WHILE NOT EOF(2)
120.     LINE INPUT #2, LineOfCode$
121.     PRINT #1, LineOfCode$
122. LOOP
123. CLOSE ' closes all files
124. PRINT " File translated ..."
125. KILL Fdef$
126. END ' end of program
127.  
128. FUNCTION Incr% (Intero%)
129.     Incr% = Intero% + 1
130. END FUNCTION
131.  
132. SUB Multiline (Line$, Counter%)
133.     PRINT " It is a multiline DEF FN"
134.     ' this subprogram process a DEF FN on multiline
135.     NextLine$ = ""
136.     Counter% = Incr(Counter%)
137.     NameOfFN$ = RIGHT$(Line$, LEN(Line$) - (INSTR(UCASE$(Line$), Primo) + LEN(Primo) - 3))
138.     PRINT #3, NameOfFN$
139.     DO WHILE NOT EOF(1)
140.         'here it processes multiline DEF FN after the first line of code
141.         LINE INPUT #1, NextLine$
142.         IF INSTR(UCASE$(NextLine$), Quarto) THEN
143.             PRINT #3, " EXIT FUNCTION "
144.         ELSEIF INSTR(UCASE$(NextLine$), Quinto) THEN
145.             EXIT DO
146.         ELSE
147.             PRINT #3, NextLine$
148.         END IF
149.     LOOP
150.     PRINT #3, "END FUNCTION"
151. END SUB
152.  
153. SUB OneLine (LineOfCode$, Counter%)
154.     PRINT " It is a oneline DEF FN"
155.     ' this subprogram process a DEF FN on oneline
156.     Counter% = Incr(Counter%)
157.     Start% = INSTR(UCASE$(LineOfCode$), Primo) + LEN(Primo) - 2
158.     Lenght% = INSTR(UCASE$(LineOfCode$), Secondo) - Start%
159.     NameOfFN$ = MID$(LineOfCode$, Start%, Lenght%)
160.     PRINT "FUNCTION "; NameOfFN$
161.     PRINT #3, NameOfFN$
162.     PRINT #3, LEFT$(NameOfFN$, INSTR(NameOfFN$, "(") - 1);
163.     PRINT #3, RIGHT$(LineOfCode$, LEN(LineOfCode$) - (INSTR(UCASE$(LineOfCode$), Secondo) - 1))
164.     PRINT #3, "END FUNCTION"
165. END SUB
166.  
167.  

[Pete]

Thanks Mark! Yeah, I'm getting on in years, and I can't stand taking extra steps to do things, if there is an easier way. Select - Copy - Paste into the IDE. Those are the only code samples I look at and try these days. One exception. If I see something interesting, and the zip has multiple files and/or is too big to post, because of board limits. Actually, in the case of multiple files, the zip is a step saver. I just would appreciate if all small enough to post code snippets without dependency files, would be posted in code boxes. Now if you will excuse me, this laxative isn't going to drink itself. Oh dam, chocolate again!

Pete

[bplus]

I am testing TempodiBasic's conversion and I have a question about the old QB45 way to use DEF FN: Didn't it use to be like this:

Code: QB64: [Select]

1. DEF FN oneTheHardWay(theta) = sin(theta) ^2 + cos(theta) ^2
2.  
3. print oneTheHardWay(_pi/4)
4.  

TempodiBasic has it this way, with the FN as part of the function name:

Code: QB64: [Select]

1. DEF fnPiuUno (z%) = z% + 1
2. DEF FNPer2 (z%) = z% * 2
3. DEF fNPer10 (z%) = z% * 10
4. DEF FnDiv1 (z%) = z% / 1
5.  
6.  
7. FOR a% = 1 TO 10 STEP 1
8.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
9.  
10. NEXT a%
11. END
12.  
13.  
14.  

It's been like 25 years! Is the FN supposed to be part of the DEF FN name?

I ask because the conversion did this:

Code: QB64: [Select]

1.  REM  File made by DEF2FUNC utility by TempodiBasic
2.  REM  DEF2FUNC translate any function DEF FN to the FUNCTION syntax
3.  
4.  
5. print oneTheHardWay(_pi/4)
6.  
7. FUNCTION FN oneTheHardWay(theta)
8. FN oneTheHardWay= sin(theta) ^2 + cos(theta) ^2
9. END FUNCTION
10.  

Which is surely not going to work.

[Pete]

Nice and neat!

You may want to consider FOR BINARY instead of INPUT. If I ran my older 50K QB programs through this, FOR BINARY would make the conversions a lot faster. Smaller programs, still faster but hardly noticeable.

I like that it appears to handle one or more DEF FN lines. One screw up that could happen is a rare instance of something like this...

Code: QB64: [Select]

1. REM DEF FN: Pete is the biggest and best function ever created!

Would it stumble on that?

Anyway, this may or may not need any tweaking, but if perfect as is or could be made perfect, this would be a shining star addition to the tool box and would help lay to rest any more "demands" for adding DEF FN to the language. Honestly, it was only added to QB to save the space that language so so limited by.

Pete

[bplus]

Hi Pete, so FN has to be a prefix to the function name ie DEF FNmyFunction and not DEF FN myFunction ?

[Pete]

@bplus: Mark, I used to use this for INKEY$ routines, and I still remember adding the variable to the DEF FN as DEF FNb$, so yes, it's been a long time, but I recall you had to combine the variable to the FN part. FN I'm not mistaken!

Pete

[TempodiBasic]

Hi guys
Thanks for feedbacks

1. this is the information that I have got from QBASIC and QB45 Help

'_________INFO_______________________________________
'DEF FN functions can be single-line
'DEF fnP (a%) = a% + 1
 
'or multi-line
'DEF fnP (a%)
'a% = a% * 3
'fnP = a% + 1
'END DEF
'single line or multi line definitions cannot be stacked in matryoshka
'DEF Fn must have at least one parameter
'DEF Fn cannot access shared variables
'no have variables with the same name as shared or global variables
'______________END of INFO___________________________

Using Qbasic, the FN part of Syntax  is not changed by the parser (or syntax's checker) while DEF is uppercased!
In the first attempt I was trying to remove the FN part of the name of the function (I got this), but it is indifferent for QB64 and this task increases time used so I leave FN there.

2.  thanks for suggestion to improve this little tool

about REM or '     it is good to fix that also if  it is rare to find a REM for oneline function but it is possible

about a BINARY access to the file I'll do the update as soon as to make faster the tool

Thanks again

[TempodiBasic]

Hi
going deeper to develope the managment of exception of comments with REM or '
I find another exception... when DEF FN is in a string (closed between two " ") and it requires some controls to work well.
Soon DEF2FUN 1.0
Thanks for feedbacks

[TempodiBasic]

Hi guys
I'll be back for DEF2FUN 1.0
and it is here!

 

Thanks to feedbacks and suggestion of Pete and Bplus I have moved to the second pass gaining the 1.0 version
1. added BINARY access to file with LINE INPUT aa only QB64 let's do  http://qb64.org/wiki/LINE_INPUT_(file_statement)

NOTE: LINE INPUT will work faster in BINARY mode than in INPUT mode.
Using LINE INPUT # in BINARY mode is possible in version 1.000 and up

2. comments issue:
the first is this

Code: QB64: [Select]

1. REM DEF FN: Pete is the biggest and best function ever created!

that opens the way to a set of issue about
REM and ' as comments operators

Now DEF2FUN manages REM and ' both in first position both as added comments to the line of code

3. String issue:
as for REM and '

Code: QB64: [Select]

1. PRINT " this is a DEF Fn demo"

Now DEF2FUN manages string containing Keywords of DEF FN

Here the code of this command line tool ( remember that you can drag & drop file to translate)

Code: QB64: [Select]

1. DECLARE SUB OneLine (LineOfCode$, Count%)
2. DECLARE SUB Multiline (Line$, Count%)
3. DECLARE FUNCTION Incr% (Intero%)
4.  
5. '_________INFO_______________________________________
6. ' le funzioni DEF FN possono essere monoriga
7. ' DEF fnP (a%)  = a% + 1
8.  
9. ' oppure  multiriga
10. ' DEF fnP (a%)
11. '      a% = a% * 3
12. '      fnP= a% + 1
13. ' END DEF
14. ' le definizioni monoriga  o multiriga non si possono impilare a matrioska
15. ' le DEF Fn devono avere almeno un parametro
16. ' le DEF Fn non possono accedere alle variabili condivise
17. ' nŠ avere variabili con lo stesso nome delle variabili condivise o globali
18. ' bisogna evitare di tradurre un REM o '
19. ' se non Š passato il nome del file mostra la info
20. ' ______________END of INFO___________________________
21. _TITLE "DEF_FN_2_FUNCTION 1.0"
22. ' constants of token to translate
23. CONST Primo = "DEF FN", Secondo = "=", Terzo = "FN"
24. CONST Quarto = "EXIT DEF", Quinto = "END DEF", Sesto = "("
25.  
26. ' variable to process lines of code
27. Counter% = 0 ' it counts how many functions are translated
28. Fi$ = "" ' File of input
29. Fo$ = "" ' File of output
30. Fdef$ = "" ' Temporary file for function translated
31. LineOfCode$ = "" ' it brings the line of code read from file
32.  
33. Fi$ = COMMAND$ ' File of input
34. IF Fi$ = "" THEN
35.     CLS
36.     PRINT "DEF2FUN Help:"
37.     PRINT " Usage: DEF2FUN NamefileToTranslate"
38.     PRINT " It needs one parameter at run "
39.     END
40. END IF
41.  
42. LenFi = LEN(Fi$)
43. IF INSTR(Fi$, ".") THEN
44.     ' name file has extention
45.     ExtFi$ = RIGHT$(Fi$, LEN(Fi$) - INSTR(Fi$, ".") + 1)
46.     NamFi$ = LEFT$(Fi$, INSTR(Fi$, ".") - 1)
47.     Fo$ = LEFT$(NamFi$, LenFi - 3) + "Tmp" + ExtFi$
48.     Fdef$ = LEFT$(NamFi$, LenFi - 3) + ".TMP"
49. ELSE
50.     ' name file has no extension
51.     Fo$ = "Tmp" + LEFT$(Fi$, 3)
52.     Fdef$ = Fo$ + ".TMP"
53. END IF
54.  
55.  
56. ' open files for input and output
57. CLS
58. PRINT "Opening files..."
59. OPEN Fi$ FOR BINARY AS #1 ' only QB64 1.0 or more can use LINE INPUT in Binary mode
60. ' suggested by Pete
61. PRINT " Opened Input file..."
62. OPEN Fo$ FOR OUTPUT AS #2
63. OPEN Fdef$ FOR OUTPUT AS #3
64. PRINT " Opened output file..."
65.  
66. ' it puts author's sign
67. PRINT #2, " REM  File made by DEF2FUNC utility by TempodiBasic "
68. PRINT #2, " REM  DEF2FUNC translate any function DEF FN to the FUNCTION syntax"
69. PRINT #2, ""
70.  
71. ' main loop processing file
72. DO WHILE NOT EOF(1)
73.     PRINT " Reading file...";
74.     LINE INPUT #1, LineOfCode$
75.     PRINT LineOfCode$
76.     ' search a definition of DEF FN
77.     DefPos% = INSTR(UCASE$(LineOfCode$), Primo) ' is there a DEF FN?
78.     RemPos% = INSTR(UCASE$(LineOfCode$), "REM") ' is there a REM?
79.     Rem2Pos% = INSTR(UCASE$(LineOfCode$), "'") ' is there an '?
80.     StringPos% = INSTR(UCASE$(LineOfCode$), CHR$(34)) ' is there an " ?
81.     StringPos2% = INSTR(StringPos% + 1, UCASE$(LineOfCode$), CHR$(34)) ' is there a second "?
82.  
83.     ' if it must be translated
84.     IF DefPos% > 0 THEN
85.  
86.         ' if DEF FN is into a string it'll be put into file
87.         IF (StringPos% > 0 AND StringPos2% > 0) AND ((DefPos% > StringPos%) AND (DefPos% < StringPos2%)) THEN
88.             'write to file main
89.             PRINT #2, LineOfCode$
90.         ELSEIF (RemPos% > 0) XOR (Rem2Pos% > 0) THEN
91.             ' there is a comment with REM XOR '
92.  
93.             ' if it is a comment so it'll be put into file
94.             IF (RemPos% = 1 XOR Rem2Pos% = 1) THEN
95.                 'write to file main
96.                 PRINT #2, LineOfCode$
97.  
98.             ELSEIF ((RemPos% < DefPos% AND RemPos%) XOR (Rem2Pos% < DefPos% AND Rem2Pos%)) THEN
99.                 ' if there is DEF FN in the same line it is at right of comment's keywords
100.                 ' it is in the comment so it'll put into file
101.                 PRINT #2, LineOfCode$
102.  
103.             ELSEIF (RemPos% > DefPos%) THEN
104.                 ' a REM after DEF FN
105.                 RemLine$ = RIGHT$(LineOfCode$, LEN(LineOfCode$) - RemPos% + 1)
106.                 LineOfCode$ = LEFT$(LineOfCode$, RemPos% - 1)
107.                 PRINT #3, RemLine$
108.                 Extract_DEF_Fn (LineOfCode$)
109.  
110.             ELSEIF (Rem2Pos% > DefPos%) THEN
111.                 ' an ' after DEF FN
112.                 RemLine$ = RIGHT$(LineOfCode$, LEN(LineOfCode$) - Rem2Pos% + 1)
113.                 LineOfCode$ = LEFT$(LineOfCode$, Rem2Pos% - 1)
114.                 PRINT #3, RemLine$
115.                 Extract_DEF_Fn (LineOfCode$)
116.             END IF
117.         ELSE
118.             ' there is DEF FN and no REM ' " "
119.             Extract_DEF_Fn (LineOfCode$)
120.         END IF
121.     ELSE
122.         ' it has no DEF FN
123.         ' write line to the main file because it mustn't be translated
124.         PRINT #2, LineOfCode$
125.     END IF
126. LOOP
127. PRINT "End of translation..."
128. PRINT " Rebuilding the file..."
129. CLOSE ' closes all files
130. OPEN Fo$ FOR APPEND AS #1
131. OPEN Fdef$ FOR INPUT AS #2
132. DO WHILE NOT EOF(2)
133.     LINE INPUT #2, LineOfCode$
134.     PRINT #1, LineOfCode$
135. LOOP
136. CLOSE ' closes all files
137. PRINT " File translated ..."
138. KILL Fdef$
139. END ' end of program
140.  
141.  
142. SUB Extract_DEF_Fn (LineOfCode$)
143.     ' if there is a DEF FN
144.     PRINT " Found a DEF FN: "; LineOfCode$
145.     PRINT #3, "FUNCTION ";
146.     '  is DEF FN in oneline or in multiline?
147.     IF INSTR(LineOfCode$, Secondo) THEN
148.         OneLine LineOfCode$, Counter%
149.     ELSE
150.         Multiline LineOfCode$, Counter%
151.     END IF
152.  
153. END SUB
154.  
155.  
156. FUNCTION Incr% (Intero%)
157.     Incr% = Intero% + 1
158. END FUNCTION
159.  
160. SUB Multiline (Line$, Counter%)
161.     PRINT " It is a multiline DEF FN"
162.     ' this subprogram process a DEF FN on multiline
163.     NextLine$ = ""
164.     Counter% = Incr(Counter%)
165.     NameOfFN$ = RIGHT$(Line$, LEN(Line$) - (INSTR(UCASE$(Line$), Primo) + LEN(Primo) - 3))
166.     PRINT #3, NameOfFN$
167.     DO WHILE NOT EOF(1)
168.         'here it processes multiline DEF FN after the first line of code
169.         LINE INPUT #1, NextLine$
170.         IF INSTR(UCASE$(NextLine$), Quarto) THEN
171.             PRINT #3, " EXIT FUNCTION "
172.         ELSEIF INSTR(UCASE$(NextLine$), Quinto) THEN
173.             EXIT DO
174.         ELSE
175.             PRINT #3, NextLine$
176.         END IF
177.     LOOP
178.     PRINT #3, "END FUNCTION"
179. END SUB
180.  
181. SUB OneLine (LineOfCode$, Counter%)
182.     PRINT " It is an oneline DEF FN"
183.     ' this subprogram process a DEF FN on oneline
184.     Counter% = Incr(Counter%)
185.     Start% = INSTR(UCASE$(LineOfCode$), Primo) + LEN(Primo) - 2
186.     Lenght% = INSTR(UCASE$(LineOfCode$), Secondo) - Start%
187.     NameOfFN$ = MID$(LineOfCode$, Start%, Lenght%)
188.     PRINT "FUNCTION "; NameOfFN$
189.     PRINT #3, NameOfFN$
190.     PRINT #3, LEFT$(NameOfFN$, INSTR(NameOfFN$, "(") - 1);
191.     PRINT #3, RIGHT$(LineOfCode$, LEN(LineOfCode$) - (INSTR(UCASE$(LineOfCode$), Secondo) - 1))
192.     PRINT #3, "END FUNCTION"
193. END SUB
194.  

here code_files to test it:
DEFFN8.BAS

Code: QB64: [Select]

1. DEF fnPiuUno (z%) = z% + 1 ' sum demo " Def Fn
2. DEF FNPer2 (z%) = z% * 2  REM " Def Fn *2"
3. DEF fNPer10 (z%) = z% * 10  REM multiplication function demo
4. DEF FnDiv1 (z%) = z% / 1   'division function demo
5.  
6.  
7. ' here main block starts
8. FOR a% = 1 TO 10 STEP 1
9.    PRINT " Def Fn Demo"
10.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
11.    REM  PRINT  " All done DEF Fn Demo"
12. NEXT a%
13. END
14.  

DEFFN9.BAS

Code: QB64: [Select]

1. DEF fnPiuUno (z%) = z% + 1
2. DEF FNPer2 (z%) = z% * 2
3. DEF fNPer10 (z%) = z% * 10
4. DEF FnDiv1 (z%) = z% / 1   'division function demo
5.  
6.  
7. ' here main block starts
8. FOR a% = 1 TO 10 STEP 1
9.    PRINT " Def Fn Demo"
10.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
11.    REM  PRINT  " All done DEF Fn Demo"
12. NEXT a%
13. END
14.  

DEFFN4.BAS

Code: QB64: [Select]

1. ' DEF FnP1(z%) = z%+999
2. ' DEF fNP2(z%)
3. '      fNP2= z%*1000
4. ' END DEF
5.  
6. DEF fnPiuUno (z%)
7.         fnPiuUno = z% + 1
8. END DEF
9. DEF fNPer10 (z%) = z% * 10
10. DEF FNPer2(z%)
11.     FNPer2 = fNPer10(z%) * 2
12. END DEF
13. DEF FnDiv1 (z%) = z% / 1
14.  
15. ' main
16. CLS
17. PRINT "this is a DEF Fn demo"
18. FOR a% = 1 TO 10 STEP 1
19.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
20. NEXT a%
21. END
22.  

DEFFN3.BAS

Code: QB64: [Select]

1. ' DEF FnP1(z%) = z%+999
2. ' DEF fNP2(z%)
3. '      fNP2= z%*1000
4. ' END DEF
5.  
6. DEF fnPiuUno (z%)
7.         fnPiuUno = z% + 1
8. END DEF
9. DEF fNPer10 (z%) = z% * 10
10. DEF FNPer2(z%)
11.     FNPer2 = fNPer10(z%) * 2
12. END DEF
13. DEF FnDiv1 (z%) = z% / 1
14.  
15. ' main
16. CLS
17. FOR a% = 1 TO 10 STEP 1
18.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
19. NEXT a%
20. END
21.  

DEFFN2.BAS

Code: QB64: [Select]

1. REM DEF FnP1(z%) = z%+999
2. REM DEF fNP2(z%)
3. REM      fNP2= z%*1000
4. REM END DEF
5.  
6. DEF fnPiuUno (z%)
7.         fnPiuUno = z% + 1
8. END DEF
9. DEF fNPer10 (z%) = z% * 10
10. DEF FNPer2(z%)
11.     FNPer2 = fNPer10(z%) * 2
12. END DEF
13. DEF FnDiv1 (z%) = z% / 1
14.  
15. ' main
16. CLS
17. FOR a% = 1 TO 10 STEP 1
18.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
19. NEXT a%
20. END
21.  

DEFFN1.BAS

Code: QB64: [Select]

1. DEF fnPiuUno (z%) = z% + 1
2.  
3.  
4. FOR a% = 1 TO 10 STEP 1
5.    PRINT fnPiuUno(a%)
6. NEXT a%
7. END

DEFFN0.BAS

Code: QB64: [Select]

1. DEF fnPiuUno (z%)
2.         fnPiuUno = z% + 1
3. END DEF
4. DEF fNPer10 (z%) = z% * 10
5. DEF FNPer2(z%)
6.     FNPer2 = fNPer10(z%) * 2
7. END DEF
8. DEF FnDiv1 (z%) = z% / 1
9.  
10. ' main
11. CLS
12. FOR a% = 1 TO 10 STEP 1
13.    PRINT fnPiuUno(a%), FNPer2(a%), fNPer10(a%), FnDiv1(a%)
14. NEXT a%
15. END
16.  

Thanks to read and try
Welcome feedbacks

@Pete
No zip or tar or other compressed files, do you like this?

[FellippeHeitor]

One thing you may want to consider is scope. DEF FN procedures can access variables in the main module, since they belong to that scope. When you turn them into a function, older programs may completely break if they rely on the FN accessing local variables.

[Pete]

One thing you may want to consider is scope. DEF FN procedures can access variables in the main module, since they belong to that scope. When you turn them into a function, older programs may completely break if they rely on the FN accessing local variables.

Well in that CASE, I think Temp could look into making a variable in DEF FN local, by putting it in a STATIC statement.

DEF FN can only pass variables by value and I recall in my multi-modular programs, they were only global to the module they were contained in. In other words, if you had a 2 module program and you wanted the same DEF FN to work in both, you'd have to define the DEF FN statements in each module, and if you wanted variables passed to the other module, you had to define those variables as COMMON SHARED. Wow, this stuff takes me back to the 90's. Remind me to pick up my hair for the return trip. This Donald Trump comb over is a real pain without access to my dollar store teenage girl hairspray.

Pete

[TempodiBasic]

Hi Fellippe and Pete
thanks for feedbacks

@Fellippe
never used into a program DEF Fn so my knowledge about it is purely theoretic

about scope

One thing you may want to consider is scope. DEF FN procedures can access variables in the main module, since they belong to that scope. When you turn them into a function, older programs may completely break if they rely on the FN accessing local variables.

@Pete
Yes the Help in Qbasic describes the limitation of DEF Fn for the single module where it is declared.

Thanks so these more informations can lead to more development of this little tool.

[TempodiBasic]

Hi

I have made some experiments with DEF Fn in QBasic and yes I have missed that feature to access  to the main module's variables without SHARED in DEF Fn or DIM SHARED in main module. Moreover SHARED is forbidden into DEF Fn multiline.
Surely it is impossible to declare  in DEF Fn multiline  a variable  with the same name of those in main module already declared, but as good Qbasic/QB bug you can declare a variable in main and also in DEF Fn multiline with DIM if DEF Fn is before the  declaration in main module!.

So I think that if it is impossible to distinguish between variables of DEF FN multiline and  variables used in DEF fn multiline but declared into main module.
if you run this code into Qbasic

Code: Text: [Select]

1. DEF FnDue(z%)
2. DIM  a%
3. PRINT a%
4. FnDue = z% * a%
5. END DEF
6.  
7. CLS
8. a% = 10
9. PRINT a%
10. PRINT FnDue(4)
11. END
12.  

and after F5 you'll get as output

10
10
40

This output lets us think that the code is running first main module sequence and after the DEF Fn sequence.
But is it legal in QBasic/QB/QB64 declare a variable with assignation and then declare the same variable with DIM? NO
So the first line of DEF FN multiline

Code: Text: [Select]

1. DIM a%

must activate the error like we get if in main we type

Code: QB64: [Select]

1. c% = 1
2. DIM c%

just if a% in the main module and DIM a% in DEF Fn are the same variable! In the case that the two previous variables  are different (and not the same) we must get as output

10
0
0

because in DEF Fn a% has no assignment .  Indeed here we found another dual experience of principle of Heisenberg  https://en.wikipedia.org/wiki/Uncertainty_principle  :-) we don't know the whole universe!

Coming back to the translator of DEF Fn to FUNCTION we must admit that the issue of broken correlation between main module and DEF Fn multiline comes out for DEF Fn multiline.
The point of gray is the real possibility to define a variable into DEF FN using DIM with the same name of a variable declared into main module using the assignment statement. (as showed into following code)

Code: Text: [Select]

1. DEF FnQbasicBug (z%)
2. DIM a%
3. FnQbasicBug= z% * a%
4. END DEF
5.  
6. a% = 10
7. PRINT a%, FnQbasicBug(4)
8.  

and this strange behaviour is claimed in the same help of Qbasic with a warning don't modify global variable into DEF Fn and don't execute graphic statements into DEF Fn.

Well in conclusion I think that the issue can be solved except for the rare case of a coder that declare in DEF Fn a variable with the same name of another variable declared into the main module .

Waiting suggestions to solve this task for now I have thought  an array for a list of variable of main to shared.

Thanks to read and talk.