home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: DFÜ und Kommunikation / SOS-DFUE.ISO / programm / dos / utility / pccp076 / comscrpt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-20  |  16.5 KB  |  737 lines
  1. /*    Copyright (C) 1992, 1993 Peter Edward Cann, all rights reserved.
  2.  */
  3.  
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. #include<bios.h>
  7. #include<dos.h>
  8. #include<fcntl.h>
  9. #include<signal.h>
  10. #include<process.h>
  11. #include"port.h"
  12. #include"comscrpt.h"
  13.  
  14. #define MAXNSCANS 32
  15.  
  16. struct
  17.     {
  18.     unsigned char index;
  19.     unsigned char *str;
  20.     unsigned char hitlabel;
  21.     }
  22.     scans[MAXNSCANS];
  23.  
  24. int nscans;
  25.  
  26. #define MAXKEYS 64
  27.  
  28. struct
  29.     {
  30.     unsigned char key;
  31.     unsigned char label;
  32.     }
  33.     keys[MAXKEYS];
  34.  
  35. short int labels[256]; /* Not a #define cause we use unsigned char all over */
  36.  
  37. unsigned short int rregs[256]; /* Same deal */
  38.  
  39. short int jregs[256]; /* ditto */
  40.  
  41. unsigned long tick;
  42.  
  43. void (interrupt far *oldtick)();
  44.  
  45. void interrupt far tickhndl()
  46.     {
  47.     tick++;
  48.     }
  49.  
  50. quit()
  51.     {
  52.     cleanup(0);
  53.     _dos_setvect(0x1c, oldtick);
  54.     exit(99);
  55.     }
  56.  
  57. char demonflag, flowctlflag;
  58.  
  59. sendchar(c)
  60.     unsigned char c;
  61.     {
  62.     if(flowctlflag) /* A small ugly speed hack; don't want in loop */
  63.         while(!((inp(basereg+STATREG)&TXMTMASK)&&(inp(basereg+MSTATREG)&CTSMASK)))
  64.             {
  65.             if(kbhit())
  66.                 if(getch()==24)
  67.                     demonflag=1;
  68.             }
  69.     else
  70.         while(!(inp(basereg+STATREG)&TXMTMASK))
  71.             {
  72.             if(kbhit())
  73.                 if(getch()==24)
  74.                     demonflag=1;
  75.             }
  76.     outp(basereg, c);
  77.     return(0);
  78.     }
  79.  
  80. int follow;
  81.  
  82. sleep()
  83.     {
  84.     long tod, tod1;
  85.     tick=0L;
  86.     while(1)
  87.         {
  88.         if(tick>8)
  89.             break;
  90.         }
  91.     }
  92.  
  93. FILE *scriptfd;
  94. int mainargc, proglen;
  95. char **mainargv;
  96. struct line far *program;
  97.  
  98. main(argc, argv)
  99.     int argc;
  100.     char **argv;
  101.     {
  102.     FILE *outfile, *infile;
  103.     char c, fpname[256], str[81], *sptr, spawnpath[81], line[256];
  104.     char comstr[16], speedstr[16], bitsstr[16], *spawnargv[41];
  105.     int i, j, k, argn, mkeyp, lni, lnl;
  106.     int value[8], flag, progcnt, demon, curkey, spawnargc;
  107.     unsigned execretn;
  108.     long timestamp, tstamp, tstamp1;
  109.     program=(struct line *)malloc(PROGSIZ*sizeof(struct line));
  110.     if(!program)
  111.         {
  112.         printf("Unable to allocate program buffer (compiled for %d statements).\n", PROGSIZ);
  113.         exit(123);
  114.         }
  115.     mainargc=argc;
  116.     mainargv=argv;
  117.     index=follow=0;
  118.     printf("Copyright (C) 1992, 1993 Peter Edward Cann, all rights reserved.\n");
  119.     if(!strcmp(getenv("REMOTE"), "YES"))
  120.         {
  121.         printf("You appear to be logged in remotely, judging by the environment\n");
  122.         printf("variable REMOTE, so it strikes me as somewhat peculiar that you\n");
  123.         printf("want to run COMSCRPT. Are you sure you want to do it? (y or n) --> ");
  124.         if(getchar()!='y') /* Note getchar() and not getch()! */
  125.             {
  126.             printf("I didn't think so!\n");
  127.             exit(98);
  128.             }
  129.         else
  130.             printf("OK, you're the boss!");
  131.         }
  132.     if(argc<2)
  133.         {
  134.         printf("USAGE: comscrpt <script file basename> [<sub arg>] ...\n");
  135.         printf("The environment variable PCCPPATH is used for the script file if set.\n");
  136.         exit(1);
  137.         }
  138.     fpname[0]='\0';
  139.     if(getenv("PCCPPATH")!=NULL)
  140.         sprintf(quicke, "%s\\", getenv("PCCPPATH"));
  141.     else
  142.         quicke[0]='\0';
  143.     if((quicke==NULL)||(argv[1][0]=='.')||(argv[1][0]=='\\')||(argv[1][0]&&(argv[1][1]==':')))
  144.         sprintf(fpname, "%s.scr", argv[1]);
  145.     else
  146.         sprintf(fpname, "%s%s.scr", quicke, argv[1]);
  147.     if((scriptfd=fopen(fpname, "r"))==NULL)
  148.         {
  149.         printf("Error opening script file %s.\n", fpname);
  150.         exit(2);
  151.         }
  152.     outfile=infile=NULL;
  153.     flowctlflag=1;
  154.     fgets(str, 80, scriptfd);
  155.     for(i=0;i<80;++i)
  156.         if(str[i]=='\n')
  157.             {
  158.             str[i]='\0';
  159.             break;
  160.             }
  161.         else if(str[i]=='\0')
  162.             break;
  163.         else if(str[i]=='$')
  164.             if((str[i+1]>='1')&&(str[i+1]<='9'))
  165.                 {
  166.                 j=strlen(str);
  167.                 argn=(str[i+1]-'0')+1;
  168.                 if(argn>=argc)
  169.                     {
  170.                     printf("Argument %d cited in port config line but not provided on command line.\n", argn-1);
  171.                     cleanup(0);
  172.                     exit(101);
  173.                     }
  174.                 sptr=argv[argn];
  175.                 k=j+strlen(sptr)-2; /* Nuke $n */
  176.                 if(k>80)
  177.                     {
  178.                     printf("Expanded port config line too long.\n");
  179.                     printf("Raw line reads:\n%s", str);
  180.                     cleanup(0);
  181.                     exit(101);
  182.                     }
  183.                 if(k>j)
  184.                     for(;j>i;j--,k--)
  185.                         str[k]=str[j];
  186.                 else if(k<j)
  187.                     for(j=i+strlen(sptr),k=i+2;str[j];j++,k++)
  188.                         str[j]=str[k];
  189.                 for(j=0;sptr[j];j++,i++)
  190.                     str[i]=sptr[j];
  191.                 i--;
  192.                 }
  193.             else
  194.                 {
  195.                 for(j=i,k=i+1;str[j];j++,k++)
  196.                     str[j]=str[k];
  197.                 i--;
  198.                 }
  199.     value[0]=sscanf(str, "%15s %15s %15s %d",
  200.         comstr, speedstr, bitsstr, &flowctlflag);
  201.     if(value[0]<3)
  202.         {
  203.         printf("Can't read init params.\n");
  204.         exit(10);
  205.         }
  206.     if(value[0]!=4)
  207.         flowctlflag=1;
  208.     comnum=atoi(comstr)-1;
  209.     speed=atoi(speedstr);
  210.     parity=bitsstr[1];
  211.     databits=bitsstr[0];
  212.     stopbits=bitsstr[2];
  213.     for(i=0;i<256;++i)
  214.         labels[i]=-1;
  215.     for(i=0;i<256;++i)
  216.         rregs[i]=0;
  217.     printf("Parsing...\n");
  218.     parse(0,0);
  219.     printf("Checking branch label validity...\n");
  220.     validate(0); /* We want to bomb if the script flunks */
  221.     printf("Liberating excess RAM...\n");
  222.     program=(struct line *)realloc(program, proglen*sizeof(struct line));
  223.     if(program==NULL)
  224.         {
  225.         printf("Gaahh! realloc() bombed. Sorry about that!\n");
  226.         _dos_setvect(0x1c, oldtick);
  227.         exit(70);
  228.         }
  229.     printf("Executing...\n", proglen);
  230.     setport();
  231.     oldtick=_dos_getvect(0x1c);
  232.     readset();
  233.     signal(SIGINT, quit);
  234.     _dos_setvect(0x1c, tickhndl);
  235.     setup();
  236.     /* Execute */
  237.     progcnt=nscans=curkey=0;
  238.     demonflag=0;
  239.     demon=-1;
  240.     while(1)
  241.         {
  242.         if(kbhit())
  243.             if(getch()==24)
  244.                 if(demon>=0)
  245.                     progcnt=demon;
  246.         if(demonflag)
  247.             {
  248.             demonflag=0;
  249.             if(demon>=0)
  250.                 progcnt=demon;
  251.             }
  252.         if(progcnt>=proglen)
  253.             {
  254.             printf("\nFell through end of program.\n");
  255.             while(!(inp(basereg+STATREG)&TXSHMTMASK));
  256.             cleanup(0);
  257.             _dos_setvect(0x1c, oldtick);
  258.             exit(100);
  259.             }
  260.         switch(program[progcnt].type)
  261.             {
  262.             case '=':
  263.                 while(!(inp(basereg+STATREG)&TXSHMTMASK))
  264.                     if(kbhit())
  265.                         if(getch()==24)
  266.                             if(demon>=0)
  267.                                 {
  268.                                 progcnt=demon;
  269.                                 demonflag=1;
  270.                                 break;
  271.                                 }
  272.                 if(demonflag)
  273.                     break;
  274.                 if(program[progcnt].stuff.port.comnum==-1)
  275.                     {
  276.                     outp(basereg+LCTLREG, DLAB);
  277.                     if(program[progcnt].stuff.port.speed)
  278.                         {
  279.                         outp(basereg+DLLSBREG, dllsb=((1152/program[progcnt].stuff.port.speed)&0xff));
  280.                         outp(basereg+DLMSBREG, dlmsb=((1152/program[progcnt].stuff.port.speed)&0x0fff)>>8);
  281.                         }
  282.                     else
  283.                         {
  284.                         outp(basereg+DLLSBREG, 0);
  285.                         outp(basereg+DLMSBREG, 0);
  286.                         }
  287.                     outp(basereg+LCTLREG, lctl);
  288.                     }
  289.                 else
  290.                     {
  291.                     cleanup(INHCTL);
  292.                     comnum=program[progcnt].stuff.port.comnum;
  293.                     speed=program[progcnt].stuff.port.speed;
  294.                     databits=program[progcnt].stuff.port.databits;
  295.                     parity=program[progcnt].stuff.port.parity;
  296.                     stopbits=program[progcnt].stuff.port.stopbits;
  297.                     flowctlflag=program[progcnt].stuff.port.flowctlflag;
  298.                     setport();
  299.                     setup();
  300.                     }
  301.                 progcnt++;
  302.                 break;
  303.             case 'g':
  304.                 progcnt=labels[program[progcnt].stuff.byte];
  305.                 break;
  306.             case '*':
  307.                 if(program[progcnt].stuff.number>=0)
  308.                     demon=labels[program[progcnt].stuff.number];
  309.                 else
  310.                     demon=-1;
  311.                 progcnt++;
  312.                 break;
  313.             case 'r':
  314.                 if(++rregs[program[progcnt].stuff.retry.reg]>=program[progcnt].stuff.retry.retries)
  315.                     {
  316.                     rregs[program[progcnt].stuff.retry.reg]=0;
  317.                     progcnt=labels[program[progcnt].stuff.retry.label];
  318.                     }
  319.                 else
  320.                     progcnt++;
  321.                 break;
  322.             case '"':
  323.                 sprintf(str, "%d", rregs[program[progcnt].stuff.number]);
  324.                 printf("%s", str);
  325.                 if(outfile!=NULL)
  326.                     fputs(str, outfile);
  327.                 progcnt++;
  328.                 break;
  329.             case '#':
  330.                 if(execretn<=program[progcnt].stuff.rtnchk.value)
  331.                     progcnt=labels[program[progcnt].stuff.rtnchk.label];
  332.                 else
  333.                     progcnt++;
  334.                 break;
  335.             case '0':
  336.                 rregs[program[progcnt].stuff.byte]=0;
  337.                 progcnt++;
  338.                 break;
  339.             case 'p':
  340.                 tick=0L;
  341.                 flag=1;
  342.                 lni=lnl=0;
  343.                 while(flag)
  344.                     {
  345.                     while(1)
  346.                         {
  347.                         if(program[progcnt].stuff.numbers[0]&&(tick>program[progcnt].stuff.numbers[0]))
  348.                             {
  349.                             progcnt++;
  350.                             flag=0;
  351.                             break;
  352.                             }
  353.                         if(lnl>0)
  354.                             {
  355.                             c=line[lni++];
  356.                             if(outfile!=NULL)
  357.                                 putc(c, outfile);
  358.                             if(lni>=lnl)
  359.                                 lni=lnl=0;
  360.                             break;
  361.                             }
  362.                         else if(follow!=index)
  363.                             {
  364.                             c=buf[follow++];
  365.                             if(follow>=TBUFSIZ)
  366.                                 follow=0;
  367.                             if(!program[progcnt].stuff.numbers[1])
  368.                                 {
  369.                                 putch(c);
  370.                                 if(outfile!=NULL)
  371.                                     putc(c, outfile);
  372.                                 break;
  373.                                 }
  374.                             else
  375.                                 if(c=='\b')
  376.                                     if(lni>0)
  377.                                         {
  378.                                         sendchar('\b');
  379.                                         putch('\b');
  380.                                         sendchar(' ');
  381.                                         putch(' ');
  382.                                         sendchar('\b');
  383.                                         putch('\b');
  384.                                         lni--;
  385.                                         }
  386.                                     else
  387.                                         sendchar(7);
  388.                                 else if((c=='\r'))
  389.                                     {
  390.                                     line[lni++]='\r';
  391.                                     lnl=lni;
  392.                                     lni=0;
  393.                                     putch('\r');
  394.                                     putch('\n');
  395.                                     }
  396.                                 else if((lni<255)&&(c>=' ')&&(c<0x80))
  397.                                     {
  398.                                     if(program[progcnt].stuff.numbers[1]==1)
  399.                                         sendchar(c);
  400.                                     else
  401.                                         sendchar('*');
  402.                                     putch(c);
  403.                                     line[lni++]=c;
  404.                                     }
  405.                                 else
  406.                                     sendchar(7);
  407.                             }
  408.                         if(kbhit())
  409.                             if(getch()==24)
  410.                                 {
  411.                                 demonflag=1;
  412.                                 flag=0;
  413.                                 break;
  414.                                 }
  415.                         }
  416.                     if(!flag)
  417.                         break;
  418.                     for(i=0;i<nscans;++i)
  419.                         if(scans[i].str[scans[i].index]==c)
  420.                             if(scans[i].str[++scans[i].index]=='\0')
  421.                                 {
  422.                                 progcnt=labels[scans[i].hitlabel];
  423.                                 flag=0;
  424.                                 break;
  425.                                 }
  426.                             else;
  427.                         else if(scans[i].str[0]==c)
  428.                             scans[i].index=1;
  429.                         else
  430.                             scans[i].index=0;
  431.                     }
  432.                 nscans=0;
  433.                 break;
  434.             case '>':
  435.                 if(nscans>=MAXNSCANS)
  436.                     {
  437.                     printf("Too many lookfors (>); statement %d; ignoring.\n", progcnt++);
  438.                     break;
  439.                     }
  440.                 scans[nscans].index=0;
  441.                 scans[nscans].str=program[progcnt].stuff.l_and_s.string;
  442.                 scans[nscans++].hitlabel=program[progcnt].stuff.l_and_s.label;
  443.                 progcnt++;
  444.                 break;
  445.             case 'f':
  446.                 follow=index;
  447.                 progcnt++;
  448.                 break;
  449.             case 't':
  450.                 if(infile==NULL)
  451.                     {
  452.                     progcnt=labels[program[progcnt].stuff.l_and_s.label];
  453.                     break;
  454.                     }
  455.                 if(fgets(str, 80, infile)==NULL)
  456.                     {
  457.                     progcnt=labels[program[progcnt].stuff.l_and_s.label];
  458.                     break;
  459.                     }
  460.                 for(i=0;i<80;++i)
  461.                     {
  462.                     if((str[i]=='\n')||(str[i]=='\r')||(str[i]=='\0'))
  463.                         break;
  464.                     sendchar(str[i]);
  465.                     }
  466.                 progcnt++;
  467.                 break;
  468.             case 'i':
  469.                 if(program[progcnt].stuff.l_and_s.string[0]=='*')
  470.                     if(infile!=NULL)
  471.                         fclose(infile);
  472.                     else;
  473.                 else if((infile=fopen(program[progcnt].stuff.l_and_s.string, "r"))==NULL)
  474.                     {
  475.                     progcnt=labels[program[progcnt].stuff.l_and_s.label];
  476.                     break;
  477.                     }
  478.                 progcnt++;
  479.                 break;
  480.             case 'o':
  481.                 if(program[progcnt].stuff.l_and_s.string[0]=='*')
  482.                     if(outfile!=NULL)
  483.                         fclose(outfile);
  484.                     else;
  485.                 else if((outfile=fopen(program[progcnt].stuff.l_and_s.string, "a"))==NULL)
  486.                     {
  487.                     progcnt=labels[program[progcnt].stuff.l_and_s.label];
  488.                     break;
  489.                     }
  490.                 else
  491.                     setmode(fileno(outfile), O_BINARY);
  492.                 progcnt++;
  493.                 break;
  494.             case '?':
  495.                 if(!((inp(basereg+STATREG)&TXMTMASK)
  496.                     &&((inp(basereg+MSTATREG)&CTSMASK)
  497.                     ||!flowctlflag)))
  498.                     progcnt=labels[program[progcnt].stuff.byte];
  499.                 else
  500.                     progcnt++;
  501.                 break;
  502.             case 'd':
  503.                 if(inp(basereg+MSTATREG)&DCDMASK)
  504.                     progcnt=labels[program[progcnt].stuff.byte];
  505.                 else
  506.                     progcnt++;
  507.                 break;
  508.             case '<':
  509.                 for(i=0;i<80;i++)
  510.                     if(program[progcnt].stuff.string[i]=='\0')
  511.                         break;
  512.                     else if(program[progcnt].stuff.string[i]=='`')
  513.                         {
  514.                         j=0;
  515.                         if(program[progcnt].stuff.string[++i]<'A')
  516.                             j=(program[progcnt].stuff.string[i]-'0')<<4;
  517.                         else if(program[progcnt].stuff.string[i]<'a')
  518.                             j=(program[progcnt].stuff.string[i]-'A'+10)<<4;
  519.                         else
  520.                             j=(program[progcnt].stuff.string[i]-'a'+10)<<4;
  521.                         if(program[progcnt].stuff.string[++i]<'A')
  522.                             j+=(program[progcnt].stuff.string[i]-'0');
  523.                         else if(program[progcnt].stuff.string[i]<'a')
  524.                             j+=(program[progcnt].stuff.string[i]-'A'+10);
  525.                         else
  526.                             j+=(program[progcnt].stuff.string[i]-'a'+10);
  527.                         sendchar(j);
  528.                         }
  529.                     else if(program[progcnt].stuff.string[i]=='~')
  530.                         sleep();
  531.                     else if(program[progcnt].stuff.string[i]=='^')
  532.                         {
  533.                         tick=0L;
  534.                         outp(basereg+LCTLREG, lctl|0x40);
  535.                         while(1)
  536.                             {
  537.                             if(tick>10)
  538.                                 break;
  539.                             }
  540.                         outp(basereg+LCTLREG, lctl);
  541.                         }
  542.                     else
  543.                         sendchar(program[progcnt].stuff.string[i]);
  544.                 progcnt++;
  545.                 break;
  546.             case '!':
  547.                 printf("%s", program[progcnt].stuff.string);
  548.                 if(outfile!=NULL)
  549.                     fputs(program[progcnt].stuff.string, outfile);
  550.                 progcnt++;
  551.                 break;
  552.             case 's':
  553.                 printf("\n");
  554.                 cleanup(INHCTL);
  555.                 if(system(program[progcnt].stuff.l_and_s.string)==-1)
  556.                     {
  557.                     progcnt=labels[program[progcnt].stuff.l_and_s.label];
  558.                     }
  559.                 else
  560.                     progcnt++;
  561.                 setup();
  562.                 printf("\nBack to script.\n");
  563.                 break;
  564.             case 'x':
  565.                 printf("\n");
  566.                 cleanup(INHCTL);
  567.                 spawnargc=0;
  568.                 if(program[progcnt].stuff.l_and_s.string[0]!='\0')
  569.                     {
  570.                     spawnargv[spawnargc++]=&program[progcnt].stuff.l_and_s.string[0];
  571.                     for(j=0,i=1;i<program[progcnt].stuff.l_and_s.ntokens;i++)
  572.                         {
  573.                         while(program[progcnt].stuff.l_and_s.string[j++]!='\0');
  574.                         spawnargv[spawnargc++]=&program[progcnt].stuff.l_and_s.string[j];
  575.                         }
  576.                     spawnargv[spawnargc++]=NULL;
  577.                     strcpy(spawnpath, spawnargv[0]);
  578.                     execretn=spawnvp(P_WAIT, spawnpath, spawnargv);
  579.                     }
  580.                 else
  581.                     execretn=65535;
  582.                 setup();
  583.                 progcnt++;
  584.                 break;
  585.             case '+':
  586.                 outp(basereg+MCTLREG, 0x0b);
  587.                 progcnt++;
  588.                 break;
  589.             case '-':
  590.                 outp(basereg+MCTLREG, 0x0a);
  591.                 progcnt++;
  592.                 break;
  593.             case 'k':
  594.                 if(curkey>=MAXKEYS)
  595.                     {
  596.                     printf("Excess key daemon ignored.\n");
  597.                     progcnt++;
  598.                     break;
  599.                     }
  600.                 keys[curkey].key=program[progcnt].stuff.l_and_s.string[0];
  601.                 keys[curkey++].label=program[progcnt].stuff.l_and_s.label;
  602.                 progcnt++;
  603.                 break;
  604.             case 'w':
  605.                 timestamp=time(NULL);
  606.                 while(1)
  607.                     {
  608.                     if(program[progcnt].stuff.number&&((time(NULL)-timestamp)>program[progcnt].stuff.number))
  609.                         {
  610.                         printf("\nKeyboard entry timeout.\n");
  611.                         progcnt++;
  612.                         break;
  613.                         }
  614.                     if(kbhit())
  615.                         {
  616.                         c=getch();
  617.                         if(c==24)
  618.                             if(demon>=0)
  619.                                 {
  620.                                 progcnt=demon;
  621.                                 break;
  622.                                 }
  623.                         for(i=0;i<curkey;i++)
  624.                             if(c==keys[i].key)
  625.                                 {
  626.                                 progcnt=labels[keys[i].label];
  627.                                 break;
  628.                                 }
  629.                         if(i>=curkey)
  630.                             putch(0x07);
  631.                         else
  632.                             break;
  633.                         }
  634.                     }
  635.                 curkey=0;
  636.                 break;
  637.             case 'm':
  638.                 tick=0L;
  639.                 flag=1;
  640.                 mkeyp=0;
  641.                 while(flag)
  642.                     {
  643.                     while(1)
  644.                         {
  645.                         if(program[progcnt].stuff.number&&(tick>program[progcnt].stuff.number))
  646.                             {
  647.                             progcnt++;
  648.                             flag=0;
  649.                             break;
  650.                             }
  651.                         if(follow!=index)
  652.                             {
  653.                             putch(c=buf[follow++]);
  654.                             if(follow>=TBUFSIZ)
  655.                                 follow=0;
  656.                             if(outfile!=NULL)
  657.                                 putc(c, outfile);
  658.                             mkeyp=0;
  659.                             break;
  660.                             }
  661.                         if(kbhit())
  662.                             {
  663.                             c=getch();
  664.                             if(c==24)
  665.                                 if(demon>=0)
  666.                                     {
  667.                                     progcnt=demon;
  668.                                     flag=0;
  669.                                     break;
  670.                                     }
  671.                             mkeyp=1;
  672.                             break;
  673.                             }
  674.                         }
  675.                     if(!flag)
  676.                         break;
  677.                     if(mkeyp)
  678.                         {
  679.                         for(i=0;i<curkey;i++)
  680.                             if(c==keys[i].key)
  681.                                 {
  682.                                 progcnt=labels[keys[i].label];
  683.                                 break;
  684.                                 }
  685.                         if(i>=curkey)
  686.                             putch(0x07);
  687.                         else
  688.                             break;
  689.                         }
  690.                     else
  691.                         {
  692.                         for(i=0;i<nscans;++i)
  693.                             if(scans[i].str[scans[i].index]==c)
  694.                                 if(scans[i].str[++scans[i].index]=='\0')
  695.                                     {
  696.                                     progcnt=labels[scans[i].hitlabel];
  697.                                     flag=0;
  698.                                     break;
  699.                                     }
  700.                                 else;
  701.                             else if(scans[i].str[0]==c)
  702.                                 scans[i].index=1;
  703.                             else
  704.                                 scans[i].index=0;
  705.                         }
  706.                     }
  707.                 nscans=curkey=0;
  708.                 break;
  709.             case 'c':
  710.                 curkey=nscans=0;
  711.                 progcnt++;
  712.                 break;
  713.             case 'l':
  714.                 if(program[progcnt].stuff.load.label<0)
  715.                     jregs[program[progcnt].stuff.load.reg]=-1;
  716.                 else
  717.                     jregs[program[progcnt].stuff.load.reg]=labels[program[progcnt].stuff.load.label];
  718.                 progcnt++;
  719.                 break;
  720.             case 'j':
  721.                 if(jregs[program[progcnt].stuff.number]<0)
  722.                     {
  723.                     progcnt++;
  724.                     break;
  725.                     }
  726.                 else
  727.                     progcnt=jregs[program[progcnt].stuff.number];
  728.                 break;
  729.             case 'q':
  730.                 while(!(inp(basereg+STATREG)&TXSHMTMASK));
  731.                 cleanup(0);
  732.                 _dos_setvect(0x1c, oldtick);
  733.                 exit(program[progcnt].stuff.number);
  734.             }
  735.         }
  736.     }
  737.