Program hangs unexpectedly with Type change

[bplus]

This is wacky, what am I missing?

I am checking out Zeppelin's BF signature and I see he is not using ASCII numbers because the values are way out of range for 0 to 255 for CHR$() to use.

They are huge with memory() array Typed for Integers they run range -32000 to 32000 and knowing this can't be right for print characters, they all should be positive, I up the memory array Type to Long with & suffix and the program then completely hangs with bf Zeppelin signature.txt file but works fine for the other 4 ASCII sample bf*.txt files.

Wow, that's weird so I try Type ~% unsigned Integer and it works and they are all positive in value as expected.

So what is wrong with changing Type to Long? that causes the program to hang?

Here is code with sample bf*.txt files:


Dang Typos, Code comments  should say:

'?????????????????????????????????????????????????????????????????????????

'    Why does this program hang when I change memory% or memory~% to
'    memory& and Only With bf Zeppelin signature.txt file


'????????????????????????????????????????????????????????????????????????

Yes, it hangs with 64 x 64 And with Last Beta 2018 0228/86 git 6fde149

[bplus]

Well I doubt I've stumped our in house panel of experts, I suspect they don't want to be bothered by .zip file.

I am really curious about this, not so complicated. How about if I comment out critical points in question?

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. 'BF translation.bas for QB64 fork (B+=MGA) 2017-07-23
3. ' BF in QB.bas for SmallBASIC 0.12.9 (B+=MGA) 2017-07-22
4. ' I just translated some QB code from Rosetta to SmallBASIC
5. ' and tested a couple of programs Hello World, Goodbye World
6. ' count down also found at Rosetta Code
7. '======================================================================
8. ' QB64 has excellent Help wiki, thanks to all who put that together!
9. '======================================================================
10.  
11.  
12. '?????????????????????????????????????????????????????????????????????????
13.  
14. '    Why does this program hang when I change memory% or memory~% to
15. '    memory& and Only With bf Zeppelin signature.txt file
16.  
17.  
18. '????????????????????????????????????????????????????????????????????????
19.  
20.  
21. _TITLE "Brainf***, Rosetta Code - Quick Basic translation to SB then to QB64 (fork)"
22. 'for directory stuff
23. CONST ListMAX% = 20
24. COMMON SHARED dirList$()
25. COMMON SHARED DIRCount% 'returns file count if desired
26. DIM memsize%, ptr%, i%, ln%, bktCnt%, ff%, ascNum%
27. DIM instChars$, source$, fileName$, fLine$, code$, char$, inLine$, instruction$, inChar$, yes$
28.  
29. memsize% = 20000
30. DIM memory&(memsize%)
31. instChars$ = "+-<>.,[]" 'valid characters
32. loadDirList "bf*.txt"
33.  
34. WHILE 1
35.     ptr% = 0 'memory pointer
36.     source$ = ""
37.     CLS
38.  
39.     '==================================== file stuff just to access the BF "program"
40.     IF DIRCount% THEN
41.         FOR i% = 1 TO DIRCount%
42.             PRINT i%, dirList$(i%)
43.         NEXT
44.     ELSE
45.         PRINT "Sorry, no bf*.txt files found."
46.         SLEEP
47.         END
48.     END IF
49.     PRINT: INPUT "Enter line number of BF Filename you desire "; ln%
50.     IF ln% < 1 OR ln% > DIRCount% THEN END
51.     fileName$ = dirList$(ln%)
52.  
53.     OPEN fileName$ FOR INPUT AS #1
54.     DO
55.         LINE INPUT #1, fLine$
56.         source$ = source$ + fLine$
57.     LOOP UNTIL EOF(1)
58.     CLOSE #1
59.  
60.     IF LEN(source$) < 1 THEN
61.         PRINT "No source code to BF."
62.         SLEEP
63.         END
64.     END IF
65.  
66.  
67.     '================================================  a check that BF program is correct and brackets balanced
68.     'let's clean the code up, check bracket balance
69.     bktCnt% = 0
70.     code$ = ""
71.     FOR i% = 1 TO LEN(source$)
72.         char$ = MID$(source$, i%, 1)
73.         'check to see if this is a valid instruction character
74.         IF INSTR(instChars$, char$) THEN
75.             code$ = code$ + char$
76.             'count brackets
77.             IF char$ = "[" THEN bktCnt% = bktCnt% + 1
78.             IF char$ = "]" THEN bktCnt% = bktCnt% - 1
79.         ELSE
80.             PRINT "Non BF character found (and ignored): "; char$
81.         END IF
82.     NEXT
83.  
84.     IF bktCnt% THEN 'mismatched brackets
85.         PRINT "Uneven brackets";
86.         SLEEP
87.         END
88.     ELSE
89.         PRINT "Code:": PRINT code$: PRINT: PRINT "Output:"
90.     END IF
91.     'clear last if any
92.     ERASE memory&
93.  
94.     ' ============================================== here is meat and potatoes of translation
95.  
96.     DIM memory&(memsize%) '<<<<<<<<<<<<< here is the array in question, at type % integer works but numbers are neg
97.     ' ====================================================== unsigned itegers ~works too
98.     ' ====================================================== so why not long & integers ????????
99.  
100.     inLine$ = "" 'input buffer  if a comma is used
101.     FOR i% = 1 TO LEN(code$) 'loop through the code
102.         instruction$ = MID$(code$, i%, 1) 'get the instruction we're on
103.         SELECT CASE instruction$
104.             CASE "+" ' +
105.                 memory&(ptr%) = memory&(ptr%) + 1
106.             CASE "-" ' -
107.                 memory&(ptr%) = memory&(ptr%) - 1
108.             CASE "."
109.                 IF memory&(ptr%) < 1 OR memory&(ptr%) > 255 THEN
110.                     'PRINT "?";
111.                     PRINT "[" + LTRIM$(STR$(memory&(ptr%))) + "]";
112.                 ELSE
113.                     PRINT CHR$(memory&(ptr%));
114.                 END IF
115.             CASE "," ' <<<<<    rarely used when playing with coded messages
116.                 IF inLine$ = "" THEN LINE INPUT inLine$ 'buffer input
117.                 inChar$ = LEFT$(inLine$, 1) 'take the first char off the buffer
118.                 inLine$ = MID$(inLine$, 2) 'delete it from the buffer
119.                 memory&(ptr%) = ASC(inChar$) 'use it
120.             CASE ">"
121.                 ptr% = ptr% + 1
122.                 IF ptr% > memsize% THEN
123.                     PRINT "Memory pointer out of range"
124.                     SLEEP
125.                     END
126.                 END IF
127.             CASE "<"
128.                 ptr% = ptr% - 1
129.                 IF ptr% < 0 THEN
130.                     PRINT "Memory pointer out of range"
131.                     SLEEP
132.                     END
133.                 END IF
134.             CASE "["
135.                 IF memory&(ptr%) = 0 THEN
136.                     bktCnt% = 1 'count the bracket we're on
137.                     i% = i% + 1 'move the code pointer to the next char
138.                     WHILE bktCnt% <> 0
139.                         'count nested loops till we find the matching one
140.                         IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
141.                         IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
142.                         i% = i% + 1 'search forward
143.                     WEND
144.                 END IF
145.             CASE "]"
146.                 IF memory&(ptr%) <> 0 THEN
147.                     bktCnt% = -1 'count the bracket we're on
148.                     i% = i% - 1 'move the code pointer back a char
149.                     WHILE bktCnt% <> 0
150.                         'count nested loops till we fine the matching one
151.                         IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
152.                         IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
153.                         i% = i% - 1 'search backwards
154.                     WEND
155.                 END IF
156.             CASE ELSE
157.                 PRINT "[?]";
158.         END SELECT
159.  
160.     NEXT
161.     '======================================================================== end of translation
162.     PRINT: PRINT: INPUT "Press y for yes to do another "; yes$
163.     IF yes$ <> "y" THEN END
164. WEND
165.  
166. ' modified function from Help files
167. '                                          to get a bf program string from a file it is saved in
168. SUB loadDirList (spec$)
169.     DIM ff%, size&
170.     CONST TmpFile$ = "DIR$INF0.INF"
171.     STATIC Ready%, Index%
172.     IF NOT Ready% THEN REDIM dirList$(ListMAX%): Ready% = -1 'DIM array first use
173.     IF spec$ > "" THEN 'get file names when a spec is given
174.         SHELL _HIDE "DIR " + spec$ + " /b > " + TmpFile$
175.         Index% = 0: dirList$(Index%) = "": ff% = FREEFILE
176.         OPEN TmpFile$ FOR APPEND AS #ff%
177.         size& = LOF(ff%)
178.         CLOSE #ff%
179.         IF size& = 0 THEN KILL TmpFile$: EXIT SUB
180.         OPEN TmpFile$ FOR INPUT AS #ff%
181.         DO WHILE NOT EOF(ff%) AND Index% < ListMAX%
182.             Index% = Index% + 1
183.             LINE INPUT #ff%, dirList$(Index%)
184.         LOOP
185.         DIRCount% = Index% 'SHARED variable can return the file count
186.         CLOSE #ff%
187.         KILL TmpFile$
188.     ELSE IF Index% > 0 THEN Index% = Index% - 1 'no spec sends next file name
189.     END IF
190. END SUB
191.  

