Text Only | Text with Attachments

QB64.org Forum

Active Forums => QB64 Discussion => Topic started by: bplus on September 11, 2018, 12:39:31 am

Title: Program hangs unexpectedly with Type change
Post by: bplus on September 11, 2018, 12:39:31 am
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
Title: Re: Program hangs unexpectedly with Type change
Post by: bplus on September 11, 2018, 02:21:26 pm
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]
  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.  
  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
  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
  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.
Title: Re: Program hangs unexpectedly with Type change
Post by: FellippeHeitor on September 11, 2018, 02:35:41 pm
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
Title: Re: Program hangs unexpectedly with Type change
Post by: bplus on September 11, 2018, 03:06:59 pm
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
  62.  
  63.  
Title: Re: Program hangs unexpectedly with Type change
Post by: bplus on September 11, 2018, 04:41:10 pm
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.  
  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?
Title: Re: Program hangs unexpectedly with Type change
Post by: FellippeHeitor on September 11, 2018, 05:02:52 pm
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]
  2. DIM memsize%, instChars$, ptr%, code$
  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
  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.
Title: Re: Program hangs unexpectedly with Type change
Post by: bplus on September 11, 2018, 05:52:29 pm
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.
Title: Re: Program hangs unexpectedly with Type change
Post by: FellippeHeitor on September 11, 2018, 06:02:09 pm
In QBasic you'd get an error. In QB64 we avoid the error and the value gets reset.
Text Only | Text with Attachments