![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to proc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 40BSD / cmd / pc0|
Return to proc.c CVS log | Up to [CSRG BSD Unix] / 40BSD / cmd / pc0 |
1.1 ! root 1: /* Copyright (c) 1979 Regents of the University of California */ ! 2: ! 3: static char sccsid[] = "@(#)proc.c 1.3 10/28/80"; ! 4: ! 5: #include "whoami.h" ! 6: #ifdef OBJ ! 7: /* ! 8: * and the rest of the file ! 9: */ ! 10: #include "0.h" ! 11: #include "tree.h" ! 12: #include "opcode.h" ! 13: #include "objfmt.h" ! 14: ! 15: /* ! 16: * The following array is used to determine which classes may be read ! 17: * from textfiles. It is indexed by the return value from classify. ! 18: */ ! 19: #define rdops(x) rdxxxx[(x)-(TFIRST)] ! 20: ! 21: int rdxxxx[] = { ! 22: 0, /* -7 file types */ ! 23: 0, /* -6 record types */ ! 24: 0, /* -5 array types */ ! 25: O_READE, /* -4 scalar types */ ! 26: 0, /* -3 pointer types */ ! 27: 0, /* -2 set types */ ! 28: 0, /* -1 string types */ ! 29: 0, /* 0 nil, no type */ ! 30: O_READE, /* 1 boolean */ ! 31: O_READC, /* 2 character */ ! 32: O_READ4, /* 3 integer */ ! 33: O_READ8 /* 4 real */ ! 34: }; ! 35: ! 36: /* ! 37: * Proc handles procedure calls. ! 38: * Non-builtin procedures are "buck-passed" to func (with a flag ! 39: * indicating that they are actually procedures. ! 40: * builtin procedures are handled here. ! 41: */ ! 42: proc(r) ! 43: int *r; ! 44: { ! 45: register struct nl *p; ! 46: register int *alv, *al, op; ! 47: struct nl *filetype, *ap; ! 48: int argc, *argv, typ, fmtspec, strfmt, stkcnt, *file; ! 49: char fmt, format[20], *strptr; ! 50: int prec, field, strnglen, fmtlen, fmtstart, pu; ! 51: int *pua, *pui, *puz; ! 52: int i, j, k; ! 53: int itemwidth; ! 54: ! 55: #define CONPREC 4 ! 56: #define VARPREC 8 ! 57: #define CONWIDTH 1 ! 58: #define VARWIDTH 2 ! 59: #define SKIP 16 ! 60: ! 61: /* ! 62: * Verify that the name is ! 63: * defined and is that of a ! 64: * procedure. ! 65: */ ! 66: p = lookup(r[2]); ! 67: if (p == NIL) { ! 68: rvlist(r[3]); ! 69: return; ! 70: } ! 71: if (p->class != PROC && p->class != FPROC) { ! 72: error("Can't call %s, its %s not a procedure", p->symbol, classes[p->class]); ! 73: rvlist(r[3]); ! 74: return; ! 75: } ! 76: argv = r[3]; ! 77: ! 78: /* ! 79: * Call handles user defined ! 80: * procedures and functions. ! 81: */ ! 82: if (bn != 0) { ! 83: call(p, argv, PROC, bn); ! 84: return; ! 85: } ! 86: ! 87: /* ! 88: * Call to built-in procedure. ! 89: * Count the arguments. ! 90: */ ! 91: argc = 0; ! 92: for (al = argv; al != NIL; al = al[2]) ! 93: argc++; ! 94: ! 95: /* ! 96: * Switch on the operator ! 97: * associated with the built-in ! 98: * procedure in the namelist ! 99: */ ! 100: op = p->value[0] &~ NSTAND; ! 101: if (opt('s') && (p->value[0] & NSTAND)) { ! 102: standard(); ! 103: error("%s is a nonstandard procedure", p->symbol); ! 104: } ! 105: switch (op) { ! 106: ! 107: case O_ABORT: ! 108: if (argc != 0) ! 109: error("null takes no arguments"); ! 110: return; ! 111: ! 112: case O_FLUSH: ! 113: if (argc == 0) { ! 114: put(1, O_MESSAGE); ! 115: return; ! 116: } ! 117: if (argc != 1) { ! 118: error("flush takes at most one argument"); ! 119: return; ! 120: } ! 121: ap = stkrval(argv[1], NIL , RREQ ); ! 122: if (ap == NIL) ! 123: return; ! 124: if (ap->class != FILET) { ! 125: error("flush's argument must be a file, not %s", nameof(ap)); ! 126: return; ! 127: } ! 128: put(1, op); ! 129: return; ! 130: ! 131: case O_MESSAGE: ! 132: case O_WRITEF: ! 133: case O_WRITLN: ! 134: /* ! 135: * Set up default file "output"'s type ! 136: */ ! 137: file = NIL; ! 138: filetype = nl+T1CHAR; ! 139: /* ! 140: * Determine the file implied ! 141: * for the write and generate ! 142: * code to make it the active file. ! 143: */ ! 144: if (op == O_MESSAGE) { ! 145: /* ! 146: * For message, all that matters ! 147: * is that the filetype is ! 148: * a character file. ! 149: * Thus "output" will suit us fine. ! 150: */ ! 151: put(1, O_MESSAGE); ! 152: } else if (argv != NIL && (al = argv[1])[0] != T_WEXP) { ! 153: /* ! 154: * If there is a first argument which has ! 155: * no write widths, then it is potentially ! 156: * a file name. ! 157: */ ! 158: codeoff(); ! 159: ap = stkrval(argv[1], NIL , RREQ ); ! 160: codeon(); ! 161: if (ap == NIL) ! 162: argv = argv[2]; ! 163: if (ap != NIL && ap->class == FILET) { ! 164: /* ! 165: * Got "write(f, ...", make ! 166: * f the active file, and save ! 167: * it and its type for use in ! 168: * processing the rest of the ! 169: * arguments to write. ! 170: */ ! 171: file = argv[1]; ! 172: filetype = ap->type; ! 173: stkrval(argv[1], NIL , RREQ ); ! 174: put(1, O_UNIT); ! 175: /* ! 176: * Skip over the first argument ! 177: */ ! 178: argv = argv[2]; ! 179: argc--; ! 180: } else ! 181: /* ! 182: * Set up for writing on ! 183: * standard output. ! 184: */ ! 185: put(1, O_UNITOUT); ! 186: } else ! 187: put(1, O_UNITOUT); ! 188: /* ! 189: * Loop and process each ! 190: * of the arguments. ! 191: */ ! 192: for (; argv != NIL; argv = argv[2]) { ! 193: /* ! 194: * fmtspec indicates the type (CONstant or VARiable) ! 195: * and number (none, WIDTH, and/or PRECision) ! 196: * of the fields in the printf format for this ! 197: * output variable. ! 198: * stkcnt is the number of longs pushed on the stack ! 199: * fmt is the format output indicator (D, E, F, O, X, S) ! 200: * fmtstart = 0 for leading blank; = 1 for no blank ! 201: */ ! 202: fmtspec = NIL; ! 203: stkcnt = 0; ! 204: fmt = 'D'; ! 205: fmtstart = 1; ! 206: al = argv[1]; ! 207: if (al == NIL) ! 208: continue; ! 209: if (al[0] == T_WEXP) ! 210: alv = al[1]; ! 211: else ! 212: alv = al; ! 213: if (alv == NIL) ! 214: continue; ! 215: codeoff(); ! 216: ap = stkrval(alv, NIL , RREQ ); ! 217: codeon(); ! 218: if (ap == NIL) ! 219: continue; ! 220: typ = classify(ap); ! 221: if (al[0] == T_WEXP) { ! 222: /* ! 223: * Handle width expressions. ! 224: * The basic game here is that width ! 225: * expressions get evaluated. If they ! 226: * are constant, the value is placed ! 227: * directly in the format string. ! 228: * Otherwise the value is pushed onto ! 229: * the stack and an indirection is ! 230: * put into the format string. ! 231: */ ! 232: if (al[3] == OCT) ! 233: fmt = 'O'; ! 234: else if (al[3] == HEX) ! 235: fmt = 'X'; ! 236: else if (al[3] != NIL) { ! 237: /* ! 238: * Evaluate second format spec ! 239: */ ! 240: if ( constval(al[3]) ! 241: && isa( con.ctype , "i" ) ) { ! 242: fmtspec += CONPREC; ! 243: prec = con.crval; ! 244: } else { ! 245: fmtspec += VARPREC; ! 246: } ! 247: fmt = 'f'; ! 248: switch ( typ ) { ! 249: case TINT: ! 250: if ( opt( 's' ) ) { ! 251: standard(); ! 252: error("Writing %ss with two write widths is non-standard", clnames[typ]); ! 253: } ! 254: /* and fall through */ ! 255: case TDOUBLE: ! 256: break; ! 257: default: ! 258: error("Cannot write %ss with two write widths", clnames[typ]); ! 259: continue; ! 260: } ! 261: } ! 262: /* ! 263: * Evaluate first format spec ! 264: */ ! 265: if (al[2] != NIL) { ! 266: if ( constval(al[2]) ! 267: && isa( con.ctype , "i" ) ) { ! 268: fmtspec += CONWIDTH; ! 269: field = con.crval; ! 270: } else { ! 271: fmtspec += VARWIDTH; ! 272: } ! 273: } ! 274: if ((fmtspec & CONPREC) && prec < 0 || ! 275: (fmtspec & CONWIDTH) && field < 0) { ! 276: error("Negative widths are not allowed"); ! 277: continue; ! 278: } ! 279: } ! 280: if (filetype != nl+T1CHAR) { ! 281: if (fmt == 'O' || fmt == 'X') { ! 282: error("Oct/hex allowed only on text files"); ! 283: continue; ! 284: } ! 285: if (fmtspec) { ! 286: error("Write widths allowed only on text files"); ! 287: continue; ! 288: } ! 289: /* ! 290: * Generalized write, i.e. ! 291: * to a non-textfile. ! 292: */ ! 293: stkrval(file, NIL , RREQ ); ! 294: put(1, O_FNIL); ! 295: /* ! 296: * file^ := ... ! 297: */ ! 298: ap = rvalue(argv[1], NIL); ! 299: if (ap == NIL) ! 300: continue; ! 301: if (incompat(ap, filetype, argv[1])) { ! 302: cerror("Type mismatch in write to non-text file"); ! 303: continue; ! 304: } ! 305: convert(ap, filetype); ! 306: put(2, O_AS, width(filetype)); ! 307: /* ! 308: * put(file) ! 309: */ ! 310: put(1, O_PUT); ! 311: continue; ! 312: } ! 313: /* ! 314: * Write to a textfile ! 315: * ! 316: * Evaluate the expression ! 317: * to be written. ! 318: */ ! 319: if (fmt == 'O' || fmt == 'X') { ! 320: if (opt('s')) { ! 321: standard(); ! 322: error("Oct and hex are non-standard"); ! 323: } ! 324: if (typ == TSTR || typ == TDOUBLE) { ! 325: error("Can't write %ss with oct/hex", clnames[typ]); ! 326: continue; ! 327: } ! 328: if (typ == TCHAR || typ == TBOOL) ! 329: typ = TINT; ! 330: } ! 331: /* ! 332: * Place the arguement on the stack. If there is ! 333: * no format specified by the programmer, implement ! 334: * the default. ! 335: */ ! 336: switch (typ) { ! 337: case TINT: ! 338: if (fmt != 'f') { ! 339: ap = stkrval(alv, NIL , RREQ ); ! 340: stkcnt++; ! 341: } else { ! 342: ap = stkrval(alv, NIL , RREQ ); ! 343: put(1, O_ITOD); ! 344: stkcnt += 2; ! 345: typ = TDOUBLE; ! 346: goto tdouble; ! 347: } ! 348: if (fmtspec == NIL) { ! 349: if (fmt == 'D') ! 350: field = 10; ! 351: else if (fmt == 'X') ! 352: field = 8; ! 353: else if (fmt == 'O') ! 354: field = 11; ! 355: else ! 356: panic("fmt1"); ! 357: fmtspec = CONWIDTH; ! 358: } ! 359: break; ! 360: case TCHAR: ! 361: tchar: ! 362: ap = stkrval(alv, NIL , RREQ ); ! 363: stkcnt++; ! 364: fmt = 'c'; ! 365: break; ! 366: case TSCAL: ! 367: warning(); ! 368: if (opt('s')) { ! 369: standard(); ! 370: } ! 371: error("Writing scalars to text files is non-standard"); ! 372: case TBOOL: ! 373: stkrval(alv, NIL , RREQ ); ! 374: put(2, O_NAM, listnames(ap)); ! 375: stkcnt++; ! 376: fmt = 's'; ! 377: break; ! 378: case TDOUBLE: ! 379: ap = stkrval(alv, TDOUBLE , RREQ ); ! 380: stkcnt += 2; ! 381: tdouble: ! 382: switch (fmtspec) { ! 383: case NIL: ! 384: field = 21; ! 385: prec = 14; ! 386: fmt = 'E'; ! 387: fmtspec = CONWIDTH + CONPREC; ! 388: break; ! 389: case CONWIDTH: ! 390: if (--field < 1) ! 391: field = 1; ! 392: prec = field - 7; ! 393: if (prec < 1) ! 394: prec = 1; ! 395: fmtspec += CONPREC; ! 396: fmt = 'E'; ! 397: break; ! 398: case CONWIDTH + CONPREC: ! 399: case CONWIDTH + VARPREC: ! 400: if (--field < 1) ! 401: field = 1; ! 402: } ! 403: format[0] = ' '; ! 404: fmtstart = 0; ! 405: break; ! 406: case TSTR: ! 407: constval( alv ); ! 408: switch ( classify( con.ctype ) ) { ! 409: case TCHAR: ! 410: typ = TCHAR; ! 411: goto tchar; ! 412: case TSTR: ! 413: strptr = con.cpval; ! 414: for (strnglen = 0; *strptr++; strnglen++) /* void */; ! 415: strptr = con.cpval; ! 416: break; ! 417: default: ! 418: strnglen = width(ap); ! 419: break; ! 420: } ! 421: fmt = 's'; ! 422: strfmt = fmtspec; ! 423: if (fmtspec == NIL) { ! 424: fmtspec = SKIP; ! 425: break; ! 426: } ! 427: if (fmtspec & CONWIDTH) { ! 428: if (field <= strnglen) { ! 429: fmtspec = SKIP; ! 430: break; ! 431: } else ! 432: field -= strnglen; ! 433: } ! 434: /* ! 435: * push string to implement leading blank padding ! 436: */ ! 437: put(2, O_LVCON, 2); ! 438: putstr("", 0); ! 439: stkcnt++; ! 440: break; ! 441: default: ! 442: error("Can't write %ss to a text file", clnames[typ]); ! 443: continue; ! 444: } ! 445: /* ! 446: * If there is a variable precision, evaluate it onto ! 447: * the stack ! 448: */ ! 449: if (fmtspec & VARPREC) { ! 450: ap = stkrval(al[3], NIL , RREQ ); ! 451: if (ap == NIL) ! 452: continue; ! 453: if (isnta(ap,"i")) { ! 454: error("Second write width must be integer, not %s", nameof(ap)); ! 455: continue; ! 456: } ! 457: if ( opt( 't' ) ) { ! 458: put(3, O_MAX, 0, 0); ! 459: } ! 460: stkcnt++; ! 461: } ! 462: /* ! 463: * If there is a variable width, evaluate it onto ! 464: * the stack ! 465: */ ! 466: if (fmtspec & VARWIDTH) { ! 467: if ( ( typ == TDOUBLE && fmtspec == VARWIDTH ) ! 468: || typ == TSTR ) { ! 469: i = sizes[cbn].om_off -= sizeof(int); ! 470: if (i < sizes[cbn].om_max) ! 471: sizes[cbn].om_max = i; ! 472: put(2, O_LV | cbn << 8 + INDX, i); ! 473: } ! 474: ap = stkrval(al[2], NIL , RREQ ); ! 475: if (ap == NIL) ! 476: continue; ! 477: if (isnta(ap,"i")) { ! 478: error("First write width must be integer, not %s", nameof(ap)); ! 479: continue; ! 480: } ! 481: stkcnt++; ! 482: /* ! 483: * Perform special processing on widths based ! 484: * on data type ! 485: */ ! 486: switch (typ) { ! 487: case TDOUBLE: ! 488: if (fmtspec == VARWIDTH) { ! 489: fmt = 'E'; ! 490: put(1, O_AS4); ! 491: put(2, O_RV4 | cbn << 8 + INDX, i); ! 492: put(3, O_MAX, 8, 1); ! 493: put(2, O_RV4 | cbn << 8 + INDX, i); ! 494: stkcnt++; ! 495: fmtspec += VARPREC; ! 496: } ! 497: put(3, O_MAX, 1, 1); ! 498: break; ! 499: case TSTR: ! 500: put(1, O_AS4); ! 501: put(2, O_RV4 | cbn << 8 + INDX, i); ! 502: put(3, O_MAX, strnglen, 0); ! 503: break; ! 504: default: ! 505: if ( opt( 't' ) ) { ! 506: put(3, O_MAX, 0, 0); ! 507: } ! 508: break; ! 509: } ! 510: } ! 511: /* ! 512: * Generate the format string ! 513: */ ! 514: switch (fmtspec) { ! 515: default: ! 516: panic("fmt2"); ! 517: case NIL: ! 518: if (fmt == 'c') ! 519: put(1, O_WRITEC); ! 520: else { ! 521: sprintf(&format[1], "%%%c", fmt); ! 522: goto fmtgen; ! 523: } ! 524: case SKIP: ! 525: break; ! 526: case CONWIDTH: ! 527: sprintf(&format[1], "%%%1D%c", field, fmt); ! 528: goto fmtgen; ! 529: case VARWIDTH: ! 530: sprintf(&format[1], "%%*%c", fmt); ! 531: goto fmtgen; ! 532: case CONWIDTH + CONPREC: ! 533: sprintf(&format[1], "%%%1D.%1D%c", field, prec, fmt); ! 534: goto fmtgen; ! 535: case CONWIDTH + VARPREC: ! 536: sprintf(&format[1], "%%%1D.*%c", field, fmt); ! 537: goto fmtgen; ! 538: case VARWIDTH + CONPREC: ! 539: sprintf(&format[1], "%%*.%1D%c", prec, fmt); ! 540: goto fmtgen; ! 541: case VARWIDTH + VARPREC: ! 542: sprintf(&format[1], "%%*.*%c", fmt); ! 543: fmtgen: ! 544: fmtlen = lenstr(&format[fmtstart], 0); ! 545: put(2, O_LVCON, fmtlen); ! 546: putstr(&format[fmtstart], 0); ! 547: put(1, O_FILE); ! 548: stkcnt += 2; ! 549: put(2, O_WRITEF, stkcnt); ! 550: } ! 551: /* ! 552: * Write the string after its blank padding ! 553: */ ! 554: if (typ == TSTR) { ! 555: put(1, O_FILE); ! 556: put(2, O_CON24, 1); ! 557: if (strfmt & VARWIDTH) { ! 558: put(2, O_RV4 | cbn << 8 + INDX , i ); ! 559: put(2, O_MIN, strnglen); ! 560: } else { ! 561: if ((fmtspec & SKIP) && ! 562: (strfmt & CONWIDTH)) { ! 563: strnglen = field; ! 564: } ! 565: put(2, O_CON24, strnglen); ! 566: } ! 567: ap = stkrval(alv, NIL , RREQ ); ! 568: put(1, O_WRITES); ! 569: } ! 570: } ! 571: /* ! 572: * Done with arguments. ! 573: * Handle writeln and ! 574: * insufficent number of args. ! 575: */ ! 576: switch (p->value[0] &~ NSTAND) { ! 577: case O_WRITEF: ! 578: if (argc == 0) ! 579: error("Write requires an argument"); ! 580: break; ! 581: case O_MESSAGE: ! 582: if (argc == 0) ! 583: error("Message requires an argument"); ! 584: case O_WRITLN: ! 585: if (filetype != nl+T1CHAR) ! 586: error("Can't 'writeln' a non text file"); ! 587: put(1, O_WRITLN); ! 588: break; ! 589: } ! 590: return; ! 591: ! 592: case O_READ4: ! 593: case O_READLN: ! 594: /* ! 595: * Set up default ! 596: * file "input". ! 597: */ ! 598: file = NIL; ! 599: filetype = nl+T1CHAR; ! 600: /* ! 601: * Determine the file implied ! 602: * for the read and generate ! 603: * code to make it the active file. ! 604: */ ! 605: if (argv != NIL) { ! 606: codeoff(); ! 607: ap = stkrval(argv[1], NIL , RREQ ); ! 608: codeon(); ! 609: if (ap == NIL) ! 610: argv = argv[2]; ! 611: if (ap != NIL && ap->class == FILET) { ! 612: /* ! 613: * Got "read(f, ...", make ! 614: * f the active file, and save ! 615: * it and its type for use in ! 616: * processing the rest of the ! 617: * arguments to read. ! 618: */ ! 619: file = argv[1]; ! 620: filetype = ap->type; ! 621: stkrval(argv[1], NIL , RREQ ); ! 622: put(1, O_UNIT); ! 623: argv = argv[2]; ! 624: argc--; ! 625: } else { ! 626: /* ! 627: * Default is read from ! 628: * standard input. ! 629: */ ! 630: put(1, O_UNITINP); ! 631: input->nl_flags |= NUSED; ! 632: } ! 633: } else { ! 634: put(1, O_UNITINP); ! 635: input->nl_flags |= NUSED; ! 636: } ! 637: /* ! 638: * Loop and process each ! 639: * of the arguments. ! 640: */ ! 641: for (; argv != NIL; argv = argv[2]) { ! 642: /* ! 643: * Get the address of the target ! 644: * on the stack. ! 645: */ ! 646: al = argv[1]; ! 647: if (al == NIL) ! 648: continue; ! 649: if (al[0] != T_VAR) { ! 650: error("Arguments to %s must be variables, not expressions", p->symbol); ! 651: continue; ! 652: } ! 653: ap = stklval(al, MOD|ASGN|NOUSE); ! 654: if (ap == NIL) ! 655: continue; ! 656: if (filetype != nl+T1CHAR) { ! 657: /* ! 658: * Generalized read, i.e. ! 659: * from a non-textfile. ! 660: */ ! 661: if (incompat(filetype, ap, argv[1] )) { ! 662: error("Type mismatch in read from non-text file"); ! 663: continue; ! 664: } ! 665: /* ! 666: * var := file ^; ! 667: */ ! 668: if (file != NIL) ! 669: stkrval(file, NIL , RREQ ); ! 670: else /* Magic */ ! 671: put(2, O_RV2, input->value[0]); ! 672: put(1, O_FNIL); ! 673: put(2, O_IND, width(filetype)); ! 674: convert(filetype, ap); ! 675: if (isa(ap, "bsci")) ! 676: rangechk(ap, ap); ! 677: put(2, O_AS, width(ap)); ! 678: /* ! 679: * get(file); ! 680: */ ! 681: put(1, O_GET); ! 682: continue; ! 683: } ! 684: typ = classify(ap); ! 685: op = rdops(typ); ! 686: if (op == NIL) { ! 687: error("Can't read %ss from a text file", clnames[typ]); ! 688: continue; ! 689: } ! 690: if (op != O_READE) ! 691: put(1, op); ! 692: else { ! 693: put(2, op, listnames(ap)); ! 694: warning(); ! 695: if (opt('s')) { ! 696: standard(); ! 697: } ! 698: error("Reading scalars from text files is non-standard"); ! 699: } ! 700: /* ! 701: * Data read is on the stack. ! 702: * Assign it. ! 703: */ ! 704: if (op != O_READ8 && op != O_READE) ! 705: rangechk(ap, op == O_READC ? ap : nl+T4INT); ! 706: gen(O_AS2, O_AS2, width(ap), ! 707: op == O_READ8 ? 8 : op == O_READ4 ? 4 : 2); ! 708: } ! 709: /* ! 710: * Done with arguments. ! 711: * Handle readln and ! 712: * insufficient number of args. ! 713: */ ! 714: if (p->value[0] == O_READLN) { ! 715: if (filetype != nl+T1CHAR) ! 716: error("Can't 'readln' a non text file"); ! 717: put(1, O_READLN); ! 718: } ! 719: else if (argc == 0) ! 720: error("read requires an argument"); ! 721: return; ! 722: ! 723: case O_GET: ! 724: case O_PUT: ! 725: if (argc != 1) { ! 726: error("%s expects one argument", p->symbol); ! 727: return; ! 728: } ! 729: ap = stkrval(argv[1], NIL , RREQ ); ! 730: if (ap == NIL) ! 731: return; ! 732: if (ap->class != FILET) { ! 733: error("Argument to %s must be a file, not %s", p->symbol, nameof(ap)); ! 734: return; ! 735: } ! 736: put(1, O_UNIT); ! 737: put(1, op); ! 738: return; ! 739: ! 740: case O_RESET: ! 741: case O_REWRITE: ! 742: if (argc == 0 || argc > 2) { ! 743: error("%s expects one or two arguments", p->symbol); ! 744: return; ! 745: } ! 746: if (opt('s') && argc == 2) { ! 747: standard(); ! 748: error("Two argument forms of reset and rewrite are non-standard"); ! 749: } ! 750: ap = stklval(argv[1], MOD|NOUSE); ! 751: if (ap == NIL) ! 752: return; ! 753: if (ap->class != FILET) { ! 754: error("First argument to %s must be a file, not %s", p->symbol, nameof(ap)); ! 755: return; ! 756: } ! 757: if (argc == 2) { ! 758: /* ! 759: * Optional second argument ! 760: * is a string name of a ! 761: * UNIX (R) file to be associated. ! 762: */ ! 763: al = argv[2]; ! 764: al = stkrval(al[1], NOFLAGS , RREQ ); ! 765: if (al == NIL) ! 766: return; ! 767: if (classify(al) != TSTR) { ! 768: error("Second argument to %s must be a string, not %s", p->symbol, nameof(al)); ! 769: return; ! 770: } ! 771: strnglen = width(al); ! 772: } else { ! 773: put(2, O_CON24, NIL); ! 774: strnglen = 0; ! 775: } ! 776: put(2, O_CON24, strnglen); ! 777: put(2, O_CON24, text(ap) ? 0: width(ap->type)); ! 778: put(1, op); ! 779: return; ! 780: ! 781: case O_NEW: ! 782: case O_DISPOSE: ! 783: if (argc == 0) { ! 784: error("%s expects at least one argument", p->symbol); ! 785: return; ! 786: } ! 787: ap = stklval(argv[1], op == O_NEW ? ( MOD | NOUSE ) : MOD ); ! 788: if (ap == NIL) ! 789: return; ! 790: if (ap->class != PTR) { ! 791: error("(First) argument to %s must be a pointer, not %s", p->symbol, nameof(ap)); ! 792: return; ! 793: } ! 794: ap = ap->type; ! 795: if (ap == NIL) ! 796: return; ! 797: argv = argv[2]; ! 798: if (argv != NIL) { ! 799: if (ap->class != RECORD) { ! 800: error("Record required when specifying variant tags"); ! 801: return; ! 802: } ! 803: for (; argv != NIL; argv = argv[2]) { ! 804: if (ap->ptr[NL_VARNT] == NIL) { ! 805: error("Too many tag fields"); ! 806: return; ! 807: } ! 808: if (!isconst(argv[1])) { ! 809: error("Second and successive arguments to %s must be constants", p->symbol); ! 810: return; ! 811: } ! 812: gconst(argv[1]); ! 813: if (con.ctype == NIL) ! 814: return; ! 815: if (incompat(con.ctype, (ap->ptr[NL_TAG])->type , NIL )) { ! 816: cerror("Specified tag constant type clashed with variant case selector type"); ! 817: return; ! 818: } ! 819: for (ap = ap->ptr[NL_VARNT]; ap != NIL; ap = ap->chain) ! 820: if (ap->range[0] == con.crval) ! 821: break; ! 822: if (ap == NIL) { ! 823: error("No variant case label value equals specified constant value"); ! 824: return; ! 825: } ! 826: ap = ap->ptr[NL_VTOREC]; ! 827: } ! 828: } ! 829: put(2, op, width(ap)); ! 830: return; ! 831: ! 832: case O_DATE: ! 833: case O_TIME: ! 834: if (argc != 1) { ! 835: error("%s expects one argument", p->symbol); ! 836: return; ! 837: } ! 838: ap = stklval(argv[1], MOD|NOUSE); ! 839: if (ap == NIL) ! 840: return; ! 841: if (classify(ap) != TSTR || width(ap) != 10) { ! 842: error("Argument to %s must be a alfa, not %s", p->symbol, nameof(ap)); ! 843: return; ! 844: } ! 845: put(1, op); ! 846: return; ! 847: ! 848: case O_HALT: ! 849: if (argc != 0) { ! 850: error("halt takes no arguments"); ! 851: return; ! 852: } ! 853: put(1, op); ! 854: noreach = 1; ! 855: return; ! 856: ! 857: case O_ARGV: ! 858: if (argc != 2) { ! 859: error("argv takes two arguments"); ! 860: return; ! 861: } ! 862: ap = stkrval(argv[1], NIL , RREQ ); ! 863: if (ap == NIL) ! 864: return; ! 865: if (isnta(ap, "i")) { ! 866: error("argv's first argument must be an integer, not %s", nameof(ap)); ! 867: return; ! 868: } ! 869: al = argv[2]; ! 870: ap = stklval(al[1], MOD|NOUSE); ! 871: if (ap == NIL) ! 872: return; ! 873: if (classify(ap) != TSTR) { ! 874: error("argv's second argument must be a string, not %s", nameof(ap)); ! 875: return; ! 876: } ! 877: put(2, op, width(ap)); ! 878: return; ! 879: ! 880: case O_STLIM: ! 881: if (argc != 1) { ! 882: error("stlimit requires one argument"); ! 883: return; ! 884: } ! 885: ap = stkrval(argv[1], NIL , RREQ ); ! 886: if (ap == NIL) ! 887: return; ! 888: if (isnta(ap, "i")) { ! 889: error("stlimit's argument must be an integer, not %s", nameof(ap)); ! 890: return; ! 891: } ! 892: if (width(ap) != 4) ! 893: put(1, O_STOI); ! 894: put(1, op); ! 895: return; ! 896: ! 897: case O_REMOVE: ! 898: if (argc != 1) { ! 899: error("remove expects one argument"); ! 900: return; ! 901: } ! 902: ap = stkrval(argv[1], NOFLAGS , RREQ ); ! 903: if (ap == NIL) ! 904: return; ! 905: if (classify(ap) != TSTR) { ! 906: error("remove's argument must be a string, not %s", nameof(ap)); ! 907: return; ! 908: } ! 909: put(2, O_CON24, width(ap)); ! 910: put(1, op); ! 911: return; ! 912: ! 913: case O_LLIMIT: ! 914: if (argc != 2) { ! 915: error("linelimit expects two arguments"); ! 916: return; ! 917: } ! 918: ap = stklval(argv[1], NOFLAGS|NOUSE); ! 919: if (ap == NIL) ! 920: return; ! 921: if (!text(ap)) { ! 922: error("linelimit's first argument must be a text file, not %s", nameof(ap)); ! 923: return; ! 924: } ! 925: al = argv[2]; ! 926: ap = stkrval(al[1], NIL , RREQ ); ! 927: if (ap == NIL) ! 928: return; ! 929: if (isnta(ap, "i")) { ! 930: error("linelimit's second argument must be an integer, not %s", nameof(ap)); ! 931: return; ! 932: } ! 933: put(1, op); ! 934: return; ! 935: case O_PAGE: ! 936: if (argc != 1) { ! 937: error("page expects one argument"); ! 938: return; ! 939: } ! 940: ap = stkrval(argv[1], NIL , RREQ ); ! 941: if (ap == NIL) ! 942: return; ! 943: if (!text(ap)) { ! 944: error("Argument to page must be a text file, not %s", nameof(ap)); ! 945: return; ! 946: } ! 947: put(1, O_UNIT); ! 948: put(1, op); ! 949: return; ! 950: ! 951: case O_PACK: ! 952: if (argc != 3) { ! 953: error("pack expects three arguments"); ! 954: return; ! 955: } ! 956: pu = "pack(a,i,z)"; ! 957: pua = (al = argv)[1]; ! 958: pui = (al = al[2])[1]; ! 959: puz = (al = al[2])[1]; ! 960: goto packunp; ! 961: case O_UNPACK: ! 962: if (argc != 3) { ! 963: error("unpack expects three arguments"); ! 964: return; ! 965: } ! 966: pu = "unpack(z,a,i)"; ! 967: puz = (al = argv)[1]; ! 968: pua = (al = al[2])[1]; ! 969: pui = (al = al[2])[1]; ! 970: packunp: ! 971: ap = stkrval((int *) pui, NLNIL , RREQ ); ! 972: if (ap == NIL) ! 973: return; ! 974: ap = stklval(pua, op == O_PACK ? NOFLAGS : MOD|NOUSE); ! 975: if (ap == NIL) ! 976: return; ! 977: if (ap->class != ARRAY) { ! 978: error("%s requires a to be an unpacked array, not %s", pu, nameof(ap)); ! 979: return; ! 980: } ! 981: al = (struct nl *) stklval(puz, op == O_UNPACK ? NOFLAGS : MOD|NOUSE); ! 982: if (al->class != ARRAY) { ! 983: error("%s requires z to be a packed array, not %s", pu, nameof(ap)); ! 984: return; ! 985: } ! 986: if (al->type == NIL || ap->type == NIL) ! 987: return; ! 988: if (al->type != ap->type) { ! 989: error("%s requires a and z to be arrays of the same type", pu, nameof(ap)); ! 990: return; ! 991: } ! 992: k = width(al); ! 993: itemwidth = width(ap->type); ! 994: ap = ap->chain; ! 995: al = al->chain; ! 996: if (ap->chain != NIL || al->chain != NIL) { ! 997: error("%s requires a and z to be single dimension arrays", pu); ! 998: return; ! 999: } ! 1000: if (ap == NIL || al == NIL) ! 1001: return; ! 1002: /* ! 1003: * al is the range for z i.e. u..v ! 1004: * ap is the range for a i.e. m..n ! 1005: * i will be n-m+1 ! 1006: * j will be v-u+1 ! 1007: */ ! 1008: i = ap->range[1] - ap->range[0] + 1; ! 1009: j = al->range[1] - al->range[0] + 1; ! 1010: if (i < j) { ! 1011: error("%s cannot have more elements in a (%d) than in z (%d)", pu, j, i); ! 1012: return; ! 1013: } ! 1014: /* ! 1015: * get n-m-(v-u) and m for the interpreter ! 1016: */ ! 1017: i -= j; ! 1018: j = ap->range[0]; ! 1019: put(5, op, itemwidth , j, i, k); ! 1020: return; ! 1021: case 0: ! 1022: error("%s is an unimplemented 6400 extension", p->symbol); ! 1023: return; ! 1024: ! 1025: default: ! 1026: panic("proc case"); ! 1027: } ! 1028: } ! 1029: #endif OBJ
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.