I am sure there is not some sort of bug here with long type but I am not seeing why it's not working here.

[FellippeHeitor]

Hi bplus,

You pointed out a weird issue coming from the guts of a full project. In all honesty, I didn't even download it cause I'd have to analyze all of the code from the start to begin to understand what it's doing in order to try to figure the issue.

I recommend trying to create a Minimal, Complete, and Verifiable example. A simpler snippet of code in which you could replicate the issue by just changing a data type. Not only that'll provide you with a more focused view of the issue but it may in the end bring you to an answer even before we look into it.

If even after that the mystery remains, it'd be at least easier to spot the faulty bit of code.

An interesting read on the suggested practice can be found at https://stackoverflow.com/help/mcve

[bplus]

OK stripped down version:

Code: QB64: [Select]

1. memsize% = 20000
2. instChars$ = "+-<>.,[]" 'valid characters
3. ptr% = 0 'memory pointer
4. code$ = "++[---------->+<]>.-[++++>---<]>.-[---->+<]>++.---[----->++<]>.-------------.----.+++++++++++.[++>---<]>--.+[----->+<]>+.-------------.++++++++++++.--------.--[--->+<]>-.-[--->++<]>-.++++++++++.+[---->+<]>+++.++++++[->++<]>+.-[------>+<]>-.--[--->+<]>---.-------.-[++>---<]>+.--[->++<]>-.+[--->++<]>+"
5.  
6. DIM memory%(memsize%) '<<<<<<<<<<<<< here is the array in question, at type % integer works but numbers are neg
7. ' ====================================================== unsigned itegers ~works too
8. ' ====================================================== so why not long & integers ????????
9. PRINT "Code translation:"
10. FOR i% = 1 TO LEN(code$) 'loop through the code
11.     instruction$ = MID$(code$, i%, 1) 'get the instruction we're on
12.     SELECT CASE instruction$
13.         CASE "+" ' +
14.             memory%(ptr%) = memory%(ptr%) + 1
15.         CASE "-" ' -
16.             memory%(ptr%) = memory%(ptr%) - 1
17.         CASE "."
18.             IF memory%(ptr%) < 1 OR memory%(ptr%) > 255 THEN
19.                 'PRINT "?";
20.                 PRINT "[" + LTRIM$(STR$(memory%(ptr%))) + "]";
21.             ELSE
22.                 PRINT CHR$(memory%(ptr%));
23.             END IF
24.         CASE ">"
25.             ptr% = ptr% + 1
26.             IF ptr% > memsize% THEN
27.                 PRINT "Memory pointer out of range"
28.                 SLEEP
29.                 END
30.             END IF
31.         CASE "<"
32.             ptr% = ptr% - 1
33.             IF ptr% < 0 THEN
34.                 PRINT "Memory pointer out of range"
35.                 SLEEP
36.                 END
37.             END IF
38.         CASE "["
39.             IF memory%(ptr%) = 0 THEN
40.                 bktCnt% = 1 'count the bracket we're on
41.                 i% = i% + 1 'move the code pointer to the next char
42.                 WHILE bktCnt% <> 0
43.                     'count nested loops till we find the matching one
44.                     IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
45.                     IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
46.                     i% = i% + 1 'search forward
47.                 WEND
48.             END IF
49.         CASE "]"
50.             IF memory%(ptr%) <> 0 THEN
51.                 bktCnt% = -1 'count the bracket we're on
52.                 i% = i% - 1 'move the code pointer back a char
53.                 WHILE bktCnt% <> 0
54.                     'count nested loops till we fine the matching one
55.                     IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
56.                     IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
57.                     i% = i% - 1 'search backwards
58.                 WEND
59.             END IF
60.     END SELECT
61. NEXT
62.  
63.  

