![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bed.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / basic / bite / src|
Return to bed.c CVS log | Up to [Research Unix] / researchv10no / cmd / basic / bite / src |
1.1 ! root 1: /* Copyright Bell Telephone Laboratories Whippany, N.J. ! 2: ! 3: * *********************************** ! 4: * *********************************** ! 5: * ***** BITE INPUT TEXT EDITOR ****** ! 6: * *** R. B. Drake WH 8C-005 X4163 *** ! 7: * **** Fri Aug 24 15:21:32 1979 ***** ! 8: * *********************************** ! 9: * *********************************** ! 10: * This routine handles all text input to bite. Text may originate from ! 11: * a tty or from a UNIX file or data placed in a string array. Certain ! 12: * syntax error messages are issued and all housekeeping having to do ! 13: * with line numbers and the page index is handled here. ! 14: ! 15: */ ! 16: /* "@(#) bed.c: V 1.3 11/12/81" */ ! 17: ! 18: #include "bas.h" ! 19: char *linptr; /* ALWAYS points to the next available ! 20: byte in the program txtbuf */ ! 21: char *endob = txtbuf + (NMPAG * PGSIZ); ! 22: char _string[LINMAX]; ! 23: union bascmd local; ! 24: union bascmd inst; ! 25: char linbuf[LINMAX]; ! 26: char ascno[NOMAX],ascop[OPMAX]; ! 27: struct pages index[NMPAG+1]; ! 28: int pg; ! 29: static int size; ! 30: char *curptr; /* fetch sets this to point to the beginning of the ! 31: current line. Other routines may change it */ ! 32: char *lbdptr; /* fetch sets this to point to the beginning ! 33: of the next sequential line in the txtbuf */ ! 34: extern int singflg; ! 35: extern int tv; ! 36: /* This table is used to encode and decode certain key-worde for ! 37: storage compression and for ease of recognition by the execution ! 38: software */ ! 39: char *keyword[] = ! 40: { ! 41: "goto", /* 1 */ ! 42: "go to", /* 2 */ ! 43: "then", /* 3 */ ! 44: "to", /* 4 */ ! 45: "step", /* 5 */ ! 46: "<>", /* 6 */ ! 47: "<=", /* 7 */ ! 48: "=<", /* 10 */ ! 49: "<", /* 11 */ ! 50: ">=", /* 12 */ ! 51: "=>", /* 13 */ ! 52: ">", /* 14 */ ! 53: "=", /* 15 */ ! 54: "gosub", /* 16 */ ! 55: "more", /* 17 */ ! 56: 0 }; ! 57: extern int rem; ! 58: extern int _sub; ! 59: extern int tel; ! 60: extern int stpflg; ! 61: extern int autflg,aut,inc; ! 62: bed(fp) ! 63: FILE *fp; ! 64: { ! 65: register char *to,*from; ! 66: int i,j,k,nlflg,quoflg,parflg,bflg; ! 67: int erflg; ! 68: char c,*strptr; ! 69: char *pt,*save; ! 70: char *isthere(); ! 71: ! 72: /* zero the working txtbufs */ ! 73: strptr=_string; ! 74: for(i=0;i<NOMAX;ascno[i++]=0); ! 75: for(i=0;i<OPMAX;ascop[i++]=0); ! 76: for(i=0;i<LINMAX;linbuf[i++]=0); ! 77: local.thing.opcode.lobyte=local.thing.opcode.hibyte='\0'; ! 78: local.thing.linno=nlflg=stpflg=0; ! 79: expr = linbuf; ! 80: if(autflg != 0) /* if auto line numbering in affect */ ! 81: { ! 82: aut += inc; ! 83: sprintf(ascno,"%d",aut); ! 84: } ! 85: /* print the prompt character */ ! 86: if(fp != 0) ! 87: if(isatty(fileno(fp))) ! 88: printf("*%s",ascno); ! 89: if(fp != 0) ! 90: if(fgets(_string,LINMAX,fp) == 0) return(-1); /* EOF */ ! 91: /* get a line of input from the user and store it in compressed ! 92: * source form unless the line number is zero in which case ! 93: * execute the instruction immediately ! 94: */ ! 95: /* get the line number if any */ ! 96: while(*strptr == ' ' || *strptr == ' ') ! 97: strptr++; /* ignore leading white space */ ! 98: for(i=0,k=0;num((c= *strptr++)) && i < (NOMAX-1);i++) ! 99: { ! 100: ascno[i]=c; ! 101: aut = atoi(ascno); ! 102: } ! 103: if(ascno[0] != '\0') ! 104: if((local.thing.linno = aut) == 0) ! 105: { ! 106: error(0,0); ! 107: return(0); ! 108: } ! 109: if(c== '\n') ! 110: { ! 111: if(local.thing.linno == 0 || autflg) ! 112: { ! 113: if(fetch(-1,&lbdptr) != 0) ! 114: { ! 115: if(fetch(0,&lbdptr) != 0) ! 116: { ! 117: error(0,1); ! 118: return(0); ! 119: } ! 120: } ! 121: prin(); ! 122: if(autflg) aut -= inc; ! 123: return(0); ! 124: } ! 125: /*a line number was entered ! 126: * but nothing followed which implies ! 127: *delete ! 128: */ ! 129: delete(); ! 130: return(0); ! 131: } ! 132: /* if no blank was used as a delimiter, then insure ! 133: * that we don't lose the first character of the opcode.lobyte ! 134: */ ! 135: if( c == '.') /* if auto line num to be tuned off */ ! 136: { ! 137: autflg=0; ! 138: aut -= inc; ! 139: return(0); ! 140: } ! 141: if(c== '\t') ! 142: { ! 143: local.thing.opcode.hibyte = '\201'; ! 144: while(*strptr == '\t') ! 145: { ! 146: local.thing.opcode.hibyte = (local.thing.opcode.hibyte&0377) + 1; ! 147: strptr++; ! 148: } ! 149: } ! 150: if( c != ' ' && c != '\t') ! 151: { ! 152: ascop[0] = c; ! 153: k=1; ! 154: } ! 155: /* get the operation statement */ ! 156: bflg=0; ! 157: for(j=0,i=k;(c= *strptr);i++) ! 158: { ! 159: if((c== ' ') && (strcmp("go",ascop) != 0)) ! 160: { ! 161: bflg=1; ! 162: while((c= *strptr) == ' ' || c== '\014') ! 163: strptr++; ! 164: } ! 165: /* if an "=" is present here then the ! 166: *opcode.lobyte is "let" by default */ ! 167: if(c== '=' || (c== '(' && bflg != 1)) ! 168: { ! 169: ascop[i]=c; ! 170: strcpy(linbuf,ascop); ! 171: strcpy(ascop,"\010"); ! 172: j=i+1; ! 173: strptr++; ! 174: break; ! 175: } ! 176: /* If a new line is present here then ! 177: * we have an operation with ! 178: * no following expression ! 179: */ ! 180: if(c== '\n') ! 181: { ! 182: nlflg=1; ! 183: ascop[i]='\0'; ! 184: break; ! 185: } ! 186: if( i< (OPMAX -1)) ! 187: { ! 188: if( bflg == 1) break; ! 189: ascop[i]=c; ! 190: } ! 191: strptr++; ! 192: } ! 193: if(ascop[0] !=0) ! 194: { ! 195: int xxx = encode(ascop); ! 196: ! 197: local.thing.opcode.lobyte = xxx; ! 198: if(xxx == -1) ! 199: { ! 200: error(local.thing.linno,1); ! 201: local.thing.opcode.lobyte=tel; ! 202: pt = strcat(linbuf,ascop); ! 203: pt = carcat(linbuf,' '); ! 204: erflg=1; ! 205: j = pt - linbuf; ! 206: } ! 207: else erflg=0; ! 208: } ! 209: if(!nlflg) ! 210: { ! 211: /* put any expression in "linbuf" */ ! 212: for(i=j;(c= *strptr++) != '\n';i++) ! 213: { ! 214: if(i < (LINMAX -1)) ! 215: linbuf[i]=c; ! 216: } ! 217: /* encode keywords in the expression field */ ! 218: while(1) ! 219: { ! 220: if(!nocode(local.thing.opcode.lobyte) && erflg == 0) ! 221: { ! 222: /* first strip any blanks and control characters ! 223: * out of the expression unless they are quoted */ ! 224: quoflg = 1; ! 225: parflg= 0; ! 226: for(i=0,j=0;linbuf[i] != '\0';i++) ! 227: if(linbuf[i] > '\040' || quoflg== -1) ! 228: { ! 229: linbuf[j++]=linbuf[i]; ! 230: switch (linbuf[i]) ! 231: { ! 232: case '"' : quoflg *= -1; ! 233: break; ! 234: case '(' : parflg += 1; ! 235: break; ! 236: case ')' : parflg -= 1; ! 237: break; ! 238: } ! 239: } ! 240: linbuf[j]='\0'; ! 241: if(quoflg == -1) ! 242: { ! 243: error(local.thing.linno,11); ! 244: } ! 245: if(parflg != 0) ! 246: { ! 247: error(local.thing.linno,16); ! 248: } ! 249: for(i=0;keyword[i] != 0;i++) ! 250: while((pt=isthere(keyword[i],linbuf,1)) != 0) ! 251: { ! 252: *pt++='\001'+i; ! 253: shrink(pt); ! 254: } ! 255: } ! 256: break; ! 257: } ! 258: } ! 259: /* If the line number is zero then we have ! 260: * a command for immediate execution ! 261: */ ! 262: if( k != 0) ! 263: { ! 264: inst.thing.linno = 0; ! 265: expr=linbuf; ! 266: if(local.thing.opcode.lobyte == tv) ! 267: list(1); ! 268: else ! 269: { ! 270: bascall(local.thing.opcode.lobyte); ! 271: if(autflg) ! 272: aut -= inc; ! 273: } ! 274: return(0); ! 275: } ! 276: /* if a ligitimate line number has been entered ! 277: *put it in the program txtbuf ! 278: */ ! 279: if(singflg != 0) /* don't permit txtbuf editing in single step */ ! 280: { ! 281: error(0,12); ! 282: return(0); /* not fatal */ ! 283: } ! 284: if(fetch(local.thing.linno,&lbdptr) == -1) inst.thing.linno = 0; ! 285: save=curptr; ! 286: /* if local.thing.linno is greater than inst.thing.linno (returned by fetch) ! 287: * then fetch has returned the last line of the program ! 288: * and the action is to add the new line to the end of the ! 289: * program */ ! 290: if(local.thing.linno > inst.thing.linno) ! 291: { ! 292: pg=(linptr-txtbuf)/PGSIZ; /* calculate page number*/ ! 293: if(index[pg].maxlin == 0) ! 294: { ! 295: index[pg].maxlin = local.thing.linno; /*first line*/ ! 296: index[pg].begin=linptr; ! 297: } ! 298: if(local.thing.linno > index[pg].maxlin) ! 299: index[pg].maxlin=local.thing.linno; ! 300: for(i=0;i<4;i++) ! 301: *linptr++=local.byte[i]; ! 302: expr = linptr; ! 303: for(i=0;linbuf[i] != 0;i++) ! 304: *linptr++=linbuf[i]; ! 305: *linptr++='\0'; /* end the expression string */ ! 306: linptr[0]='\0'; /* make it an eof mark */ ! 307: linptr[1]= '\0'; ! 308: } ! 309: /* if local.thing.linno is less than inst.thing.linno, then the new ! 310: * line must be inserted into the program txtbuf. In order ! 311: * to do that, the current line and all lines above it ! 312: * must be slid up to make room for the new line */ ! 313: if(local.thing.linno < inst.thing.linno) /* insert case */ ! 314: { ! 315: /* make room */ ! 316: clear(); /*clear page index from current page up */ ! 317: from = linptr; ! 318: linptr += strlen(linbuf) + 5; ! 319: to = linptr; ! 320: *linptr = '\0'; /*insure an eof mark*/ ! 321: linptr[1] = '\0'; ! 322: linptr[2] = '\0'; /* eof requires one 0 to end an expression ! 323: string and two to mark eof */ ! 324: while(from != curptr) ! 325: *--to = *--from; ! 326: put(); ! 327: update(); /* rebuild page index */ ! 328: lbdptr=curptr=save; ! 329: return(0); ! 330: } ! 331: /* if we arrive at this place in the program, local.thing.linno is ! 332: * by default equal to inst.thing.linno and the action is to replace ! 333: * the current line with the new one. There are three possible ! 334: * vvariations in the replacement algorithm. 1) the new line ! 335: * and the old one are the same size in which case the action ! 336: * is a simple replacement. 2) the new line is shorter than the ! 337: * old one in which case the action is to replace the old line ! 338: * and slide the remaining txtbuf down to reclaim the left over ! 339: * space. 3) the new line is longer than the old one in which ! 340: * case the txtbuf above the current line must be slid up by ! 341: * an amount equal to the difference in length to make room ! 342: * for the new line */ ! 343: ! 344: size = strlen(expr) - strlen(linbuf); ! 345: if(size == 0) /*case 1 */ ! 346: { ! 347: put(); ! 348: lbdptr=curptr=save; ! 349: return(0); ! 350: } ! 351: if(size > 0) /* case 2 */ ! 352: { ! 353: put(); ! 354: cover(lbdptr,curptr); ! 355: lbdptr=curptr=save; ! 356: return(0); ! 357: ! 358: } ! 359: clear(); /* case 3 by default of not being either 1 or 2 */ ! 360: from = linptr; ! 361: linptr -= size; ! 362: to = linptr; ! 363: while(from != curptr) ! 364: *--to = *--from; ! 365: put(); ! 366: update(); ! 367: lbdptr=curptr=save; ! 368: return(0); ! 369: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.