home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Interactive Guide / c-cplusplus-interactive-guide.iso / c_ref / csource4 / 202_01 / ked2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1979-12-31  |  24.3 KB  |  712 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <ked.h>
  4.  
  5.  
  6. getchr()   /* low-level character input */
  7. {
  8.      char c;
  9.  
  10.      c = getch();
  11.      putch(c);
  12.      return c;
  13. }
  14.  
  15.  
  16. int lower(c)
  17. char c;
  18. {
  19.      return isupper(c) ? c+32 : c;
  20. }
  21.  
  22. int upper(c)
  23. char c;
  24. {
  25.      return islower(c) ? c-32 : c;
  26. }
  27.  
  28.  
  29. readin(w)   /* find location of command in comm array or symbol table */
  30. char w[];
  31. {
  32.           int c,i,l,m;
  33.  
  34.           do {
  35.             inputs(w);
  36.             if ((m = match(w,comm,MAXCOMM)) != NOMATCH)
  37.                return m;              
  38.             if (m == NOMATCH && last != first && p != pr) {
  39.                l = pr->lastin;
  40.                if (l == 15) 
  41.                    l = last;
  42.                for (i = first; i != l; i = new[i].nextin)
  43.                     if ((c = strcomp(w,new[i].defname)) == 0) 
  44.                        return ( -i - 1);
  45.             }          
  46.             printf("INVALID COMMAND. TYPE MN TO SEE MENU.\n?");
  47.           } while (m == NOMATCH);
  48. }
  49.  
  50.  
  51.  
  52. menu()           /* print updated menu */
  53. {
  54.           int i;
  55.  
  56.           printf("THE FOLLOWING IS A LIST OF VALID ");
  57.           printf("COMMANDS FOR THIS EDITOR.\n\n");
  58.           printf("  INSTRUCTIONS\n");   
  59.           printf("m          move\n");
  60.           printf("tl         turnleft\n");
  61.           printf("pi         pickbeeper\n");
  62.           printf("pu         putbeeper\n");
  63.           printf("to         turnoff\n");
  64.           printf("b          BEGIN\n");
  65.           printf("bx         BEGINNING-OF-EXECUTION\n");
  66.           printf("nd         END\n");
  67.           printf("ndc        end construct\n");
  68.           printf("ndx        END-OF-EXECUTION\n");
  69.           printf("if         IF\n");
  70.           printf("el         ELSE\n");
  71.           printf("it         ITERATE\n");
  72.           printf("wh         WHILE\n");
  73.           printf("df         DEFINE-NEW-INSTRUCTION\n");
  74.           printf("\nTYPE ANY KEY TO CONTINUE.\n");
  75.           getchr();
  76.           if (last != first) {   /* any valid sym tab entries? */
  77.            printf("\n  USER-DEFINED COMMANDS\n");
  78.            for (i = first; i != last; i = new[i].nextin)
  79.                 printf("%s\n", new[i].defname);  
  80.           }
  81.           printf("\n  EDIT COMMANDS\n");      
  82.           printf("n          move pointer to next instruction\n");
  83.           printf("nc         move pointer to next construct\n");
  84.           printf("n-         move pointer to previous instruction\n");
  85.           printf("n--        move pointer back 10 lines\n"); 
  86.           printf("d          delete current instruction\n");
  87.           printf("c          print current line\n");
  88.           printf("p          print next 20 lines\n");
  89.           printf("i          insert new instruction before current one\n");
  90.           printf("t          move pointer to the first line\n");
  91.           printf("l          list the rest of the program\n");
  92.           printf("s          save the program\n");
  93.           printf("mn         print an updated menu\n");
  94.           printf("q          quit the edit program\n");
  95.           printf("\nTYPE ANY KEY TO CONTINUE.\n");
  96.           getchr();
  97.           printf("\n  TESTS\n");
  98.           printf("n          facing-north\n");
  99.           printf("nn         not-facing-north\n");
  100.           printf("s          facing-south\n");
  101.           printf("ns         not-facing-south\n");
  102.           printf("e          facing-east\n");
  103.           printf("ne         not-facing-east\n");
  104.           printf("w          facing-west\n");
  105.           printf("nw         not-facing-west\n");
  106.           printf("c          next-to-a-beeper (beeper on corner)\n");
  107.           printf("nc         not-next-to-a-beeper\n");
  108.           printf("b          any-beepers-in-beeper-bag\n");
  109.           printf("nb         no-beepers-in-beeper bag\n");
  110.           printf("f          front-is-clear\n");
  111.           printf("nf         front-is-blocked\n");
  112.           printf("l          left-is-clear\n");
  113.           printf("nl         left-is-blocked\n");
  114.           printf("r          right-is-clear\n");
  115.           printf("nr         right-is-blocked\n");
  116. }
  117.  
  118. createtree()                      /* reads information from old file1 */
  119. {
  120.            int i,in,d,fn,fs,b,t,l;
  121.            char *malloc();
  122.  
  123.            fscanf(fptr1, "%d %d %d %d %d %d %d %d",
  124.                   &i,&in,&d,&fn,&fs,&b,&t,&l);
  125.            pr = NULL;
  126.            p = (struct tnode *)malloc(24);
  127.            tree(i,in,d,fn,fs,b,t,l);              /* store first node */
  128.            root = p;
  129.            p = root->sub = (struct tnode *)malloc(24);
  130.            pr = root;
  131.            fscanf(fptr1, "%d %d %d %d %d %d %d %d",
  132.                   &i,&in,&d,&fn,&fs,&b,&t,&l);
  133.            while (i != NDX && i != CPMEOF && i != EOF) { 
  134.                createnode(fptr1,i,in,d,fn,fs,b,t,l);    
  135.                fscanf(fptr1, "%d %d %d %d %d %d %d %d",
  136.                       &i,&in,&d,&fn,&fs,&b,&t,&l);
  137.            }
  138.            endcons();
  139.            tree(i,in,d,fn,fs,b,t,l);
  140.            pr = p;
  141.            fclose(fptr1);        
  142. }
  143.  
  144.  
  145. createnode(fptr1,i,in,d,fn,fs,b,t,l)    /* restores nodes for parse tree */
  146. FILE *fptr1;
  147. int i,in,d,fn,fs,b,t,l;
  148. {
  149.           int j;
  150.           char w[MAXLINE];
  151.           struct tnode *allocp();
  152.  
  153.           if (d == NEWINSTR && pr->instr != DEF) {
  154.               i = reloc[i];                   /* set up array to convert */
  155.               j = 0;                              /* old symb tab to new */
  156.               while (new[i].loc[j] != NULL)
  157.                      j++;
  158.               new[i].loc[j] = p;
  159.               new [i].loc[++j] = NULL;
  160.               if (l != 15)
  161.                  l = last;
  162.               tree(i,in,d,fn,fs,b,t,l);
  163.               p = p->next = allocp();
  164.           } else switch (i) { 
  165.                  case 0:            /* move */
  166.                  case 1:            /* turnleft */
  167.                  case 2:            /* pickbeeper */
  168.                  case 3:            /* putbeeper */
  169.                  case 4:            /* turnoff */
  170.                     while (in < pr->indent)
  171.                            endcons();
  172.                     if (l != 15)
  173.                        l = last;
  174.                     tree(i,in,d,fn,fs,b,t,l);
  175.                     p = p->next = allocp();
  176.                     break;
  177.                 case 5:             /* BEGIN */
  178.                 case 7:             /* BEGINNING-OF-EXECUTION */
  179.                 case 13:            /* ELSE */
  180.                    if (l != 15)
  181.                       l = last;
  182.                    tree(i,in,d,fn,fs,b,t,l);
  183.                    p = p->sub = allocp();
  184.                    break;
  185.                case 8:              /* END */
  186.                   if (l != 15)
  187.                      l = last;
  188.                   tree(i,in,d,fn,fs,b,t,l);
  189.                   p = p->next = allocp();
  190.                   endcons();
  191.                   break;
  192.                case 11:             /* IF */
  193.                   while (in < pr->indent)
  194.                       endcons();
  195.                   if (l != 15)
  196.                      l = last;
  197.                   tree(i,in,d,fn,fs,b,t,l);
  198.                   p = p->sub = allocp();
  199.                   fscanf(fptr1,"%d %d %d %d %d %d %d %d",
  200.                          &i,&in,&d,&fn,&fs,&b,&t,&l);         /* get test */
  201.                   if (l != 15)
  202.                      l = last;
  203.                   tree(i,in,d,fn,fs,b,t,l);
  204.                   p = p->sub = allocp();
  205.                   fscanf(fptr1, "%d %d %d %d %d %d %d %d",
  206.                          &i,&in,&d,&fn,&fs,&b,&t,&l);         /* get THEN */
  207.                   if (l != 15)
  208.                      l = last;
  209.                   tree(i,in,d,fn,fs,b,t,l);
  210.                   p = p->sub = allocp();
  211.                   break;
  212.                case 14:               /* ITERATE */
  213.                case 15:               /* WHILE */
  214.                   while (in < pr->indent)
  215.                       endcons();
  216.                   if (l != 15)
  217.                      l = last;
  218.                   tree(i,in,d,fn,fs,b,t,l);
  219.                   p = p->sub = allocp();
  220.                   fscanf(fptr1,"%d %d %d %d %d %d %d %d",
  221.                          &i,&in,&d,&fn,&fs,&b,&t,&l);      /* get test or */
  222.                   if (l != 15)                                 /* pos int */
  223.                      l = last;
  224.                   tree(i,in,d,fn,fs,b,t,l);                   
  225.                   p = p->sub = allocp();
  226.                   break;
  227.                case 16:             /* DEFINE-NEW-INSTRUCTION */
  228.                   tree(i,in,d,fn,fs,b,t,last);
  229.                   p = p->sub = allocp();
  230.                   fscanf(fptr1,"%d %d %d %d %d %d %d %d",
  231.                          &i,&in,&d,&fn,&fs,&b,&t,&l);      /* get new name */
  232.                   i = reloc[i] = last;                        /* translate */
  233.                   j = 0;                              /* sym tab subscript */
  234.                   while ((w[j++] = getc(fptr1)) != '\n')
  235.                       ;
  236.                   j -= 3;
  237.                   w[j] = '\0';
  238.                   strcpy(new[i].defname,w);
  239.                   new[i].nextin = last + 1; /* store next ref in sym table */
  240.                   tree(i,in,d,fn,fs,b,t,last);
  241.                   p = p->sub = allocp();
  242.                   break;
  243.                }
  244. }   
  245.  
  246.  
  247. insertinstr()     /* prepare to add instructions in insert mode */
  248. {
  249.         
  250.           struct tnode *allocp(), *conbegin(), *advance();
  251.  
  252.           insert = 1;
  253.           insertnode = curr;
  254.           if ((curr->instr == NDX ||        /* find previous construct */
  255.                curr->instr == ND) && curr->del !=  NEWINSTR) {
  256.               p = curr->prev;
  257.               if (p->cons != 1)
  258.                  while (p->indent > curr->indent + 1)
  259.                      p = conbegin(p);
  260.           } else p = curr->prec;
  261.           if (p->instr == IFF) {     /* set THEN as start of construct */
  262.              p = advance(p);                /* so ELSE can be inserted */
  263.              p = advance(p);
  264.           }
  265.           ins = p->indent;         /* final indent level for construct */
  266.           if ((p->instr == BX || p->instr == BEG || p->instr == BEPGM)
  267.                && p->del != NEWINSTR)
  268.                ++ins;
  269.           if (insertnode == p->sub ||
  270.              (p->instr == BX && p->del != NEWINSTR)) 
  271.               p = p->sub = allocp();           /* set up links to next */
  272.           else {                                   /* node to be added */
  273.                p = p->next = allocp();
  274.                temp = insertnode->prev;  
  275.                temp->next = p;
  276.           }
  277. }
  278.  
  279.  
  280. endinsert()        /* exit insert mode */
  281. {
  282.  
  283.           if (insert) {
  284.               if (pr->instr == THEN) 
  285.                  if (p == pr->sub)
  286.                     printf("PLEASE COMPLETE CONSTRUCT\n");
  287.                  else endcons();
  288.               if (pr->indent > ins)
  289.                  printf("PLEASE COMPLETE CONSTRUCT\n");
  290.               else {
  291.                  insert = 0;
  292.                  insertnode->prec = pr;
  293.                  if (tempend != NULL) {            /* if a node has been */
  294.                      tempend->next = insertnode;   /* inserted link last */
  295.                      insertnode->prev = tempend;          /* instruction */
  296.                      tempend = NULL;
  297.                  } else if (temp != NULL)           /* otherwise restore */
  298.                             temp->next = insertnode;        /* old links */
  299.                         else if (p == pr->next)
  300.                                  pr->next = insertnode;
  301.                              else pr->sub = insertnode;
  302.                  temp = NULL;  
  303.                  free((char *)p);
  304.                  p = pr;
  305.                  curr = insertnode;
  306.               }
  307.          }
  308. } 
  309.  
  310.  
  311. delete()                /* delete or replace current instruction */
  312. {
  313.           int c;
  314.  
  315.           switch(curr->del) {
  316.           case 0:       /* reserved word */
  317.              printf("DELETE ENTIRE CONSTRUCT? (Y/N)\n");
  318.              if ((c = upper(getchr())) == 'Y')
  319.                   deletecon();
  320.              else printf("\n");
  321.              break;
  322.           case 1:       /* simple instruction */
  323.              demalloc(curr,curr->next);
  324.              break;
  325.           case 2:       /* test */
  326.              prompt("TYPE REPLACEMENT ",1,"",5,0);
  327.              curr->instr = getest();
  328.              print(curr->prev,stdout);
  329.              print(curr,stdout);
  330.              break;
  331.           case 3:       /* positive number */
  332.              prompt("TYPE REPLACEMENT ",2,"",16,0);
  333.              curr->instr = getint();
  334.              print(curr->prev,stdout);
  335.              print(curr,stdout); 
  336.              break;
  337.           case 4:       /* new name */
  338.              if (curr->prev->instr == DEF) {
  339.                  prompt("TYPE REPLACEMENT ",4,"",9,0);
  340.                  getnew(curr->instr);
  341.                  print(curr->prev,stdout);
  342.                  print(curr,stdout); 
  343.              } else demalloc(curr,curr->next);
  344.              break;
  345.           case 5:       /* BEGINNING-OF-PROGRAM, BX, NDX */
  346.              printf("CAN'T BE DELETED\n?");
  347.              break;
  348.       }
  349. }
  350.  
  351.  
  352. deletecon()       /* locate start and end of current construct */
  353. {
  354.  
  355.           struct tnode *ptr1, *ptr2, *conbegin(), *conend();
  356.  
  357.           if (curr->instr == THEN || curr->cons != 1)
  358.               ptr1 = conbegin(curr);       /* locate start of construct */
  359.           else ptr1 = curr; 
  360.           if (ptr1->instr == DEF)          /* delete all references for */
  361.               deletenewin(ptr1->sub->instr);           /* defined instr */
  362.           ptr2 = conend(ptr1);               /* locate end of construct */
  363.           demalloc(ptr1,ptr2);
  364. }
  365.  
  366.  
  367. struct tnode *conbegin(ptr)       /* locates start of current construct */
  368. struct tnode *ptr;
  369. {
  370.           int in;
  371.  
  372.           if (ptr->instr == ND && ptr->del != NEWINSTR) {
  373.               in = ptr->indent;
  374.               while ((ptr = ptr->prev)->indent > in)
  375.                        ;
  376.           }
  377.           while ((ptr = ptr->prev)->cons != 1 || ptr->instr == THEN)
  378.              ;   
  379.           return ptr;
  380. }
  381.  
  382.  
  383. struct tnode *conend(ptr)        /* locates end of current construct */
  384. struct tnode *ptr;
  385. {
  386.           int d,in;
  387.           struct tnode *advance();
  388.  
  389.           in = ptr->indent;
  390.           if (ptr != endof)
  391.              ptr = advance(ptr);
  392.           while (ptr != endof && (ptr->indent > in ||
  393.                  (d = ptr->del) == TEST || d == POSINT || d == NEWINSTR)) 
  394.               ptr = advance(ptr);
  395.           if (ptr == endof && (ptr->indent > in ||
  396.               (d = ptr->del) == TEST || d == POSINT || d == NEWINSTR))
  397.               ptr = p;
  398.           return ptr; 
  399.  
  400. }
  401.  
  402.  
  403. deletenewin(i)                /* removes user-defined instruction */
  404. int i;
  405. {
  406.  
  407.           int j;
  408.           struct tnode *ptr;
  409.  
  410.           j = 0;
  411.           while ((ptr = new[i].loc[j]) != NULL) { 
  412.               demalloc(ptr,ptr->next);        /* locate and delete */
  413.               j++;                                 /* uses in pgm */
  414.           }
  415.           j = first;
  416.           if (j != i) {
  417.              while (new[j].nextin != i)             /* remove sym */
  418.                  j = new[j].nextin ;          /* table references */
  419.              new[j].nextin = new[i].nextin;
  420.           } else if (new[first].nextin == last)
  421.                      --last;
  422.                  else first = new[i].nextin;
  423. }
  424.  
  425.  
  426.  
  427. demalloc(ptr1,ptr2)                 /* free space from ptr1 up to ptr2 */
  428. struct tnode *ptr1,*ptr2;
  429. {
  430.  
  431.           struct tnode *ptr;
  432.       
  433.           printf("\n");
  434.           if (ptr2->instr != NDX || ptr2->del == NEWINSTR)
  435.               ptr2->prec = ptr1->prec;        /* set up links between */
  436.           curr = ptr2;                        /* ptr2 & ptr1's parent */
  437.           ptr = ptr2->prev = ptr1->prev;
  438.           if (ptr1 == ptr->sub &&
  439.              (ptr2->instr != NDX || ptr2->del == NEWINSTR))
  440.               ptr->sub = ptr2;
  441.           else { 
  442.              ptr->next = ptr2;
  443.              if (ptr2->instr == NDX && ptr2->del != NEWINSTR)
  444.                  ptr->sub = NULL;
  445.           }
  446.           while (ptr1 != ptr2) {               /* deallocate nodes in */
  447.               ptr = ptr1;                     /* succession and print */
  448.               if (ptr1->sub != NULL)
  449.                   ptr1 = ptr1->sub;
  450.               else if (ptr1->next != NULL)
  451.                        ptr1 = ptr1->next;
  452.               print(ptr,stdout);
  453.               free((char *)ptr);
  454.           }
  455.           if (ptr2 == p && p != pr) {              /* if last line of */
  456.               endof = temp = curr = ptr1->prev;   /* pgm, set new eof */ 
  457.               pr = ptr1->prec;
  458.               temp->next = p;
  459.           }       
  460. }
  461.  
  462.  
  463. putintable(i)     /* add new name to symbol table */
  464. int i;
  465. {
  466.           int j,k;
  467.  
  468.           if (insert && insertnode->instr == DEF) {
  469.               j = insertnode->sub->instr;         /* if inserting before */
  470.               new[i].nextin = j;                    /* DEF locate proper */
  471.               for (k = first; new[k].nextin != last;)     /* position in */
  472.                    k = new[k].nextin;                     /* linked list */
  473.               new[k].nextin = last + 1;
  474.               if (j == first)
  475.                   first = i;
  476.               else {
  477.                  for (k = first; new[k].nextin != j;)
  478.                       k = new[k].nextin;
  479.                  new[k].nextin = i;
  480.              }                            /* otherwise add as last entry */
  481.           } else new[i].nextin = last + 1;
  482. }   
  483.  
  484.  
  485. savetree(p,argv)         /* write parse tree to file1, text to file2 */
  486. struct tnode *p;
  487. char **argv;
  488. {
  489.           struct tnode *advance(); 
  490.  
  491.           fptr1 = fopen(argv[1],"w");         /* open both files */
  492.           fptr2 = fopen(argv[2],"w");         /* for writing */
  493.           while (p != endof) {
  494.               fprintf(fptr1, "%d %d %d %d %d %d %d %d \n",   /*codes */
  495.                     p->instr,p->indent,p->del,p->nfollow,/* in file1 */
  496.                     p->sfollow,p->comp,p->cons,p->lastin);
  497.               print(p,fptr2);                       /* text in file2 */
  498.               if (p->instr == DEF && p->del == 0) {
  499.                   p = advance(p);
  500.                   fprintf(fptr1,"%d %d %d %d %d %d %d %d \n",
  501.                           p->instr,p->indent,p->del,p->nfollow,
  502.                           p->sfollow,p->comp,p->cons,p->lastin);
  503.                   print(p,fptr2);
  504.                   fprintf(fptr1,"%s \n",new[p->instr].defname);
  505.               }
  506.               p = advance(p);      
  507.            } 
  508.            fprintf(fptr1, "%d %d %d %d %d %d %d %d \n",
  509.                    9,1,5,4,4,0,2,10);
  510.            print(p,fptr2);
  511.            putc(CPMEOF,fptr1);    putc(CPMEOF,fptr2);
  512.            fclose(fptr1);         fclose(fptr2);
  513.          
  514. }
  515.  
  516.  
  517.  
  518. tree(i,in,d,fn,fs,b,t,l)    /* store instruction codes in parse tree */
  519. int i,in,d,fn,fs,b,t,l;
  520. {
  521.          p->sub = NULL;
  522.          p->next = NULL;
  523.          p->prec = pr;
  524.          if (pr->sub != NULL && p == pr->next) {
  525.              p->prev = temp;                       /* set up link to */
  526.              temp = NULL;                    /* previous instruction */
  527.          } else p->prev = pr;
  528.          p->instr = i;
  529.          p->indent = in;
  530.          p->del = d;
  531.          p->nfollow = fn;
  532.          p->sfollow = fs;
  533.          p->comp = b;
  534.          p->cons = t;
  535.          p->lastin = l;
  536.          if (insert)
  537.              tempend = p;     /* last node inserted */
  538.          else endof = p;      /* last node added (eof) */
  539. }
  540.  
  541.  
  542. struct tnode *allocp()      /* get space for next node */
  543. {
  544.           char *malloc();
  545.           struct tnode *ptr;
  546.  
  547.           ptr = (struct tnode *)malloc(24);
  548.           curr = p;
  549.           pr = p;
  550.           return ptr;
  551. }
  552.  
  553.  
  554. inputs(w)         /* read in next command */
  555. char w[];
  556. {
  557.           int i,m;
  558.           char c;
  559.  
  560.           m = 0;
  561.           i = 0;
  562.           while ((c = w[i++] = lower(getchr())) != '\r')
  563.               if ((c > 'z' || c < 'a') && (c > '9' || c < '0') && c != '-') 
  564.                 m = ERROR;
  565.           w[--i] = '\0';
  566.           return m;
  567. }
  568.  
  569.  
  570. match(w,s,maxx)          /* compares string to array element */
  571. char w[], *s[];
  572. int maxx;
  573. {
  574.           int c,i;
  575.  
  576.           for (i = 0; i < maxx; i++) {
  577.             c = strcomp(w,s[i]);
  578.             if (c == 0)                 /* if match, return */
  579.                 return i;                /* array subscript */
  580.           }
  581.           return NOMATCH;            /* else return NOMATCH */
  582. }
  583.  
  584.  
  585. prompt(mess1,num1,mess2,num2,i)       /* prompt for next instruction */
  586. char *mess1,*mess2;
  587. int num1, num2,i;
  588. {
  589.           int j;
  590.  
  591.           printf("%s",mess1);                  /* print first string */
  592.           switch(num1) {           /* print desired instruction type */  
  593.           case 1:
  594.              printf("<test>");
  595.              break;
  596.           case 2:
  597.              printf("<positive-number>");
  598.              break;
  599.           case 3:
  600.              for (j = 0; j < curr->indent;
  601.                          printf("  "), j++);
  602.              if (i == ND || i == NDC) {
  603.                 printf("\b");
  604.                 printf("\b");
  605.              }
  606.              printf("<instruction>");
  607.              break;
  608.           case 4:
  609.              printf("<new-name>");
  610.              break;
  611.           }
  612.           printf("%s",mess2);            /* print second string */
  613.           for (; num2-- > 0; printf("\b"))
  614.             ;
  615. }
  616.  
  617.  
  618. struct tnode *advance(ptr)         /* point to next line or eof */
  619. struct tnode *ptr;
  620. {
  621.           if (ptr->sub != NULL)
  622.               ptr = ptr->sub;
  623.           else if (ptr->next != NULL)
  624.                    ptr = ptr->next;
  625.           return ptr;
  626. }
  627.  
  628.  
  629. checkin(valid)   /* correct location for an instruction? */
  630. int *valid;
  631. {
  632.           int in;
  633.  
  634.           *valid = 1;
  635.           if (p == pr && !insert) {  /* if NDX added, must insert */
  636.               printf("INSERT ONLY\n?");
  637.               *valid = 0;
  638.           } else { 
  639.                if (pr->instr == THEN && p!= pr->sub) {
  640.                    endcons();               /* end THEN construct */
  641.                    if (insert)            /* since ELSE not added */
  642.                       ins = pr->indent;
  643.                }
  644.                if (pr->nfollow == 0 &&           
  645.                           p == pr->next)
  646.                    in = pr->indent;         
  647.                else if (pr->sfollow == 0 && 
  648.                                p == pr->sub)
  649.                         in = pr->indent + 1;
  650.                      else { 
  651.                         *valid = 0;
  652.                         printf("BAD LOCATION FOR COMMAND. ");
  653.                         printf("TYPE MN TO SEE MENU.\n?");
  654.                      }
  655.             }           
  656.           return in;
  657. }
  658.  
  659.  
  660. checkcomp(valid)         /* compound statement? */
  661. int *valid;
  662. {
  663.           int b;
  664.  
  665.           if (pr->comp == 2) {       /* if 2nd instr added without BEGIN */
  666.               *valid = 0;
  667.               printf("STRUCTURE NOT A COMPOUND STATEMENT\n?");
  668.           } else if (pr->comp == 1)  /* if 1st instr added without BEGIN */
  669.                      b = 2;            /* set warning for future entries */
  670.                  else b = pr->comp;
  671.           return b;
  672. }
  673.  
  674.  
  675.  
  676. endcons()         /* end construct */
  677. {  
  678.           int in;
  679.           char *malloc();
  680.   
  681.           if (pr->indent == 1)     /* only BX, NDX indented 1 level */
  682.               printf("LAST POSSIBLE LEVEL\n");   
  683.           else {
  684.              if (temp->next != p     /* keep last instr in previous */
  685.                  || temp == NULL)               
  686.                  temp = pr;            /* construct if NDC repeated */
  687.              do {
  688.               in = pr->indent;
  689.               while ((pr = pr->prev)->cons != 1 /* go back to start */
  690.                       || pr->indent >= in);         /* of construct */
  691.              } while (pr->instr == ELS);               /* skip ELSE */
  692.              if (pr->instr == DEF)          /* if DEF ended add new */
  693.                  last++;                         /* name to sym tab */
  694.              pr->next = (struct tnode *)malloc(24);
  695.              free((char *)p);
  696.              p = temp->next = pr->next;
  697.           } 
  698. }    
  699.  
  700.  
  701. strcomp(s1,s2)
  702. char s1[],s2[];
  703. {
  704.           int i;
  705.  
  706.           i = 0;
  707.           while (s1[i] == s2[i])
  708.              if (s1[i++] == '\0' || i == 8)
  709.                 return 0;
  710.           return s1[i] - s2[i];
  711. }
  712.