                       (TOKIWA BASIC Compiler)



             (Beginner's All-purpose Symbolic Instruction Code)



                IABS(), IVAL(), INP(), DINP(), PEEK(),DPEEK()
                POS(), LOC(), CINT(), ASC(), INSTR(), LEN()
                FRE(), USR(), CALL_name()

                ABS(), SGN(), RND(), INT(), FIX(), SQR(), SIN()
                COS(), TAN(), ASN(), ACS(), ATN(), EXP(), LOG()
                LGT(), HSN(), HCS(), HTN(), FN_name(), FLOAT()
                VAL(), PI, EE

                CHR$(), RIGHT$(), MID$(), LEFT$(), STR$(), INKEY$



    *** Sample Program ***

    for n=0 to 10
      print n;
    next n
    end





    input x
    print "square="; x*x, "square root="; sqr(x)
    end



THEN IF, ELSE IF    THENIF, ELSEIF
FOR, IFX,    FOR

-32768 to 32767


1234H   C&1234

ASCII CODE   'A'   'AB'



2.9387359E-39  to 1.7014118E+38   over normalize    80H X(Bias)

DPEEK(LOC(A$))

INTEGER
DEFINT
INTEGER A, KING, ZEBRA
DEFINT I-N


REAL        A, A0, ABCDEF, ABC56

CHARACTER        A$, A0$, ABCDEF$, ABC56$



abcdef, ABCDEF, Abcdef


        INTEGER I,J,K
        REAL X,Y,Z                  <--

        K=I+J                       <--
        Z=X-Y                       <--

OR, XOR, AND

        INTEGER I,J,K
        K=I*J
        K=I/J
        K=I MOD J
        K=I AND J



  IF     =, >, >=, <, <=, <>

        IF I>=J THEN K=1 ELSE K=0


        A$="abcde"
        B$=LEFT$(A$,3)+"xyz"




      INTEGER K,M,N
      K=M+N
      N=DPEEK(M)-1
      K=M*N
      K=M/N


INT i
X0=1.3
INTEGER X
X=X0*4+1                <-- X0
X=CINT(X0*4)+1          <-- X0
CINT  (  )



OR, XOR, AND

    INTEGER X,Y,Z
    X=Y OR Z
    Y=Z XOR X
    Z=(X+Y) AND &FFF0

MOD

    INTEGER X,Y,Z
    X=Y MOD Z

            MOD > /, * > -, + > AND, XOR > OR


      X=Y+Z
      D=A+B*C
      Y=SIN(X)+Z


FLOAT
     INTEGER X,Y,Z
      Y0=X+Y-Z
      Y0=FLOAT(X+Y-Z)
      X0=FLOAT(PEEK(100)*2)



 C(X0+Y0)*(X0+Y0)         C(X0+Y0)^2


      C$=A$+B$+"abc"

      B$=A$

      B$=A$+""


          PEEK(), POKE



      A$="XYZ"
      POKE DPEEK(LOC(A$)),'A'

LOC(A$)  DPEEK(LOC(A$))

 POKE 'A',1


        INTEGER CNTR, CONST
        DIM CNTR(100)

CNTR
CONST
DIM
INTEGER
INTEGER CNTR 12, CONST 25


        REAL XYZ, ABC
        DIM XYZ(50,10)
        REAL XYZ 1.23, ABC 2.56


 CHARACTER

        CHARACTER STRING, TEST
        DIM STRING(10)

        INPUT    READ






        SUBROUTINE TEST
          INTEGER CNTR
          REAL XYZ
         CCNTR  XYZ




        SUBROUTINE TEST(I, XYZ, ABC$)
          INTEGER I
          REAL XYZ



        _CONST    1234
        _PORT     &80
        _SIZE     100*2+1

        INTEGER N, X, Y
        DIM Y(_SIZE)

        N=DPEEK(_CONST)+_SIZE
        X=INP(_PORT)



        INTEGER A
        REAL X0
        DIM A(9), X0(20, 30), TEST$(100)

      CA(0), A(1)  A(9)


X0(0,0), X0(1,0), X0(2,0), X0(3,0)
X0(0,1), X0(1,1), X0(2,1), X0(3,1)
TEST$(0), TEST$(1), TEST$(3)


  DIM
64 kbytes    86 CPU


        INTEGER B
        REAL Y0
        DIMX B(30000), Y0(200, 200)




  SWITCH `CASE, FOR `NEXT, WHILE `WEND, REPEAT `UNTIL ' BREAK


        INTEGER N
        FOR N=0 TO 10
          IF N=5 THEN BREAK
          PRINT N;
        NEXT N
        END


        INTEGER N
        FOR N=0 TO 10
          IF N=5 THEN CONTINUE
          PRINT N;
        NEXT N
        END



 STOP
 IF X<0 THEN STOP


END


REM
REM This is a remark
*   This is a remark also


KILL

  FOR       NEXT       TO    STEP


        INTEGER N
        FOR N=10 TO -10 STEP -1
          PRINT N;
        NEXT N
        END




        INTEGER N
        N=0
        WHILE N<=10
          PRINT N;
          N=N+1
        WEND
        END



        INTEGER N
        N=0
        REPEAT
          PRINT N;
          N=N+1
        UNTIL N>10
        END


    IF A<0 THEN N=1: PRINT "M" ELSE P=1: PRINT "P"



        IF A<0 THEN
          N=1
          PRINT "M"
        ELSE
          P=1
          PRINT "P"
        ENDIF


    IF A>0 THEN IF B>0 THEN PRINT "++" ELSE PRINT "+-" ELSE PRINT "-?"



        IF A>0 THEN
          IF B>0 THEN
            PRINT "++"
          ELSE
            PRINT "+-"
          ENDIF
        ELSE
          PRINT "-?"
        ENDIF



    IF A>0 THEN 200
    IF A>0 THEN GOTO 200



    IF (A>B) AND (C>D) THEN X=A+C


    IF A>B THEN IF C>D THEN X=A+C


    IF (A>B) OR (C>D) THEN X=A+C

                             B

        IF A>B ELSE IF C>D ELSE 10
           X=A+C
        10




        SWITCH
          CASE
                   [ `
            BREAK
          CASE
                   [ `
            BREAK
          DEFAULT
                   [ `
            BREAK
        SWEND



        SWITCH ASC(A$)
          CASE 'A'
            PRINT "by A"

          CASE 'B'
            PRINT "by B"
            BREAK

          DEFAULT
            PRINT "others"
            BREAK
        SWEND



        SWITCH A$
          CASE "abc"
            PRINT "by abc"
            BREAK

          CASE "def"
            PRINT "by def"
            BREAK

          DEFAULT
            PRINT "others"
            BREAK
        SWEND



 GOTO  NAME
GOTO NAME
RETURN
GOSUB 100
CALL
GOTO
ON GOTO


        INPUT A$
        ON INSTR("CDEP", A$) GOTO  CALC,  DISPLAY,  END_PRG,  PRINT_OUT


        INPUT A$
        ON INSTR("CDEP", A$) GOSUB  CALC,  DISPLAY,  PRINT_OUT

 ON ERROR GOTO
ON ERROR GOSUB

ON EOF GOTO
ON EOF GOSUB

 ON KEY GOTO
 ON KEY GOSUB



INTEGER X,Y
REAL X0
CALL TEST(10, 3.0, " e X g", X, X0, X$, X-Y j


DUMMY
SUBROUTINE
FORTRAN
call by value
call by reference
offset address



        CALL name( ARRAY1( ), ARRAY2( ))
         CARRAY1( )      ARRAY2( )


 USER
       P            AX
       Q            BX, AX
       R            CX ,BX, AX
       S            DX, CX, BX, AX

 RET


    10  INPUT "x,y"; X, Y
        PRINT "X+Y="; X+Y
        GOTO 10
        END


    10  INPUT A$, B$
        PRINT A$; B$
        GOTO 10
        END

   OPEN
  READ      DATA

        OPEN "DTEST"
        READ A$,B,C0
        PRINT A$
        PRINT B,C0
        END

LINE READ
LINE INPUT


        OPEN "DTEST"
        LINE READ A$
        PRINT A$
        END

WRITE#
READ#
CLOSE


        INTEGER ARY
        DIM ARY(25000)
        INPUT "File name:", A$
        OPEN# A$
        READ# ARY
        PRINT !; "bytes"
        END


        PRINT 1.2345, 678.9+1.1, "ABCDEF", "test"
        PRINT 1.2345; 678.9+1.1; "ABCDEF"; "test"
        END

         1.2345          690            ABCDEF  test
         1.2345  690 ABCDEFtest



      PRINT #1 "test"
      PRINT "line out"
      END


        FOR N=0 TO 10
          X0=N/10
          PRINT %5.1 X0; %12.6 SIN(X0); COS(X0)
        NEXT N
        END





        PRINT PEEK(12)+3

        PRINT SIN(XYZ)+0.1


    (1) PRINT 1+SIN(0.1)                     1.0998334
    (2) PRINT 5/3.0                          1.6666667
    (3) PRINT 5/3                            1
    (4) PRINT CINT(5/3)
    (5) PRINT PEEK(12)+3.1

FLOAT(PEEK(12))+3.1


        SUBROUTINE TABSTRING(N)
          INTEGER N
          WHILE PEEK(N)<>0
            IF !=9 THEN PRINT, ELSE PRINT CHR$(!);
            N=N+1
          WEND
          PRINT
          RETURN
        SUBEND


WIDTH #
WIDTH #0 72
PRINT "abcdefg"; TAB(20); "xyz"
LOCATE




        INTEGER N,X
        REAL Y0
        DIM X(9), Y0(9)
        FOR N=0 TO 9
          X(N)=N
          Y0(N)=N/100
        NEXT N

        OPEN# "ARYTEST"
        WRITE# X, Y0
        END





        INTEGER A
        REAL B0
        A=2
        B0=1/3
        CALL DISPLAY(A, B0)
        STOP




        SUBROUTINE DISPLAY(X, YZ)
          INTEGER X
          REAL YZ
          PRINT X, YZ
          RETURN
        SUBEND

        END





        INTEGER A
        REAL B0
        A=12
        B0=5.678
        CALL TEST(A, B0)
        PRINT A, B0
        STOP



        SUBROUTINE TEST(X, Y0)
          INTEGER X
          REAL Y0
          PRINT X, Y0
          X=34
          Y0=1.234
          PRINT X, Y0
          RETURN
        SUBEND
        END



        INTEGER A
        A=12
        CALL TEST(LOC(A))
        PRINT A
        STOP



        SUBROUTINE TEST(X)
          INTEGER X
          PRINT %I DPEEK(X)
          DPOKE X, 56
          RETURN
        SUBEND
        END



        INTEGER X
        REAL Y0
        DIM X(10), Y0(5,5)
        CALL TEST(X(), Y0())


        SUBROUTINE TEST(A(10), B0(5, 5))




        REAL A0
        A0=2.0
        PRINT FN_SEN(A0)
        STOP

        FUNCTION SEN(YZ)
          REAL YZ
          RETURN YZ*1000.0
        FNEND
        END



 SWAP

WAIT



 XOR
  WAIT &12, &80

        LOOP0: IN    AL,12H
               AND   AL,80H
               JZ    LOOP0

XOR AL,0

DOUT

POKE

        POKE &A000, 3

        X=&A000                 <-----  Z O
        POKE X; ADDRESS, DATA   <----- eseg

POKE; ADDRESS, DATA

  RND(X)
 RANDOMIZE
CLOCK
SEED
    RANDOMIZE &5A5A

DPOKE



        LOCATE X, Y

0<= X <80 j B
0<= Y <24 j B

(2) TXCLS

 TXCLS

(3) BEEP

 BEEP
 CURSOR
 BOTTOM
RDELETE



IABS()
IVAL()
INP()
OUT

DINP()


        INTEGER X,ADDRESS
        X=PEEK(ADDRESS)



        INTEGER X,Y,ADDRESS
        X=&A000               <-----  Z O     g ieseg j   w
        Y=PEEK(X; ADDRESS)    <----- eseg               [ Q

 POS()

 POS
PRINT
POS()
LOC()
VARPTR()


        DPEEK(LOC(XY( )))

ASC()

        INTEGER N, X
        N=2
        A$="abcdefg"
        X=INSTR(N,A$,"de")

        A$  "de"                   Q         {   B         C4            B

FRE()
 USR()


                1               AX
                2               BX, AX
                3               CX, BX, AX
                4               DX, CX, BX, AX

 CALL_name()




        X=CALL_name(Y)
        STOP


        SUBROUTINE name(Y)
          INTEGER Y
          RETURN Y+3
        SUBEND


 LGT()

 FN_name()


  FUNCTION
 FN_

FUNCTION

    PI         3.14159265
 EE            2.71828183


(1) CHR$()

(2) RIGHT$()

A$=RIGHT$("abcdefg", 3)

(3) MID$()

         A$=MID$("abcdefg", 3, 2)

(4) LEFT$()

        A$=LEFT$("abcdefg", 3)

(5) STR$()
STR$(%n.m X0)

(6) INKEY$
        10 IF INKEY$="" THEN 10



    /byte &b4, 8        --->  mov ah,8                  /mov ah,8
    /byte &cd, &21      --->  int 21h                   /int &21
    /byte &b4, 0        --->  mov ah,0                  /mov ah,0
    value = n           --->       ^     n              /mov n,ax
    print %4h !         --->  ax   W X ^     e   P U i     o
