Author Topic: Buggy code, needs help (Read 3540 times)

Larryrl · « **on:** December 02, 2021, 01:20:00 pm »

I have a program called switch which is going to be a programming language of an esoteric nature. I hope to make it worl like a subset of basic, if I can fix this ghost bug. The code is as follows:

Code: QB64: [Select]

' This idea uses switches that have 3 states either 
' up (a number), down (another number), or off(middle position)
'
' This programming language does not use a tape, or an array
' of cells. Instead, it uses an internal array of switches.
'
' the first switch is #0 which represents the number 0
' the second switch is is #1 which represents either a 1 or 3
' the third switch is is #2 which represents either a 2 or 4
' the fourth switch is is #3 which represents either a 5 or 7
' the fifth switch is is #4 which represents either a 6 or 8
' the sixth switch is is #5 which represents either a 9 or 11
' the seventh switch is is #6 which represents either a 10 or 12
' the eighth switch is is #7 which represents either a 13 or 15
'
'
' there is no 14 so the programmer would have to use math using
' various numbers to get to 14, 7+7, 15-1, 28/2, 7*2 etc
'
' In addition to these switches, there are 4 special memory areas
' which are used to hold values resluting from addition, subtraction,
' multiplication or division. They can be used temporarily and erased.
'
' There is a pointer which points to a numbered switch from 0 to 8
' all math functions are done by moving the pointer between the switches
' to point to a specific numbered switch. Then you simply store the number
' represented by the position of the numbered switch whether up down. Switches in the
' middle or off position do not contain a number.  By adding, subtracting, multiplying
' or dividing numbers from switches, you arrive at a value that can then be used for
' output or other things.
'
' The syntax of switch resembles assembly language.
'
' mu or MU moves the pointer up one position. If at 1, it will wrap around back to 7
' md or MD moves the pointer down one position. If at 7, it will wrap around to 1
' a or A starts the addition process.
' s or S starts the subtraction process.
' m or M starts the multiplication process.
' d or D starts the division process.
' ea or EA stops the addition process and wipes the result from memory
' es or ES stops the subtraction process and wipes the result from memory
' em or EM stops the multiplication process and wipes the result from memory
' ed or ED stops the division process and wipes the result from memory
' oa or OA will output the value in the addition memory.
' os or OS will output the value in the subtraction memory.
' om or OM will output the value in the multiplication memory.
' od or OD will output the value in the division memory.
' on or ON will output a new line.
'
' Each consecutive a,A,s,S,m,M,d or D command continues the math process.
' a4 adds 4 to the position in memory another a4 makes the value 8
' It works like this so long as you do not use any ea,EA,es,ES,em,EM,ed or ED
' commands. If you have a4, then ea followed by another a4, then the result will 
' be 4 because you will have erased the first 4. 
'
' You can output ascii characters by creating totals that equal to the ascii
' decimal value of the letter to be outputted. If you want a to output a
' blank line, you must use the on or ON command.
'
' gi or GI tells the interpreter to get input from the user.
' If you want the input to be specific, then you can use the
' math and output commands to ask the user a question.   
'
' In addition to the memory storage place for the 4 different math functions,
' there are four more that can store data. These can be used as variables,
' however they do not get a name. You can word with them using the following:
'
' s0a or S0A stores the value of "a" in storage unit 0
' s0s or S0S stores the value of "s" in storage unit 0
' s0m or S0M stores the value of "m" in storage unit 0
' s0d or S0D stores the value of "d" in storage unit 0
' s1a or S1A stores the value of "a" in storage unit 1
' s1s or S1S stores the value of "s" in storage unit 1
' s1m or S1M stores the value of "m" in storage unit 1
' s1d or S1D stores the value of "d" in storage unit 1
' s2a or S2A stores the value of "a" in storage unit 2
' s2s or S2S stores the value of "s" in storage unit 2
' s2m or S2M stores the value of "m" in storage unit 2
' s2d or S2D stores the value of "d" in storage unit 2
' s3a or S3A stores the value of "a" in storage unit 3
' s3s or S3S stores the value of "s" in storage unit 3
' s3m or S3M stores the value of "m" in storage unit 3
' s3d or S3D stores the value of "d" in storage unit 3
'
' This allows for certain games to be created. Simple though they may be,
' they are still fun. They are considered simple in that they work with
' the 4 storage units that are available.
'
' fu or FU flips the switch at the pointer location to up
' fd or FD flips the switch at the pointer location to down
' fo or FO turns on the switch at the pointer location
' fx or FX turns off the switch at the pointer location
'
' Begin the inteerpreter
'
'_fullscreen
dim shared switch$(7,3),x,tlns,lnctr,a,s,m,d,u0,u1,u2,u3,p$(20000),ptr
lnctr=1:ptr=0
switch$(0,1)="0":switch$(0,2)="0":switch$(0,3)="up"
switch$(1,1)="1":switch$(1,2)="3":switch$(1,3)="up"
switch$(2,1)="2":switch$(2,2)="4":switch$(2,3)="up"
switch$(3,1)="5":switch$(3,2)="7":switch$(3,3)="up"
switch$(4,1)="6":switch$(4,2)="8":switch$(4,3)="up"
switch$(5,1)="9":switch$(5,2)="11":switch$(5,3)="up"
switch$(6,1)="10":switch$(6,2)="12":switch$(6,3)="up"
switch$(7,1)="13":switch$(7,2)="15":switch$(7,3)="up"
cls
' Open a file to run
filename$=command$
if filename$="" then filename$="\switch\hello world.switch"
x=0
open filename$ for input as #1
while not eof(1)
x=x+1
line input #1,p$(x)
wend
close #1
tlns=x
'
' Parse commands
if p$(lnctr)="mu" then gosub 8010:lnctr=lnctr+1:goto 1060
if p$(lnctr)="md" then gosub 8040:lnctr=lnctr+1:goto 1060
if p$(lnctr)="a"  then gosub 8070:lnctr=lnctr+1:goto 1060
if p$(lnctr)="s"  then gosub 8110 :lnctr=lnctr+1:goto 1060
if p$(lnctr)="m"  then gosub 8150:lnctr=lnctr+1:goto 1060
if p$(lnctr)="d"  then gosub 8190 :lnctr=lnctr+1:goto 1060
if p$(lnctr)="ea" then gosub 8240 :lnctr=lnctr+1:goto 1060
if p$(lnctr)="es" then gosub 8270:lnctr=lnctr+1:goto 1060
if p$(lnctr)="em" then gosub 8290:lnctr=lnctr+1:goto 1060
if p$(lnctr)="ed" then gosub 8330:lnctr=lnctr+1:goto 1060
if p$(lnctr)="oa" then gosub 8360:lnctr=lnctr+1:goto 1060
if p$(lnctr)="os" then gosub 8390:lnctr=lnctr+1:goto 1060
if p$(lnctr)="om" then gosub 8420:lnctr=lnctr+1:goto 1060
if p$(lnctr)="od" then gosub 8450:lnctr=lnctr+1:goto 1060
if p$(lnctr)="on" then gosub 8480:lnctr=lnctr+1:goto 1060
if p$(lnctr)="oca" then gosub 9090:lnctr=lnctr+1:goto 1060
if p$(lnctr)="ocs" then gosub 9110:lnctr=lnctr+1:goto 1060
if p$(lnctr)="ocm" then gosub 9130:lnctr=lnctr+1:goto 1060
if p$(lnctr)="ocd" then gosub 9150:lnctr=lnctr+1:goto 1060
if p$(lnctr)="s0a" then gosub 8510:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s0s" then gosub 8540:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s0m" then gosub 8570:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s0d" then gosub 8600:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s1a" then gosub 8630:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s1s" then gosub 8660:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s1m" then gosub 8690:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s1d" then gosub 8720:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s2a" then gosub 8750:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s2s" then gosub 8780:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s2m" then gosub 8810:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s2d" then gosub 8840:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s3a" then gosub 8870:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s3s" then gosub 8900:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s3m" then gosub 8930:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="s3d" then gosub 8960:lnctr=lnctr+1:goto 1060 
if p$(lnctr)="//" then lnctr=lnctr+1:goto 1060
if left$(p$(lnctr),2)="//" then lnctr=lnctr+1:goto 1060
if left$(p$(lnctr),3)="// " then lnctr=lnctr+1:goto 1060
if p$(lnctr)="fu" then gosub 8990:lnctr=lnctr+1:goto 1060
if p$(lnctr)="fd" then gosub 9020:lnctr=lnctr+1:goto 1060
if p$(lnctr)="ep" then print:print "Program ";filename$;" ended with no errors.":end
if p$(lnctr)="rp" then ptr=0:lnctr=lnctr+1:goto 1060
if p$(lnctr)="" then lnctr=lnctr+1:goto 1060
if p$(lnctr)="oo" then print chr$(32);:lnctr=lnctr+1:goto 1060
if p$(lnctr)="!" then gosub 9170:lnctr=lnctr+1:goto 1060
 
