![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to copy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu|
Return to copy.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / dbu |
1.1 ! root 1: # include <stdio.h> ! 2: # include <func.h> ! 3: # include <pv.h> ! 4: # include <ingres.h> ! 5: # include <aux.h> ! 6: # include <access.h> ! 7: # include <symbol.h> ! 8: # include <lock.h> ! 9: # include <signal.h> ! 10: # include <sccs.h> ! 11: ! 12: SCCSID(@(#)copy.c 7.6 9/26/83) ! 13: ! 14: /* ! 15: ** COPY -- Performs an ingres COPY. ! 16: ** ! 17: ** Trace Flags: ! 18: ** 30 ! 19: */ ! 20: ! 21: ! 22: # define MAXMAP 3 * MAXDOM ! 23: # define DUMMY 'd' ! 24: # define ESCAPE '\\' ! 25: ! 26: extern short tTdbu[100]; ! 27: extern int copy(); ! 28: extern int null_fn(); ! 29: ! 30: struct fn_def CopyFn = ! 31: { ! 32: "COPY", ! 33: copy, ! 34: null_fn, ! 35: null_fn, ! 36: NULL, ! 37: 0, ! 38: tTdbu, ! 39: 100, ! 40: 'Z', ! 41: 0 ! 42: }; ! 43: ! 44: ! 45: ! 46: ! 47: struct map ! 48: { ! 49: char name[MAXNAME+1]; /* attribute name */ ! 50: char ftype; /* attfrmt of file domain */ ! 51: char rtype; /* attfrmt of relation domain */ ! 52: int flen; /* attfrml of file domain */ ! 53: int rlen; /* attfrml of relation domain */ ! 54: int roffset; /* attoff of relation domain */ ! 55: int used; /* tag for duplicate checking */ ! 56: char *fdelim; /* pointer to list of file param delims */ ! 57: char *paramname; /* pointer to original parameter name */ ! 58: /* used for supplying domain name in case of error */ ! 59: }; ! 60: struct map Map[MAXMAP]; /* one entry for each user ! 61: specified domain in copy statement. */ ! 62: ! 63: int Mapcount; /* number of Map entries */ ! 64: ! 65: ! 66: DESC Des; /* descriptor for copied relation */ ! 67: ! 68: extern struct out_arg Out_arg; /* user defined formats for numeric output */ ! 69: ! 70: FILE *File_iop; /* i/o file pointer */ ! 71: char *Filename; /* pointer to file name */ ! 72: ! 73: int Into; /* into is one if this is a copy into file */ ! 74: ! 75: char Inbuf[BUFSIZ]; /* input holder */ ! 76: char Outbuf[BUFSIZ]; /* output holder */ ! 77: ! 78: long Tupcount; /* number of tuples processed */ ! 79: char *Relname; /* name of relation */ ! 80: long Duptuple; /* number of duplicate tuples */ ! 81: long Baddoms; /* number of domains with control chars */ ! 82: long Truncount; /* number of truncations on a c0 field */ ! 83: int Piped[2]; /* pipe descriptor for copy communication */ ! 84: char *Cpdomains[] = /* dummy domain names for copy "into" */ ! 85: { ! 86: "nl", "\n", ! 87: "tab", "\t", ! 88: "sp", " ", ! 89: "nul", "\0", ! 90: "null", "\0", ! 91: "comma", ",", ! 92: "colon", ":", ! 93: "dash", "-", ! 94: "lparen", "(", ! 95: "rparen", ")", ! 96: 0 ! 97: }; ! 98: ! 99: char Delimitor[] = ",\n\t"; /* default delims for c0 & d0 */ ! 100: ! 101: ! 102: ! 103: copy(pc,pv) ! 104: int pc; ! 105: PARM pv[]; ! 106: { ! 107: extern char *Usercode; ! 108: extern int Noupdt; ! 109: register int i, pid; ! 110: register char *cp; ! 111: int stat; ! 112: int copydone(); ! 113: int op; ! 114: ! 115: # ifdef xZTR1 ! 116: if (tTf(30,1)) ! 117: { ! 118: printf("entered copy\n"); ! 119: prvect(pc, pv); ! 120: } ! 121: # endif ! 122: Duptuple = 0; ! 123: Truncount = 0; ! 124: Tupcount = 0; ! 125: Baddoms = 0; ! 126: Relname = pv[0].pv_val.pv_str; ! 127: Into = (pv[pc-2].pv_val.pv_str[0] == 'i'); ! 128: Filename = pv[pc-1].pv_val.pv_str; ! 129: ! 130: /* relation must exist and not be a system relation */ ! 131: /* in addition a copy "from" can't be done if the user */ ! 132: /* doesn't own the relation */ ! 133: /* and furthermore it can't have an index */ ! 134: i = 0; /* assume all is well */ ! 135: if (op = openr(&Des, 2, Relname)) ! 136: { ! 137: if (op == AMOPNVIEW_ERR) ! 138: i = 5818; ! 139: else ! 140: { ! 141: if (op < 0) ! 142: syserr("COPY: openr 1 (%.14s) %d", Relname, op); ! 143: else ! 144: /* non-existant relation */ ! 145: i = 5800; ! 146: } ! 147: } ! 148: else ! 149: { ! 150: if (Into) ! 151: { ! 152: if ((Des.reldum.relstat & S_PROTALL) ! 153: && (Des.reldum.relstat & S_PROTRET) ! 154: && !bequal(Usercode, Des.reldum.relowner, 2)) ! 155: i = 5822; ! 156: } ! 157: else ! 158: { ! 159: /* extra checking if this is a copy "from" */ ! 160: ! 161: /* must be owned by the user */ ! 162: if (!bequal(Usercode, Des.reldum.relowner, 2)) ! 163: i = 5814; ! 164: else ! 165: /* must be updateable */ ! 166: if ((Des.reldum.relstat & S_NOUPDT) && Noupdt) ! 167: i = 5813; ! 168: else ! 169: /* must not be indexed */ ! 170: if (Des.reldum.relindxd > 0) ! 171: i = 5812; ! 172: } ! 173: } ! 174: if (i) ! 175: { ! 176: closer(&Des); ! 177: return (error(i, Relname, 0)); /* relation doesn't exist for this user */ ! 178: } ! 179: ! 180: /* check that file name begins with a "/" */ ! 181: cp = Filename; ! 182: while (*cp == ' ') ! 183: cp++; ! 184: if (*cp != '/') ! 185: { ! 186: closer(&Des); ! 187: return (error(5816, Filename, 0)); ! 188: } ! 189: ! 190: /* fill map structures with transfer information */ ! 191: if (i = mapfill(&pv[1])) ! 192: { ! 193: closer(&Des); ! 194: return (i); /* error in user semantics */ ! 195: } ! 196: ! 197: /* fork a child process which will run as the real user */ ! 198: /* that child will complete the copy and exit */ ! 199: if (pipe(Piped)) ! 200: syserr("copy:can't make pipe"); ! 201: if ((pid = fork()) < 0) ! 202: syserr("copy:can't fork"); ! 203: if (pid) ! 204: { ! 205: /* the ingres parent */ ! 206: close(Piped[1]); ! 207: ruboff(0); /* interrupts off */ ! 208: stat = fullwait(pid, "copy"); ! 209: if (read(Piped[0], &Des.reladds, 4) != 4) ! 210: syserr("copy:can't read pipe"); ! 211: close(Piped[0]); ! 212: closer(&Des); /* close the rel */ ! 213: rubon(); ! 214: /* if stat is != 0 then add on 5800 for error */ ! 215: if (stat) ! 216: stat += 5800; ! 217: return (stat); /* done */ ! 218: } ! 219: ! 220: /* the child. change to run as the real user */ ! 221: if (signal(SIGINT, SIG_IGN) != SIG_IGN) ! 222: signal(SIGINT, copydone); /* clean up on rubout */ ! 223: setuid(getuid()); ! 224: # ifndef xB_UNIX ! 225: setgid(getgid()); ! 226: # endif ! 227: if (Into) /* from relation into file */ ! 228: { ! 229: if ((File_iop = fopen(Filename, "w")) == NULL) /* create file for user */ ! 230: i = nferror(5806, Filename, 0); /* cant create file */ ! 231: else ! 232: { ! 233: if (Lockrel) /* set a shared lock on relation*/ ! 234: setrll(A_SLP, Des.reltid.ltid, M_SHARE); ! 235: i = rel_file(); ! 236: } ! 237: } ! 238: else /* from UNIX file into relation */ ! 239: { ! 240: if ((File_iop = fopen(Filename, "r")) == NULL) ! 241: i = nferror(5805, Filename, 0); /* cant open user file */ ! 242: else ! 243: { ! 244: if (Lockrel) /* set an exclusive lock on relat*/ ! 245: setrll(A_SLP, Des.reltid.ltid, M_EXCL); ! 246: i = file_rel(); ! 247: if (Duptuple) ! 248: nferror(5819, locv(Duptuple), 0); /* warning only */ ! 249: if (Baddoms) ! 250: nferror(5820, locv(Baddoms), 0); /* warning only */ ! 251: } ! 252: } ! 253: copydone(i); ! 254: } ! 255: /* ! 256: ** Finish up and exit after a copy or interrupt ! 257: ** ! 258: ** I is the return code. Since only a byte can be ! 259: ** returned, only the least significant 2 decimal ! 260: ** digits are returned. i is either 0 or a number like 58?? ! 261: */ ! 262: ! 263: copydone(i) ! 264: int i; ! 265: { ! 266: if (Lockrel) /* unlock relation */ ! 267: unlrl(Des.reltid.ltid); ! 268: if (Truncount) ! 269: nferror(5821, locv(Truncount), 0); /* warning only */ ! 270: /* force the updates to be flushed */ ! 271: cleanrel(&Des); ! 272: if (File_iop) ! 273: fclose(File_iop); ! 274: if (write(Piped[1], &Des.reladds, 4) != 4) ! 275: syserr("copyc:can't writepipe"); ! 276: exit (i % 100); ! 277: } ! 278: /* ! 279: ** REL_FILE -- copy from relation to file ! 280: */ ! 281: ! 282: rel_file() ! 283: { ! 284: int j; ! 285: struct tup_id tid, limtid; ! 286: char *cp, save; ! 287: register int offset; ! 288: register int i; ! 289: register struct map *mp; ! 290: ! 291: /* set scan limits to scan the entire relation */ ! 292: if (find(&Des, NOKEY, &tid, &limtid)) ! 293: syserr("find error"); ! 294: ! 295: while ((i = get(&Des, &tid, &limtid, Inbuf, 1)) == 0) ! 296: { ! 297: mp = Map; ! 298: offset = 0; ! 299: for (i = 0; i < Mapcount; i++) ! 300: { ! 301: /* ! 302: ** For cases of char to numeric conversion, ! 303: ** there must be a null byte at the end of the ! 304: ** string. The character just past the current ! 305: ** domain is saved an a null byte inserted ! 306: */ ! 307: ! 308: cp = &Inbuf[mp->roffset + mp->rlen]; /* compute address */ ! 309: save = *cp; /* get the character */ ! 310: *cp = '\0'; /* insert a null */ ! 311: ! 312: /* ! 313: ** Special case, we want to copy the tid ! 314: */ ! 315: if ( mp->roffset == -1 ) ! 316: j = transfer(&tid,mp->rtype,mp->rlen, ! 317: mp->ftype,mp->flen,offset); ! 318: else ! 319: j = transfer(&Inbuf[mp->roffset], mp->rtype, ! 320: mp->rlen, mp->ftype, mp->flen, offset); ! 321: if (j) ! 322: { ! 323: /* bad ascii to numeric conversion or field length too small */ ! 324: return (nferror(j, mp->paramname, &Inbuf[mp->roffset], locv(Tupcount), Relname, Filename, 0)); ! 325: } ! 326: *cp = save; /* restore the saved character */ ! 327: offset += mp->flen; ! 328: mp++; ! 329: } ! 330: Tupcount++; ! 331: if (fwrite(Outbuf, 1, offset, File_iop) != offset) ! 332: syserr("copy:cant write to user file %s", Filename); ! 333: } ! 334: if (i < 0) ! 335: syserr("bad get from rel %d", i); ! 336: return (0); ! 337: } ! 338: /* ! 339: ** file_rel is called to transfer tuples from ! 340: ** the input file and append them to the relation ! 341: ** ! 342: ** Char domains are initialized to blank and numeric ! 343: ** domains are initialized to zero. ! 344: */ ! 345: ! 346: file_rel() ! 347: { ! 348: register int i, j; ! 349: register struct map *mp; ! 350: struct tup_id tid; ! 351: ! 352: clr_tuple(&Des, Outbuf); ! 353: ! 354: /* copy domains until an end of file or an error */ ! 355: for (;;) ! 356: { ! 357: mp = Map; ! 358: for (i = 0; i < Mapcount; i++) ! 359: { ! 360: if ((j = bread(mp)) <= 0) ! 361: { ! 362: if (j < 0) ! 363: { ! 364: i = 1; /* force an error */ ! 365: j = 5815; /* unterminated string */ ! 366: } ! 367: else ! 368: j = 5810; /* end of file */ ! 369: if (i) /* error only if end of file during a tuple or unterminated string */ ! 370: { ! 371: i = nferror(j, mp->paramname, locv(Tupcount), Filename, Relname, 0); ! 372: } ! 373: return (i); ! 374: } ! 375: j = transfer(Inbuf, mp->ftype, mp->flen, mp->rtype, mp->rlen, mp->roffset); ! 376: if (j) ! 377: { ! 378: /* bad ascii to numeric or field length too small */ ! 379: return (nferror(j, mp->paramname, Inbuf, locv(Tupcount), Filename, Relname, 0)); ! 380: } ! 381: mp++; ! 382: } ! 383: Tupcount++; ! 384: if ((j = insert(&Des, &tid, Outbuf, 1)) < 0) ! 385: syserr("insert error %d rel=%s", j, Relname); ! 386: if (j == 1) ! 387: Duptuple++; ! 388: mp++; ! 389: } ! 390: /* ! 391: ** This statement was here -- i don'T think it does anything, but we'll see ! 392: ** return (0); ! 393: */ ! 394: } ! 395: /* ! 396: ** transfer copies data from "*in" to ! 397: ** Outbuf doing conversions whenever ! 398: ** necessary ! 399: */ ! 400: ! 401: transfer(in, sf, sl, df, dl, doff) ! 402: ANYTYPE *in; /* pointer to input chars */ ! 403: char sf; /* source format */ ! 404: int sl; /* source length */ ! 405: char df; /* destination format */ ! 406: int dl; /* destination length */ ! 407: int doff; /* destination offset */ ! 408: { ! 409: register char *outp; ! 410: register ANYTYPE *inp; ! 411: register int i; ! 412: int j; ! 413: char temp[MAXFIELD]; /* holds char during conversions to ascii */ ! 414: float f; ! 415: double d; ! 416: long l; ! 417: ! 418: ! 419: outp = &Outbuf[doff]; ! 420: inp = in; ! 421: ! 422: if (sf == DUMMY) ! 423: /* if source format is a dummy fields then ! 424: nothing else need be done */ ! 425: return (0); ! 426: ! 427: if (df == DUMMY) ! 428: { ! 429: /* fill field with dummy domain character */ ! 430: i = dl; /* i equals the number of chars */ ! 431: while (i--) ! 432: *outp++ = sf; /* sf holds dummy char */ ! 433: return (0); ! 434: } ! 435: ! 436: if (sf != CHAR) ! 437: { ! 438: if (df == CHAR) /* numeric to char conversion */ ! 439: { ! 440: switch (sl) ! 441: { ! 442: /* int of size 1 or 2 */ ! 443: case 1: ! 444: itoa(inp->i1type, temp); ! 445: break; ! 446: ! 447: case 2: ! 448: itoa(inp->i2type, temp); /* convert to ascii */ ! 449: break; ! 450: ! 451: /* int or float of size 4 */ ! 452: case 4: ! 453: if (sf == INT) ! 454: { ! 455: smove(locv(inp->i4type), temp); /* convert and copy */ ! 456: } ! 457: ! 458: else ! 459: { ! 460: ftoa(inp->f4type, temp, dl, Out_arg.f4prec, Out_arg.f4style); ! 461: } ! 462: break; ! 463: ! 464: /* float of size 8 */ ! 465: case 8: ! 466: ftoa(inp->f8type, temp, dl, Out_arg.f8prec, Out_arg.f8style); ! 467: break; ! 468: ! 469: /* there is no possible default */ ! 470: default: ! 471: syserr("bad domain length %d",sl); ! 472: } ! 473: ! 474: j = length(temp); ! 475: if ((i = dl - j) < 0) ! 476: return (5808); /* field won't fit */ ! 477: ! 478: /* blank pad from left. Number will be right justified */ ! 479: while (i--) ! 480: *outp++ = ' '; ! 481: ! 482: bmove(temp, outp, j); ! 483: return (0); ! 484: } ! 485: ! 486: if (convert(inp, outp, sf, sl, df, dl)) /* numeric to numeric transfer */ ! 487: return (5808); /* numeric truncation error */ ! 488: return (0); ! 489: } ! 490: ! 491: /* character to numeric conversion */ ! 492: /* and character to character conversion */ ! 493: switch (df) ! 494: { ! 495: ! 496: case CHAR: ! 497: i = sl; ! 498: if (!i) ! 499: { ! 500: i = length(inp->c0type); ! 501: } ! 502: if (i > dl) ! 503: i = dl; ! 504: if (charmove(inp->c0type, outp, i)) ! 505: Baddoms++; ! 506: for (outp += i; i<dl; i++) ! 507: *outp++ = ' '; ! 508: return (0); ! 509: ! 510: case FLOAT: ! 511: if (atof(inp->c0type, &d)) ! 512: return (5809); /* bad conversion to numeric */ ! 513: if (dl == 8) ! 514: bmove(&d, outp, dl); ! 515: else ! 516: { ! 517: f = d; /* f8 to f4 conversion */ ! 518: bmove(&f, outp, dl); ! 519: } ! 520: return (0); ! 521: ! 522: case INT: ! 523: if (dl == 4) ! 524: { ! 525: if (atol(inp->c0type, &l)) ! 526: return (5809); ! 527: bmove(&l, outp, 4); ! 528: return (0); ! 529: } ! 530: j = atoi(inp->c0type); ! 531: if ((dl == 1) && ((j < -128) || (j > 127))) ! 532: return (5809); ! 533: bmove(&j, outp, dl); ! 534: return (0); ! 535: } ! 536: } ! 537: /* ! 538: ** moves a character string from "in" ! 539: ** to "out" removing any control characters. ! 540: ** returns true if any control characters were found ! 541: */ ! 542: ! 543: charmove(in, out, length) ! 544: char *in, *out; ! 545: int length; ! 546: { ! 547: register char *ip, *op; ! 548: register int l; ! 549: int bad; ! 550: ! 551: bad = FALSE; ! 552: ip = in; ! 553: op = out; ! 554: l = length; ! 555: ! 556: while (l--) ! 557: if ((*op++ = *ip++) < ' ') ! 558: { ! 559: *(op-1) = ' '; ! 560: bad = TRUE; ! 561: } ! 562: return (bad); ! 563: } ! 564: /* ! 565: ** Mapfill fills the Map structure with the list ! 566: ** of user supplied attributes. It then reads ! 567: ** the list of relation attributes and checks ! 568: ** for matching attribute names. ! 569: ** ! 570: ** if an error occures then mapfill returns -1 ! 571: ** else it returns 0 ! 572: ** ! 573: ** Mapfill performs special processing on ! 574: ** dummy domains. ! 575: ** ! 576: ** If no user attributes are given, then "given"=FALSE ! 577: ** and each attribute in the relation is set up to be ! 578: ** copied in the formats and order in which they ! 579: ** exist in the relation ! 580: */ ! 581: ! 582: mapfill(aptr) ! 583: PARM aptr[]; ! 584: { ! 585: register PARM *ap; ! 586: register struct map *mp; ! 587: register int i; ! 588: char *fp; ! 589: extern DESC Attdes; ! 590: struct attribute att; ! 591: struct tup_id tid, limtid; ! 592: int given, cnt; ! 593: char *zcheck(); ! 594: char *dumvalue(); ! 595: ! 596: Mapcount = 0; ! 597: mp = Map; ! 598: ap = aptr; ! 599: ! 600: /* Gather list of user supplied attributes */ ! 601: ! 602: while (*(ap->pv_val.pv_str) != '\0') ! 603: { ! 604: /* check for overflow */ ! 605: if (Mapcount == MAXMAP) ! 606: return (error(5803, 0)); /* more than MAXMAP specifiers */ ! 607: ! 608: mp->paramname = (ap->pv_val).pv_str; /* save pointer to user supplied name */ ! 609: pmove(((ap++)->pv_val).pv_str, mp->name, MAXNAME, ' '); ! 610: fp = ((ap++)->pv_val).pv_str; /* fp points to format string */ ! 611: mp->used = 0; ! 612: mp->rlen = 0; /* zero in case this is a dummy domain */ ! 613: mp->roffset = 0; ! 614: mp->fdelim = 0; ! 615: /* check domain type in *fp */ ! 616: switch (*fp++) ! 617: { ! 618: ! 619: case 'c': ! 620: i = CHAR; ! 621: if ((mp->fdelim = zcheck(fp)) == 0) ! 622: return (-1); /* bad delimitor */ ! 623: break; ! 624: ! 625: case 'f': ! 626: i = FLOAT; ! 627: break; ! 628: ! 629: case 'i': ! 630: i = INT; ! 631: break; ! 632: ! 633: case DUMMY: ! 634: i = DUMMY; ! 635: if ((mp->fdelim = zcheck(fp)) == 0) ! 636: return (-1); ! 637: break; ! 638: ! 639: default: ! 640: return (error(5811, mp->paramname, --fp, 0)); ! 641: } ! 642: mp->ftype = i; ! 643: ! 644: ! 645: /* convert format length to binary */ ! 646: mp->flen = atoi(fp); ! 647: if (mp->flen < 0 || ! 648: mp->flen > 511 || ! 649: (mp->ftype == FLOAT && mp->flen != 4 && mp->flen != 8) || ! 650: (mp->ftype == INT && mp->flen != 1 && mp->flen != 2 && mp->flen != 4)) ! 651: { ! 652: return (error(5804, mp->paramname, --fp, 0)); /* bad length for attribute */ ! 653: } ! 654: ! 655: /* process dummy domain if any */ ! 656: if (Into && mp->ftype == DUMMY && mp->flen) ! 657: { ! 658: if ((fp = dumvalue(mp->paramname)) == 0) ! 659: return (5807); /* bad dummy name */ ! 660: mp->rtype = *fp; /* use first char of string */ ! 661: } ! 662: ! 663: /* check for format of type "c0delim" on copy "into" */ ! 664: if (Into && mp->flen == 0 && mp->fdelim != Delimitor) ! 665: { ! 666: fp = mp->fdelim; ! 667: ! 668: /* is there room for a dummy domain? */ ! 669: mp++; ! 670: if (++Mapcount == MAXMAP) ! 671: return (error(5803, 0)); /* no room */ ! 672: ! 673: /* create a dummy entry */ ! 674: mp->ftype = DUMMY; ! 675: mp->flen = 1; ! 676: mp->rtype = *fp; ! 677: mp->roffset = mp->rlen = 0; ! 678: } ! 679: ! 680: mp++; ! 681: Mapcount++; ! 682: } ! 683: /* if no atributes were given, set flag */ ! 684: if (Mapcount) ! 685: given = TRUE; ! 686: else ! 687: given = FALSE; ! 688: ! 689: /* open attribute relation and prepare for scan */ ! 690: opencatalog("attribute", 0); ! 691: ! 692: setkey(&Attdes, &att, Des.reldum.relid, ATTRELID); ! 693: setkey(&Attdes, &att, Des.reldum.relowner, ATTOWNER); ! 694: ! 695: if (find(&Attdes, EXACTKEY, &tid, &limtid, &att)) ! 696: syserr("find error for att-rel"); ! 697: ! 698: /* scan Map for each relation attribute */ ! 699: while ((i = get(&Attdes, &tid, &limtid, &att, 1)) == 0) ! 700: { ! 701: if (!bequal(&Des, &att, MAXNAME+2)) ! 702: continue; ! 703: /* if no user attributes were supplied, fake an entry */ ! 704: if (!given) ! 705: { ! 706: Mapcount++; ! 707: mp = &Map[att.attid -1]; ! 708: mp->rtype = mp->ftype = att.attfrmt; ! 709: mp->rlen = mp->flen = att.attfrml & 0377; ! 710: mp->roffset = att.attoff; ! 711: mp->used = 1; ! 712: mp->paramname = mp->name; /* point to name */ ! 713: bmove(att.attname, mp->name, MAXNAME); /* copy name */ ! 714: continue; ! 715: } ! 716: mp = Map; ! 717: ! 718: /* check each user domain for match with relation domain */ ! 719: for (i = Mapcount; i--; mp++) ! 720: { ! 721: if (mp->ftype == DUMMY) ! 722: continue; /* ignore dummy */ ! 723: if (!bequal(mp->name, att.attname, 12)) ! 724: continue; ! 725: ! 726: mp->rtype = att.attfrmt; ! 727: mp->rlen = att.attfrml & 0377; ! 728: mp->roffset = att.attoff; ! 729: mp->used++; ! 730: ! 731: /* check for special case of C0 in a copy "into" */ ! 732: if (Into && (mp->flen == 0) && mp->ftype == CHAR) ! 733: { ! 734: switch (mp->rtype) ! 735: { ! 736: case CHAR: ! 737: mp->flen = mp->rlen; ! 738: break; ! 739: ! 740: case INT: ! 741: switch (mp->rlen) ! 742: { ! 743: ! 744: case 1: ! 745: mp->flen = Out_arg.i1width; ! 746: break; ! 747: ! 748: case 2: ! 749: mp->flen = Out_arg.i2width; ! 750: break; ! 751: ! 752: case 4: ! 753: mp->flen = Out_arg.i4width; ! 754: } ! 755: break; ! 756: ! 757: case FLOAT: ! 758: if (mp->rlen == 4) ! 759: mp->flen = Out_arg.f4width; ! 760: else ! 761: mp->flen = Out_arg.f8width; ! 762: } ! 763: } ! 764: /* if this is a copy "from" then break ! 765: otherwise continue. In a copy "into" ! 766: an attribute might be copied more than once */ ! 767: if (!Into) ! 768: break; ! 769: } ! 770: } ! 771: if (i < 0) ! 772: syserr("bad get from att-rel %d", i); ! 773: ! 774: /* check that all user domains have been identified */ ! 775: cnt = 0; ! 776: mp = Map; ! 777: for (i = Mapcount; i--; mp++) ! 778: { ! 779: cnt += mp->flen; ! 780: if (mp->ftype == DUMMY) ! 781: continue; ! 782: if (!mp->used) ! 783: { ! 784: if ( Into && bequal(mp->name,"tid ",12) ) ! 785: { ! 786: mp->flen = 4; ! 787: mp->rtype = INT; ! 788: mp->rlen = 4; ! 789: mp->roffset = -1; ! 790: mp->used++; ! 791: } ! 792: else ! 793: return (error(5801, mp->paramname, Relname, 0)); /* unrecognizable domain name */ ! 794: } ! 795: } ! 796: /* check that copy into doesn't exceed buffer size */ ! 797: if (Into && cnt > BUFSIZ) ! 798: return (error(5817, 0)); /* cnt too large */ ! 799: return (0); ! 800: } ! 801: /* ! 802: ** BREAD ! 803: */ ! 804: ! 805: bread(mp) ! 806: struct map *mp; ! 807: { ! 808: register int count, i; ! 809: register char *inp; ! 810: char *dl; ! 811: int esc; /* escape flag */ ! 812: ! 813: count = mp->flen; ! 814: inp = Inbuf; ! 815: ! 816: if (count) ! 817: { ! 818: /* block mode. read characters */ ! 819: i = fread(inp, 1, count, File_iop); ! 820: ! 821: /* null terminate */ ! 822: *(inp + count) = '\0'; ! 823: ! 824: return (i == count); /* true -> normal, false ->eof */ ! 825: } ! 826: ! 827: /* string mode read */ ! 828: /* ! 829: ** Determine the maximum size the C0 field being read can be. ! 830: ** In the case where it is being copied into a CHAR field, then ! 831: ** the size is that of the char field (+1 for the delimitor). ! 832: ** In the case of a numeric, it is limited only by the size of the ! 833: ** buffer area. ! 834: */ ! 835: count = mp->rtype == CHAR ? mp->rlen + 1 : BUFSIZ; ! 836: esc = FALSE; ! 837: ! 838: for (;;) ! 839: { ! 840: if ((i = getc(File_iop)) == EOF) ! 841: return (inp == Inbuf ? 0 : -1); /* -1 -> unexpected EOF, 0 -> normal EOF */ ! 842: ! 843: if (count > 0) ! 844: { ! 845: count--; ! 846: *inp++ = i; ! 847: } ! 848: else ! 849: { ! 850: if (count == 0) ! 851: { ! 852: /* determine type of overflow */ ! 853: if (mp->rtype == CHAR) ! 854: { ! 855: Truncount++; ! 856: count--; /* read until delim */ ! 857: } ! 858: else ! 859: { ! 860: return (-1); ! 861: } ! 862: } ! 863: } ! 864: if (esc) ! 865: { ! 866: esc = FALSE; ! 867: continue; ! 868: } ! 869: if (i == ESCAPE) ! 870: { ! 871: esc = TRUE; ! 872: /* ! 873: ** If esc was stored, back it up. ! 874: */ ! 875: if (count >= 0) ! 876: { ! 877: inp--; /* remove escape char */ ! 878: count++; /* restore counter */ ! 879: } ! 880: } ! 881: else ! 882: { ! 883: for (dl = mp->fdelim; *dl; dl++) ! 884: if (*dl == i) ! 885: { ! 886: *(inp-1) = '\0'; ! 887: return (1); ! 888: } ! 889: } ! 890: } ! 891: } ! 892: /* ! 893: ** Look for the existence of a param of the ! 894: ** form "0nl" or "00comma" etc. ! 895: ** ! 896: ** Returns the correct delim list or 0 ! 897: ** if there was a user error ! 898: ** ! 899: ** If successful, a null is inserted at the ! 900: ** rightmost '0' so the subsequent atoi will work. ! 901: */ ! 902: ! 903: char * ! 904: zcheck(param) ! 905: char *param; ! 906: { ! 907: register char *np, *ret; ! 908: ! 909: np = param; ! 910: ret = Delimitor; /* assume default delimitors */ ! 911: ! 912: if (*np++ == '0') ! 913: { ! 914: /* we have a starting zero. trim the rest */ ! 915: while (*np == '0') ! 916: np++; ! 917: ! 918: if (*np > '9' || (*np < '0' && *np >= ' ')) ! 919: { ! 920: /* we have a special delim on a 0 width field */ ! 921: if (ret = dumvalue(np)) ! 922: *(--np) = '\0'; /* ! 923: ** end string before delim ! 924: ** Do not alter delimitor but ! 925: ** instead destroy last '0'. ! 926: */ ! 927: } ! 928: } ! 929: return (ret); ! 930: } ! 931: /* ! 932: ** Search list of valid dummy names looking ! 933: ** for 'name'. If 'name' is a single char ! 934: ** then use just that name else it is ! 935: ** an error if the name is not found ! 936: */ ! 937: ! 938: char * ! 939: dumvalue(name) ! 940: char *name; ! 941: { ! 942: register char **dp, *np, *ret; ! 943: ! 944: dp = Cpdomains; /* get list of valid dummy names */ ! 945: np = name; ! 946: ret = 0; ! 947: ! 948: /* first look for a matching key word */ ! 949: while (*dp) ! 950: { ! 951: if (sequal(np, *dp++)) ! 952: { ! 953: ret = *dp; ! 954: break; ! 955: } ! 956: dp++; ! 957: } ! 958: ! 959: /* If single char, use that char */ ! 960: if (length(np) == 1) ! 961: ret = np; /* use first char of name */ ! 962: if (ret == 0) ! 963: error(5807, np, 0); ! 964: ! 965: return (ret); ! 966: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.