[bplus]

One thing is clear! The program that coded "My real name is Mark." Is not the same as the program that coded this example of "Hello World!"

2,793,000 loops for "My real name is Mark." Yikes! and the letter codes are different.

Code: QB64: [Select]

1. memsize% = 20000
2. instChars$ = "+-<>.,[]" 'valid characters
3. ptr% = 0 'memory pointer
4.  
5. printIndex = 1
6. trans$ = "Hello World!"
7. code$ = "++++++++[>++++[>++>+++>+++>+<<<<-]>+>->+>>+[<]<-]>>.>>---.+++++++..+++.>.<<-.>.+++.------.--------.>+.>++.+++."
8. 'trans$ = "My real name is Mark ;"
9. 'code$ = "++[---------->+<]>.-[++++>---<]>.-[---->+<]>++.---[----->++<]>.-------------.----.+++++++++++.[++>---<]>--.+[----->+<]>+.-------------.++++++++++++.--------.--[--->+<]>-.-[--->++<]>-.++++++++++.+[---->+<]>+++.++++++[->++<]>+.-[------>+<]>-.--[--->+<]>---.-------.-[++>---<]>+.--[->++<]>-.+[--->++<]>+"
10.  
11. DIM memory%(memsize%) '<<<<<<<<<<<<< here is the array in question, at type % integer works but numbers are neg
12. ' ====================================================== unsigned itegers ~works too
13. ' ====================================================== so why not long & integers ????????
14. PRINT "Code translation:"
15. FOR i% = 1 TO LEN(code$) 'loop through the code
16.     cnt = cnt + 1
17.     'IF cnt MOD 100000 = 0 THEN PRINT cnt; " ";
18.  
19.     instruction$ = MID$(code$, i%, 1) 'get the instruction we're on
20.     SELECT CASE instruction$
21.         CASE "+" ' +
22.             memory%(ptr%) = memory%(ptr%) + 1
23.         CASE "-" ' -
24.             memory%(ptr%) = memory%(ptr%) - 1
25.         CASE "."
26.             'BEEP
27.             'IF memory%(ptr%) < 1 OR memory%(ptr%) > 255 THEN
28.             PRINT "[" + LTRIM$(STR$(memory%(ptr%))) + "]";
29.               'check the translation
30.             PRINT " = "; MID$(trans$, printIndex, 1)
31.             printIndex = printIndex + 1
32.             'ELSE
33.             'PRINT CHR$(memory%(ptr%));
34.             'END IF
35.         CASE ">"
36.             ptr% = ptr% + 1
37.             IF ptr% > memsize% THEN
38.                 PRINT "Memory pointer out of range"
39.                 SLEEP
40.                 END
41.             END IF
42.         CASE "<"
43.             ptr% = ptr% - 1
44.             IF ptr% < 0 THEN
45.                 PRINT "Memory pointer out of range"
46.                 SLEEP
47.                 END
48.             END IF
49.         CASE "["
50.             IF memory%(ptr%) = 0 THEN
51.                 bktCnt% = 1 'count the bracket we're on
52.                 i% = i% + 1 'move the code pointer to the next char
53.                 WHILE bktCnt% <> 0
54.                     'count nested loops till we find the matching one
55.                     IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
56.                     IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
57.                     i% = i% + 1 'search forward
58.                     IF i% > LEN(code$) THEN PRINT "i% exceeded upper bound of code, goodbye.": END '<<< added boundary check
59.                 WEND
60.             END IF
61.         CASE "]"
62.             IF memory%(ptr%) <> 0 THEN
63.                 bktCnt% = -1 'count the bracket we're on
64.                 i% = i% - 1 'move the code pointer back a char
65.                 WHILE bktCnt% <> 0
66.                     'count nested loops till we fine the matching one
67.                     IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
68.                     IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
69.                     i% = i% - 1 'search backwards
70.                     IF i% < 0 THEN PRINT "i% exceeded lower bound of code, goodbye.": END  '<<< added boundary check
71.                 WEND
72.             END IF
73.     END SELECT
74.  
75. NEXT
76.  
77. PRINT "Loopcount:"; cnt