print:print "Illegal / unknown command in line ";lnctr:end
 
if ptr>0 then ptr=ptr-1
if ptr=0 then ptr=7
return
 
if ptr<7 then ptr=ptr+1
if ptr=7 then ptr=1
return
 
 
if switch$(ptr,3)="up" then a=a+val(switch$(ptr,1)) else a=a+val(switch$(ptr,2))
return
 
if switch$(ptr,3)="up" then s=s-val(switch$(ptr,1)) else s=s-val(switch$(ptr,2))
return
 
if switch$(ptr,3)="up" then m=m*val(switch$(ptr,1)) else m=m*val(switch$(ptr,2))
return
 
if switch$(ptr,3)="up" and d>0 and ptr=0 then print:print "Illegal attempt to divide by 0 in line ";lnctr:end
if switch$(ptr,3)="up" then d=d/val(switch$(ptr,1)) else d=d/val(switch$(ptr,2))
return
 
a=0
return
 
s=0
return
 
m=0
return
 
d=0
return
 
print ltrim$(str$(a));
return
 
print ltrim$(str$(s));
return
 
print ltrim$(str$(m));
return
 
print ltrim$(str$(d));
return
 
print 
return
 
u0=a
return
 
u0=s
return
 
u0=m
return
 
u0=d
return
 
