basic11.sdi

proteus 仿真实例

,,, *}
,,, *
,,, */***** STOP *****/
,,, *
,,, *xstop()
,,, *{
,,, * *tbufptr++=STOPTOK;    /* put STOP token in buffer */
,,, * return;
,,, *}
,,, *
,,, */***** END *****/
,,, *
,,, *xend()
,,, *{
,,, * *tbufptr++=ENDTOK;     /* put end token in buffer */
,,, * return;
,,, *}
,,, *
,,, */***** TRON *****/
,,, *
,,, *xtron()
,,, *{
,,, * *tbufptr++=TRONTOK;    /* put TRON token in buffer */
,,, * return;
,,, *}
,,, *
,,, */***** TROFF *****/
,,, *
,,, *xtroff()
,,, *{
,,, * *tbufptr++=TROFFTOK;   /* put TROFF token in buffer */
,,, * return;
,,, *}
,,, *
,,, XRETURN:        EQU    *
,,, XSTOP:  EQU    *
,,, XEND:   EQU    *
,,, XTRON:  EQU    *
,,, XTROFF: EQU    *
,,, XRESTORE:       EQU    *
,,, XENDWH: EQU    *
,,, XRETI:  EQU    *
,,, XSLEEP: EQU    *
,,, XRTIME: EQU    *
E3FB,39,,         RTS                ; NULL FUNCTIONS BECAUSE TOKEN PLACEMENT IS DONE IN
,,, *                            ; XLATE FUNCTION.
,,, *
,,,
,,, */***** REM *****/
,,, *
,,, *xrem()
,,, *{
,,, * char c;
,,, * *tbufptr++=REMTOK;     /* put rem token in buffer */
,,, * while(1)
,,, * {
,,, *  if((c=*ibufptr)==EOL) break;
,,, *  *tbufptr++=c;
,,, *  ++ibufptr;
,,, * }
,,, * return;
,,, *}
,,, *
,,, *
,,, */***** xdata() *****/
,,, *
,,, *xdata()
,,, *{
,,, * char c;
,,, * *tbufptr++=DATATOK;            /* put DATA token in buffer */
,,, * while((c=*ibufptr)!=EOL)
,,, * {
,,, *  if(c==',') *tbufptr++=COMMATOK;
,,, *  else *tbufptr++=c;
,,, *  ++ibufptr;
,,, * }
,,, * return;
,,, *}
,,, *
,,, XDATA:  EQU    *
,,, XREM:   EQU    *
E3FC,DE 02,,         LDX    TBUFPTR      ; GET POINTER TO TOKEN BUFFER.
E3FE,3C,,         PSHX                ; SAVE IT. (POINTER TO LENGTH OF REM OR DATA)
E3FF,86 00,,         LDAA   #0           ; SAVE A BYTE FOR THE LENGTH.
E401,8D D4,,         BSR    PUTTOK
E403,C6 02,,         LDAB   #2           ; INITALIZE LENGTH  TO 2 (INCLUDES LENGTH & EOL.
E405,8D BC,XREM1:, XREM1:  BSR    GETCHR
E407,81 0D,,         CMPA   #EOL
E409,27 07,,         BEQ    XREM2
E40B,8D CA,,         BSR    PUTTOK
E40D,8D BD,,         BSR    INCIBP
E40F,5C,,         INCB                ; UP THE BYTE COUNT.
E410,20 F3,,         BRA    XREM1
E412,8D C3,XREM2:, XREM2:  BSR    PUTTOK
E414,38,,         PULX                ; GET POINTER TO LENGTH BYTE.
E415,E7 00,,         STAB   0,X          ; PUT IT IN THE TOKEN BUFFER.
E417,39,,         RTS
,,, *
,,, *
,,, XPORTA: EQU    *
,,, XPORTB: EQU    *
,,, XPORTC: EQU    *
,,, XPORTD: EQU    *
E418,C6 01,,         LDAB   #NUM         ; WE'RE XLATING A NUMERICAL STATEMENT.
E41A,20 04,,         BRA    ASIGNMT1     ; GO DO IT LIKE AN ASIGNMENT STATEMENT.
,,, *
,,, *
,,, *
,,, *
,,,
,,, */***** LET *****/
,,, *
,,, *xlet()
,,, *{
,,, * letcom(LETTOK);                /* pass LET token to common code */
,,, * return;
,,, *}
,,, *
,,, */***** implied LET *****/
,,, *
,,, *ximplet()
,,, *{
,,, * letcom(IMLETTOK);
,,, * return;
,,, *}
,,, *
,,, */***** common code for explicit & implicit LET *****/
,,, *
,,, *letcom(letok)
,,, *short letok;
,,, *{
,,, * *tbufptr++=letok;              /* put LET token in buffer */
,,, * blanks();              /* skip blanks before assignment statement */
,,, * if(ibufptr=='@') { *tbufptr++=INDIRTOK; ++ibufptr; }
,,, * asignmt();                     /* evaluate expression */
,,, * return;
,,, *}
,,, *
,,, XLET:   EQU    *
,,, XIMPLET:        EQU    *
,,, *        JSR    BLANKS
,,, *XLET1    JMP    ASIGNMT
,,, *
,,, *
,,,
,,, */***** asignmt() *****/
,,, *
,,, *asignmt()
,,, *{
,,, *short type;
,,, * if((type=getvar())==0) return; /* get variable & return type */
,,, * if(errcode) return;
,,, * if(*ibufptr++!='=') { errcode=IVEXPERR; return; } /* invalid expression */
,,, * *tbufptr++=EQUALTOK;           /* put equals token in buffer */
,,, * xexpres(type);                 /* build expression in token buffer */
,,, * return;
,,, *}
,,, *
,,, ASIGNMT:        EQU    *
E41C,BD E5 57,,         JSR    GETVAR
E41F,16,,         TAB
E420,8D A8,ASIGNMT1:, ASIGNMT1:       BSR    GETNXCHR
E422,81 3D,,         CMPA   #'='
E424,27 05,,         BEQ    ASIGNMT2
E426,86 03,,         LDAA   #IVEXPERR
E428,7E EA 98,,         JMP    RPTERR
E42B,86 79,ASIGNMT2:, ASIGNMT2:       LDAA   #EQUALTOK
E42D,8D A8,,         BSR    PUTTOK
E42F,17,,         TBA
,,, *                               FALL THROUGH TO XEXPRES.
,,, *
,,, *
,,,
,,, */***** xexpres() *****/
,,, *
,,, *xexpres(type)
,,, *short type;
,,, *{
,,, * char c;
,,, * while(1)
,,, * {
,,, *  if(match("-")) *tbufptr++=NEGTOK;
,,, *  else if(match("@")) *tbufptr++=INDIRTOK;
,,, *  else if(match("NOT")) *tbufptr++=NOTTOK;
,,, XEXPRES:        EQU    *
E430,18 3C,,         PSHY
E432,36,,         PSHA
E433,18 30,,         TSY
E435,CE E5 4E,XEXPRS29:, XEXPRS29:       LDX    #UINARYOP
E438,BD E4 FD,,         JSR    TBLSRCH
E43B,24 02,,         BCC    XEXPRS30
E43D,8D 98,,         BSR    PUTTOK
,,, *
,,, *  if(*ibufptr=='(')     /* open paren? */
,,, *  {
,,, *   *tbufptr++=OPARNTOK; /* put in token buffer */
,,, *   ++ibufptr;           /* point to next char in input buffer */
,,, *   xexpres(type);       /* go get sub expression */
,,, *   if(errcode) return;
,,, *   if(*ibufptr!=')') { errcode=UPARNERR; return; }
,,, *   *tbufptr++=CPARNTOK; /* put it in the token buffer */
,,, *   ++ibufptr;           /* point to the next char in the input buffer */
,,, *   goto chkoprtr;
,,, *  }
,,, *
E43F,BD E3 C3,XEXPRS30:, XEXPRS30:       JSR    GETCHR
E442,81 28,,         CMPA   #'('
E444,26 22,,         BNE    XEXPRS1
E446,BD E3 CC,,         JSR    INCIBP
E449,86 10,,         LDAA   #OPARNTOK
E44B,BD E3 D7,,         JSR    PUTTOK
E44E,18 A6 00,,         LDAA   0,Y
E451,BD E4 30,,         JSR    XEXPRES
E454,BD E3 CA,XEXPRS2:, XEXPRS2:        JSR    GETNXCHR
E457,81 29,,         CMPA   #')'
E459,27 05,,         BEQ    XEXPRS3
E45B,86 04,,         LDAA   #UPARNERR
E45D,7E EA 98,,         JMP    RPTERR
E460,86 11,XEXPRS3:, XEXPRS3:        LDAA   #CPARNTOK
E462,BD E3 D7,,         JSR    PUTTOK
E465,7E E4 97,,         JMP    CHKOPRTR
,,, *
,,, *  if((numeric(*ibufptr)) | (*ibufptr=='$') | (*ibufptr=='"'))
,,, *  {
,,, *   c=getcon();
,,, *   if(errcode) return;
,,, *  }
,,, *  else if(c=getfun()) ;
,,, *  else (c=getvar()) ;
,,, *  if(errcode) return;
,,, *  if(type==NULL) type=c;
,,, *  if(c!=type) { errcode=DTMISERR; return; }
,,, *
,,, XEXPRS1:        EQU    *
E468,BD E1 BB,,         JSR    NUMERIC
E46B,25 08,,         BCS    XEXPRS4
E46D,81 24,,         CMPA   #'$'
E46F,27 04,,         BEQ    XEXPRS4
E471,81 22,,         CMPA   #'"'
E473,26 05,,         BNE    XEXPRS5
E475,BD E6 6C,XEXPRS4:, XEXPRS4:        JSR    GETCON
E478,20 09,,         BRA    XEXPRS7
E47A,BD E7 67,XEXPRS5:, XEXPRS5:        JSR    GETFUN
E47D,4D,,         TSTA
E47E,26 03,,         BNE    XEXPRS7
E480,BD E5 57,,         JSR    GETVAR
E483,18 E6 00,XEXPRS7:, XEXPRS7:        LDAB   0,Y
E486,C1 00,,         CMPB   #NULL
E488,26 03,,         BNE    XEXPRS8
E48A,18 A7 00,,         STAA   0,Y
E48D,18 A1 00,XEXPRS8:, XEXPRS8:        CMPA   0,Y
E490,27 05,,         BEQ    XEXPRS9
E492,86 05,,         LDAA   #DTMISERR
E494,7E EA 98,,         JMP    RPTERR
,,, XEXPRS9:        EQU    *
,,, *
,,, *
,,, */* now look for operator or end of expression */
,,, *
,,, *  chkoprtr:
,,, *  c=*ibufptr;
,,, *  if(c==EOL | c==MIDEOL | c==SPC | c==COMMA | c==SEMI | c==')')
,,, *  {
,,, *   return(c);
,,, *  }
,,, *
,,, CHKOPRTR:       EQU    *
E497,BD E3 C3,,         JSR    GETCHR
E49A,81 0D,,         CMPA   #EOL
E49C,27 40,,         BEQ    XEXPRS24
E49E,81 3A,,         CMPA   #MIDEOL
E4A0,27 3C,,         BEQ    XEXPRS24
E4A2,81 20,,         CMPA   #SPC
E4A4,27 38,,         BEQ    XEXPRS24
E4A6,81 2C,,         CMPA   #COMMA
E4A8,27 34,,         BEQ    XEXPRS24
E4AA,81 3B,,         CMPA   #SEMI
E4AC,27 30,,         BEQ    XEXPRS24
E4AE,81 29,,         CMPA   #')'
E4B0,27 2C,,         BEQ    XEXPRS24
,,, *
,,, *
,,, *  if(type==NUM)
,,, *  {
,,, *   if(c=cknumop()) ;
,,, *   else if(c=ckbolop()) ;
,,, *   else if(ifwhflag) c=cklogop();
,,, *   else c=NULL;
,,, *  }
,,, XEXPRS15:       EQU    *
E4B2,18 A6 00,,         LDAA   0,Y
E4B5,81 01,,         CMPA   #NUM
E4B7,26 18,,         BNE    XEXPRS21
E4B9,BD E4 E8,,         JSR    CKNUMOP
E4BC,25 18,,         BCS    XEXPRS17
E4BE,BD E4 F3,,         JSR    CKBOLOP
E4C1,25 13,,         BCS    XEXPRS17
E4C3,7D 00 1A,,         TST    IFWHFLAG
E4C6,27 05,,         BEQ    XEXPRS18
E4C8,BD E4 F8,,         JSR    CKLOGOP
E4CB,20 09,,         BRA    XEXPRS17
E4CD,86 00,XEXPRS18:, XEXPRS18:       LDAA   #NULL
E4CF,20 05,,         BRA    XEXPRS17
,,, *
,,, *
,,, *  else { errcode=IDTYERR; return; }
,,, *
,,, XEXPRS21:       EQU    *
E4D1,86 13,,         LDAA   #IDTYERR
E4D3,7E EA 98,,         JMP    RPTERR
,,, *
,,, *
,,, *  if(c==NULL) { errcode=OPRTRERR; return; }
,,, *  *tbufptr++=c;
,,, * }
,,, * return;
,,, *}
,,, *
,,, XEXPRS17:       EQU    *
E4D6,4D,,         TSTA
E4D7,26 09,,         BNE    XEXPRS23
E4D9,86 06,,         LDAA   #OPRTRERR
E4DB,7E EA 98,,         JMP    RPTERR
E4DE,31,XEXPRS24:, XEXPRS24:       INS
E4DF,18 38,,         PULY
E4E1,39,,         RTS
E4E2,BD E3 D7,XEXPRS23:, XEXPRS23:       JSR    PUTTOK
E4E5,7E E4 35,,         JMP    XEXPRS29
,,, *
,,, *
,,, */***** cknumop() *****/
,,, *
,,, *cknumop()
,,, *{
,,, * if(match("+")) return(PLUSTOK);
,,, * else if(match("-")) return(MINUSTOK);
,,, * else if(match("*")) return(MULTTOK);
,,, * else if(match("/")) return(DIVTOK);
,,, * else if(match("\\")) return(MODTOK);
,,, * else if(match("^")) return(PWRTOK);
,,, * else return(NULL);
,,, *}
,,, *
,,, CKNUMOP:        EQU    *
E4E8,CE E5 13,,         LDX    #NUMOPTBL
,,, *
E4EB,BD E4 FD,CKOP:, CKOP:   JSR    TBLSRCH
E4EE,25 02,,         BCS    CKOP1
E4F0,86 00