Could the hanging be a result of taking way, way, way more time to access items in a Long array as compared to an Integer? Array?

[FellippeHeitor]

The program doesn't crash when you use LONG type for the memory() array. It just runs indefinitely because it never manages to close the [] loop.

You see it conclude faster with INTEGER because when the value reaches < -32768 it overflows back to 32767, and runs less until the loop gets closed.

Apparently, brainf*ck requires values to overflow below zero into 255 and above 255 into 0. From the wikipedia article on the language: "In the classic distribution, the cells are of 8-bit size (cells are bytes), and this is still the most common size."

To fix your program (and to properly translate Zeppelin's message), you need to have memory() be of type _UNSIGNED _BYTE:

Code: QB64: [Select]

1. OPTION _EXPLICIT
2. DIM memsize%, instChars$, ptr%, code$
3. DIM r AS INTEGER, c AS INTEGER
4. DIM i%, instruction$
5. DIM bktCnt%
6.  
7. memsize% = 20000
8. instChars$ = "+-<>.,[]" 'valid characters
9. ptr% = 0 'memory pointer
10. code$ = "++[---------->+<]>.-[++++>---<]>.-[---->+<]>++.---[----->++<]>.-------------.----.+++++++++++.[++>---<]>--.+[----->+<]>+.-------------.++++++++++++.--------.--[--->+<]>-.-[--->++<]>-.++++++++++.+[---->+<]>+++.++++++[->++<]>+.-[------>+<]>-.--[--->+<]>---.-------.-[++>---<]>+.--[->++<]>-.+[--->++<]>+"
11.  
12. DIM memory(memsize%) AS _UNSIGNED _BYTE 'fixed by Fellippe
13.  
14. PRINT "Code translation:"
15. r = CSRLIN
16. c = POS(0)
17. FOR i% = 1 TO LEN(code$) 'loop through the code
18.     instruction$ = MID$(code$, i%, 1) 'get the instruction we're on
19.     LOCATE 1, 30
20.     PRINT "i%="; i%, "ptr%="; ptr%, memory(ptr%)
21.     SELECT CASE instruction$
22.         CASE "+" ' +
23.             memory(ptr%) = memory(ptr%) + 1
24.         CASE "-" ' -
25.             memory(ptr%) = memory(ptr%) - 1
26.         CASE "."
27.             LOCATE r, c
28.             IF memory(ptr%) < 1 OR memory(ptr%) > 255 THEN
29.                 'PRINT "?";
30.                 PRINT "[" + LTRIM$(STR$(memory(ptr%))) + "]";
31.             ELSE
32.                 PRINT CHR$(memory(ptr%));
33.             END IF
34.             r = CSRLIN
35.             c = POS(0)
36.         CASE ">"
37.             ptr% = ptr% + 1
38.             IF ptr% > memsize% THEN
39.                 PRINT "Memory pointer out of range"
40.                 SLEEP
41.                 END
42.             END IF
43.         CASE "<"
44.             ptr% = ptr% - 1
45.             IF ptr% < 0 THEN
46.                 PRINT "Memory pointer out of range"
47.                 SLEEP
48.                 END
49.             END IF
50.         CASE "["
51.             IF memory(ptr%) = 0 THEN
52.                 bktCnt% = 1 'count the bracket we're on
53.                 i% = i% + 1 'move the code pointer to the next char
54.                 WHILE bktCnt% <> 0
55.                     'count nested loops till we find the matching one
56.                     IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
57.                     IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
58.                     i% = i% + 1 'search forward
59.                 WEND
60.             END IF
61.         CASE "]"
62.             IF memory(ptr%) <> 0 THEN
63.                 bktCnt% = -1 'count the bracket we're on
64.                 i% = i% - 1 'move the code pointer back a char
65.                 WHILE bktCnt% <> 0
66.                     'count nested loops till we find the matching one
67.                     IF MID$(code$, i%, 1) = "]" THEN bktCnt% = bktCnt% - 1
68.                     IF MID$(code$, i%, 1) = "[" THEN bktCnt% = bktCnt% + 1
69.                     i% = i% - 1 'search backwards
70.                 WEND
71.             END IF
72.     END SELECT
73. NEXT
74.  

Especially because that'll keep the result inside the ASCII realm.

BTW: I got to see how the program was going wacko by monitoring the values on screen. You'll see the print statements I left behind in the code above.

[bplus]

Thank you Fellippe for checking this out. Thank you for your time and clear explanation.

I don't recall ever seeing a Type used like that, very interesting! That may come in handy.

[FellippeHeitor]

In QBasic you'd get an error. In QB64 we avoid the error and the value gets reset.