u1=a
return
 
u1=s
return
 
u1=m
return
 
u1=d
return
 
u2=a
return
 
u2=s
return
 
u2=m
return
 
u2=d
return
 
u3=a
return
 
u3=s
return
 
u3=m
return
 
u3=d
return
 
switch$(ptr,3)="up"
return
 
switch$(ptr,3)="dn"
return
 
print chr$(a);
return
 
print chr$(s);
return
 
print chr$(m);
return
 
print chr$(d);
return
 
print:print "The pointer is pointing to switch ";ptr;". Which is in the ";switch$(ptr,3);" Position."
print "A = ";a;" S = ";s;" M = ";m;" D = ";d:print:return
 
 

This is the switch source code the intyerpreter runs that causes the bug.

Code: QB64: [Select]

// hello world. switch
//
// This is the famous first program hello world written in the interpreted lan guage switch.
// Each command must be on a seperate line.
//
// move the pointer to 2nd switch which is 2 up or 4 down
md
md
// flip the switch to the up position
fu
// add it's value to the memory
a
// move the pointer to the 7th switch which is 10 up or 12 down
md
md
md
md
// flip the switch to the up position 
fu
// add the value of that switch 7 times to what is already in the memory
a
a
a
a
a
a
a
// print the character represented by the ascii decimal value
oca
ea
rp
md
md
md
md
md
md
fu
a
a
a
a
a
a
mu
fu
a
oca
rp
ea
md
md
md
md
md
md
a
a
a
a
a
a
a
mu
mu
fu
a
oca
oca
mu
mu
mu
fu
a
a
a
oca
ea
rp
md
md
md
md
md
md
fu
a
mu
mu
mu
mu
mu
fu
a
oca
ea
rp
// down to here it prints hello
//
// this part is here to test to see why it prints HELLO on line 1, then the next thing printed prints over the H, on the same row.
// if you print 4 more things, it will totally write over HELLO, instead of moving over to the next column after the O to print.
// The on command below makes it print a newline, and only then will the next printed character or value print right.
// The problem is, nothing tells it where to print. Except for the on command, they're  all just print commands ending in a semicolon 
// which in basic means to stay on the same row and not move to a new row. That is why the overprinting of the already printed
// positions is so odd. The oo command is supposed to print a space, but if  it comes after the HELLO, then it also writes over the 
// already printed text.    
on
md
fu
a
oca
ea
rp
// end program
ep

Run the interpreter and it will automatically load this hello world source code. Run it as is, then run it without the on command near the end, and see what happens. As long as the "on", command for a newline is present it works ok, but if I do not want a newline, and I want the smileyface chr$(1) to show up after the hello, it prints over the H, that was already printed. I have no locate commands anywhere. I only print with ; after, or just print for the newline. I need to find out what is making it revert back to column 1 since the qb64 compiler gives no errors, and it runs.

bplus · « **Reply #1 on:** December 02, 2021, 03:48:11 pm »

Check this out for Chr$(1)

http://qb64.org/wiki/CONTROLCHR

bplus · « **Reply #2 on:** December 02, 2021, 04:45:51 pm »

Yeah it fixes your problem but _ControlChr OFF has made another symbol appear:
[ You are not allowed to view this attachment ]

Larryrl · « **Reply #3 on:** December 02, 2021, 06:04:16 pm »

Yes I see the extra character. It's interesting. I'm still trying to figure out regardless of the control charactr or it's qb64 command, what causes it to go back to the left edge of the screen. It's acting like the screen only has 5 colums total.

Larryrl · « **Reply #4 on:** December 02, 2021, 06:08:48 pm »

Quote from: bplus on December 02, 2021, 03:48:11 pm

Check this out for Chr$(1)

http://qb64.org/wiki/CONTROLCHR

The contreol character I do not feel is the issue. Thank you for your help, and will keep that command in mind for when I might need it. I used it now and it showed the other character before the smiley. The problem is nothing I print to the screen after the hello prints except from the left side of the screen again. Nothing will print after the hello. Itg won't even print a space. I can print a newline, and then it will print on the next line.

bplus · « **Reply #5 on:** December 02, 2021, 06:37:49 pm »

@Larryrl

It looks like a Chr$(11) is being snuck into your code program or interpreter:
Press spacebar when you see "ZZZ" the first Z gets replaced by "X" when the next item is printed, same thing you were getting when ON removed from interpreted program.

Code: QB64: [Select]

Print "ZZZ";
Sleep
Print Chr$(11);
Print "X";

The _ControlChr OFF command turned off that effect on Chr$(11), allot of Control Chars mess with printing that's why there is this command. Chr$(9) prints a tab, Chr$(13) a Carriage Return... (next line) like Chr$(10).

Larryrl · « **Reply #6 on:** December 02, 2021, 07:25:29 pm »

Tried that, but it still does not explain what causes it to start back over at column 1 when after each print statememt I have the ;

Larryrl · « **Reply #7 on:** December 02, 2021, 07:47:03 pm »

Fixed my own problem. The math generated by the source code hello world.switch, was adding up to 11 and causing a control character to go nuts. It's fixed now.

bplus · « **Reply #8 on:** December 02, 2021, 08:55:36 pm »

Quote from: Larryrl on December 02, 2021, 07:47:03 pm

Fixed my own problem. The math generated by the source code hello world.switch, was adding up to 11 and causing a control character to go nuts. It's fixed now.

Just what I said in Reply #5 ;-))

Quote

It looks like a Chr$(11) is being snuck into your code program or interpreter:

News:

Author Topic: Buggy code, needs help (Read 3540 times)

Larryrl

Buggy code, needs help

bplus

Re: Buggy code, needs help

bplus

Re: Buggy code, needs help

Larryrl

Re: Buggy code, needs help

Larryrl

Re: Buggy code, needs help

bplus

Re: Buggy code, needs help

Larryrl

Re: Buggy code, needs help

Larryrl

Re: Buggy code, needs help

bplus

Re: Buggy code, needs help