![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to string.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / libstring|
Return to string.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / libstring |
1.1 ! root 1: #include "String.h" ! 2: #include <ctype.h> ! 3: ! 4: extern "C" { ! 5: extern char *memcpy(char *to, const char *from, int); ! 6: } ! 7: ! 8: inline char* // thanx to Jerry Schwarz ! 9: my_mcpy(char *to, const char *from, int n) ! 10: { ! 11: if (n==1) { ! 12: *to = *from; ! 13: return to; ! 14: } else return memcpy(to, from, n); ! 15: } ! 16: ! 17: inline char* ! 18: my_Mcpy(char *to, const char *from, int n) ! 19: { ! 20: if (n==1) { ! 21: *to = *from; ! 22: return to; ! 23: } else return Memcpy(to, from, n); ! 24: } ! 25: ! 26: String ! 27: String::operator+ (const String& oo) _const /* catenate */ ! 28: { ! 29: register Rep *sd = d; ! 30: register Rep *sood = oo.d; ! 31: register sdlen = sd->len; ! 32: register soodlen = sood->len; ! 33: if (sdlen + soodlen > MAXSTRINGLENGTH) ! 34: error( 1, "String.operator+: overflow" ); ! 35: if (sdlen == 0) return oo; ! 36: else if (soodlen == 0) return *this; ! 37: // try to make this a SubString of the result ! 38: Rep *temp; ! 39: if ((temp = sd->canCat(soodlen)) == NULL) { ! 40: temp = new Rep(sdlen + soodlen); ! 41: my_mcpy(temp->start, sd->start, sdlen); ! 42: } ! 43: my_mcpy(temp->start+sdlen, sood->start, soodlen); ! 44: return String(*temp); ! 45: } ! 46: ! 47: String ! 48: String::operator+ (const char *p) _const /* catenate */ ! 49: { ! 50: register Rep *sd = d; ! 51: register sdlen = sd->len; ! 52: register len = strlen(p); ! 53: if (sdlen + len > MAXSTRINGLENGTH) ! 54: error(1, "String::operator+: overflow"); ! 55: if (sdlen == 0) return String(p); ! 56: else if (len == 0) return *this; ! 57: // try to make this a SubString of the result ! 58: Rep *temp; ! 59: if ((temp = sd->canCat(len)) == NULL) { ! 60: temp = new Rep(sdlen + len); ! 61: my_mcpy(temp->start, sd->start, sdlen); ! 62: } ! 63: my_mcpy(temp->start+sdlen, p, len); ! 64: return String(*temp); ! 65: } ! 66: ! 67: String ! 68: String::operator+ (const char c) const /* catenate */ ! 69: { ! 70: register Rep *sd = d; ! 71: register sdlen = sd->len; ! 72: if (sdlen > MAXSTRINGLENGTH - 1) ! 73: error( 1, "String.operator+: overflow" ); ! 74: if (sdlen == 0) return String(c); ! 75: // try to make this a SubString of the result ! 76: Rep *temp; ! 77: if ((temp = sd->canCat(1)) == NULL) { ! 78: temp = new Rep(sdlen + 1); ! 79: my_mcpy(temp->start, sd->start, sdlen); ! 80: } ! 81: temp->start[sdlen] = c; ! 82: return String(*temp); ! 83: } ! 84: ! 85: String ! 86: operator+ (const char *p, const String& s) /* catenate */ ! 87: { ! 88: register Rep *ssd = s.d; ! 89: register ssdlen = ssd->len; ! 90: register len = strlen(p); ! 91: if (ssdlen + len > MAXSTRINGLENGTH) ! 92: s.error( 1, "operator+(char*,String): overflow" ); ! 93: if (ssdlen == 0) return String(p); ! 94: else if (len == 0) return s; ! 95: Rep *temp = new Rep(ssdlen + len); ! 96: my_mcpy(temp->start, p, len); ! 97: my_mcpy(temp->start+len, ssd->start, ssdlen); ! 98: return String(*temp); ! 99: } ! 100: ! 101: String ! 102: operator+ (const char c, const String& s) /* catenate */ ! 103: { ! 104: register Rep *ssd = s.d; ! 105: register ssdlen = ssd->len; ! 106: if (ssdlen > MAXSTRINGLENGTH - 1) ! 107: s.error( 1, "operator+(char,String): overflow" ); ! 108: if (ssdlen == 0) return String(c); ! 109: Rep *temp = new Rep(ssdlen + 1); ! 110: my_mcpy(temp->start+1, ssd->start, ssdlen); ! 111: temp->start[0] = c; ! 112: return String(*temp); ! 113: } ! 114: ! 115: Subchar& ! 116: String::operator[](const unsigned i) /* character selection */ ! 117: { ! 118: if ( i >= length()) ! 119: error(1, "String.operator[]: out of bounds"); ! 120: return *new Subchar(*this,i); ! 121: } ! 122: ! 123: SubString& ! 124: String::operator()(const unsigned offset, const unsigned len) /* SubString */ ! 125: { ! 126: if ( offset > length() ) ! 127: error(1, "String.operator(): offset out of bounds"); ! 128: if ( len > MAXSUBSTRINGLENGTH || offset + len > d->len) ! 129: error(1, "String.operator(): length out of bounds"); ! 130: return *new SubString(*this, offset, len); ! 131: } ! 132: ! 133: Subchar::Subchar(const Subchar&) ! 134: { ! 135: error(1, "Subchar.Subchar(Subchar&): shouldn't call this" ); ! 136: } ! 137: ! 138: SubString::SubString(const SubString&) ! 139: { ! 140: error(1, "SubString.SubString(SubString&): shouldn't call this" ); ! 141: } ! 142: ! 143: String& ! 144: String::operator=(const String& oo) ! 145: { ! 146: register Rep *sd = d; ! 147: register Rep *sood = oo.d; ! 148: if ( sd != sood ) { ! 149: sd->refDecr(); ! 150: sd = d = sood; ! 151: sd->refIncr(); ! 152: } ! 153: return *this; ! 154: } ! 155: ! 156: String& ! 157: String::operator=(const char *s) ! 158: { ! 159: register Rep *sd = d; ! 160: sd->refDecr(); ! 161: d = new Rep(s); ! 162: return *this; ! 163: } ! 164: ! 165: String& ! 166: String::operator= (const char c) ! 167: { ! 168: register Rep *sd = d; ! 169: sd->refDecr(); ! 170: d = &oneChar[c]; ! 171: return *this; ! 172: } ! 173: ! 174: char ! 175: Subchar::operator=(const char cc) ! 176: { ! 177: register Rep *sd = ss->d; ! 178: if (sd->len == 1) { /* one character String */ ! 179: sd = &oneChar[cc]; ! 180: } else if (sd->refCount == 1 && !sd->is_constant()) { ! 181: /* modify in place */ ! 182: sd->start[oo] = cc; ! 183: } else { ! 184: Rep *rr = new Rep(*sd); ! 185: /* copy middle */ ! 186: rr->start[oo] = cc; ! 187: sd->refDecr(); ! 188: ss->d = rr; ! 189: } ! 190: /* delete this; it's used up */ ! 191: return cc; ! 192: } ! 193: ! 194: void ! 195: SubString::operator=(const String& oss) ! 196: { ! 197: register Rep *sd = ss->d; ! 198: register Rep *osd = oss.d; ! 199: int itsOldLength = ss->length(); ! 200: int newLength = itsOldLength + oss.length() - ll; ! 201: if (newLength == 0) { ! 202: sd->refDecr(); ! 203: sd = ss->d = nullRep; ! 204: } else if (newLength == 1) { ! 205: Rep *rr; ! 206: if (oss.length() == 1) ! 207: rr = osd; ! 208: else if (oo == 1) /* the head of this */ ! 209: rr = &oneChar[*sd->start]; ! 210: else /* the last character */ ! 211: rr = &oneChar[*(sd->start+ss->length()-1)]; ! 212: sd->refDecr(); ! 213: ss->d = rr; ! 214: } else if (sd->refCount == 1 && !sd->is_constant() && ! 215: (sd->extend(oss.length() - ll))) { ! 216: /* modify in place */ ! 217: if (ll != oss.length()) ! 218: /* copy tail */ ! 219: my_Mcpy(sd->start + oo + oss.length(), ! 220: sd->start + oo + ll, ! 221: itsOldLength - (oo + ll)); ! 222: /* copy middle */ ! 223: my_mcpy(sd->start+oo, osd->start, oss.length()); ! 224: } else { ! 225: Rep *rr = new Rep(newLength); ! 226: /* copy head */ ! 227: my_mcpy(rr->start, sd->start, oo); ! 228: /* copy middle */ ! 229: my_mcpy(rr->start+oo, osd->start, oss.length()); ! 230: /* copy tail */ ! 231: my_mcpy(rr->start + oo + oss.length(), ! 232: sd->start + oo + ll, ! 233: ss->length() - (oo + ll)); ! 234: sd->refDecr(); ! 235: ss->d = rr; ! 236: } ! 237: /* delete this; it's used up */ ! 238: } ! 239: ! 240: bit ! 241: String::getX(char& c) /* or lop */ ! 242: { ! 243: register Rep *sd = d; ! 244: if ( length() < 1 ) ! 245: return FALSE; ! 246: c = *sd->start; ! 247: if ( length() == 1 ) ! 248: d = nullRep; ! 249: else if ( length() == 2 ) { ! 250: d = &oneChar[(unsigned char)sd->start[1]]; ! 251: sd->refDecr(); ! 252: } else { ! 253: Charfield *myF = sd->myField(); ! 254: if (sd->refCount == 1 && !sd->is_constant()) { ! 255: sd->start++; ! 256: sd->len--; ! 257: myF->usedSpace -= 1; ! 258: } else { ! 259: Rep *rr = myF->getMt(); ! 260: if (rr) { ! 261: sd->immutable(); ! 262: rr->immutable(); ! 263: rr->start = sd->start + 1; ! 264: myF->usedSpace += (rr->len = sd->len - 1); ! 265: } else ! 266: rr = new Rep (sd->start+1, sd->len - 1); ! 267: sd->refDecr(); ! 268: d = rr; ! 269: } ! 270: } ! 271: return TRUE; ! 272: } ! 273: ! 274: bit ! 275: String::firstX(char &c) _const // don't change the String ! 276: { ! 277: return length() ? (c = *d->start, TRUE) : FALSE; ! 278: } ! 279: ! 280: bit ! 281: String::lastX(char &c) _const // don't change the String ! 282: { ! 283: return length() ? (c = d->start[length()-1], TRUE) : FALSE; ! 284: } ! 285: ! 286: bit ! 287: String::unputX(char& c) /* remove from back */ ! 288: { ! 289: register Rep *sd = d; ! 290: if (length() < 1) ! 291: return FALSE; ! 292: c = sd->start[length()-1]; ! 293: if (length() == 1) ! 294: d = nullRep; ! 295: else if (length() == 2) { ! 296: d = &oneChar[(unsigned char)*sd->start]; ! 297: sd->refDecr(); ! 298: } else { ! 299: Charfield *myF = sd->myField(); ! 300: if (!myF) abort(); // internal string error ! 301: if (sd->refCount == 1 && !sd->is_constant()) { ! 302: sd->len--; ! 303: myF->usedSpace -= 1; ! 304: } else { ! 305: Rep *rr = myF->getMt(); ! 306: if (rr) { ! 307: sd->immutable(); ! 308: rr->immutable(); ! 309: rr->start = sd->start; ! 310: myF->usedSpace += (rr->len = sd->len - 1); ! 311: } else ! 312: rr = new Rep (sd->start, sd->len - 1); ! 313: sd->refDecr(); ! 314: d = rr; ! 315: } ! 316: } ! 317: return TRUE; ! 318: } ! 319: ! 320: String& ! 321: String::put(const char c) /* append or put */ ! 322: { ! 323: register Rep *sd = d; ! 324: register sdlen = sd->len; ! 325: switch (sdlen) { ! 326: case 0: ! 327: d = &oneChar[(unsigned char) c]; ! 328: break; ! 329: case 1: ! 330: Rep *rr = new Rep(2); ! 331: *rr->start = *sd->start; ! 332: rr->start[1] = c; ! 333: d = rr; ! 334: break; ! 335: case MAXSTRINGLENGTH: ! 336: error (1, "String::put: String overflow"); ! 337: break; ! 338: default: ! 339: if (sd->refCount == 1 && !sd->is_constant() && sd->extend(1)) ! 340: sd->start[sdlen] = c; ! 341: else { ! 342: Rep *rr = sd->canCat(1); ! 343: if (rr) ! 344: rr->start[rr->len-1] = c; ! 345: else { ! 346: rr = new Rep (sdlen + 1); ! 347: my_mcpy(rr->start, sd->start, sdlen); ! 348: rr->start[sdlen] = c; ! 349: } ! 350: sd->refDecr(); ! 351: d = rr; ! 352: } ! 353: break; ! 354: } ! 355: return *this; ! 356: } ! 357: ! 358: String& ! 359: String::put(const char *p) /* append */ ! 360: { ! 361: register Rep *sd = d; ! 362: register sdlen = sd->len; ! 363: register soodlen = strlen(p); ! 364: if (sdlen + soodlen > MAXSTRINGLENGTH) ! 365: error(1, "String::put: overflow"); ! 366: if (sdlen == 0) return *this = p; ! 367: if (soodlen == 0) return *this; ! 368: if (sd->refCount == 1 && !sd->is_constant()) { ! 369: char *oldEnd = sd->start+sdlen; ! 370: if (sd->extend(soodlen)) { ! 371: my_mcpy(oldEnd, p, soodlen); ! 372: return *this; ! 373: } ! 374: } ! 375: Rep *temp = new Rep(sdlen + soodlen); ! 376: my_mcpy(temp->start, sd->start, sdlen); ! 377: my_mcpy(temp->start+sdlen, p, soodlen); ! 378: sd->refDecr(); ! 379: d = temp; ! 380: return *this; ! 381: } ! 382: ! 383: String& ! 384: String::put(const String& oo) /* append */ ! 385: { ! 386: register Rep *sd = d; ! 387: register Rep *sood = oo.d; ! 388: register sdlen = sd->len; ! 389: register soodlen = sood->len; ! 390: if (sdlen + soodlen > MAXSTRINGLENGTH) ! 391: error(1, "String::put: overflow"); ! 392: if (sdlen == 0) return *this = oo; ! 393: if (soodlen == 0) return *this; ! 394: if (sd->refCount == 1 && !sd->is_constant()) { ! 395: char *oldEnd = sd->start+sdlen; ! 396: if (sd->extend(soodlen)) { ! 397: my_mcpy(oldEnd, sood->start, soodlen); ! 398: return *this; ! 399: } ! 400: } ! 401: Rep *temp = new Rep(sdlen + soodlen); ! 402: my_mcpy(temp->start, sd->start, sdlen); ! 403: my_mcpy(temp->start+sdlen, sood->start, soodlen); ! 404: sd->refDecr(); ! 405: d = temp; ! 406: return *this; ! 407: } ! 408: ! 409: // unget(c) sticks c onto the front of the String ! 410: String& ! 411: String::unget (const char c) ! 412: { ! 413: register Rep *sd = d; ! 414: register sdlen = sd->len; ! 415: switch (sdlen) { ! 416: case 0: ! 417: d = &oneChar[(unsigned char) c]; ! 418: break; ! 419: case 1: ! 420: Rep *rr = new Rep (2); ! 421: *rr->start = c; ! 422: rr->start[1] = *sd->start; ! 423: d = rr; ! 424: break; ! 425: case MAXSTRINGLENGTH: ! 426: error(1, "String::unget: String overflow"); ! 427: break; ! 428: default: ! 429: if (sd->refCount == 1 && !sd->is_constant() && sd->extend(1)) { ! 430: my_Mcpy(sd->start+1, sd->start, sdlen); ! 431: *sd->start = c; ! 432: } else { ! 433: Rep *rr; ! 434: rr = new Rep (sdlen + 1); ! 435: my_mcpy (rr->start+1, sd->start, sdlen); ! 436: *rr->start = c; ! 437: sd->refDecr(); ! 438: d = rr; ! 439: } ! 440: } ! 441: return *this; ! 442: } ! 443: ! 444: String& ! 445: String::unget (const String& oo) /* prepend */ ! 446: { ! 447: register Rep *sd = d; ! 448: register Rep *sood = oo.d; ! 449: register sdlen = sd->len; ! 450: register soodlen = sood->len; ! 451: if (sdlen + soodlen > MAXSTRINGLENGTH) ! 452: error(1, "String.operator-=: overflow"); ! 453: if (soodlen == 0) return *this; ! 454: if (sdlen == 0) return *this = oo; ! 455: if (sd->refCount == 1 && !sd->is_constant()) { ! 456: if (sd->extend(soodlen)) { ! 457: my_Mcpy(sd->start+soodlen, sd->start, sdlen); ! 458: my_mcpy(sd->start, sood->start, soodlen); ! 459: return *this; ! 460: } ! 461: } ! 462: Rep *temp = new Rep(sdlen + soodlen); ! 463: my_mcpy(temp->start, sood->start, soodlen); ! 464: my_mcpy(temp->start+soodlen, sd->start, sdlen); ! 465: sd->refDecr(); ! 466: d = temp; ! 467: return *this; ! 468: } ! 469: ! 470: istream& ! 471: operator>>(istream& ii, String& ss) ! 472: { ! 473: ss = ""; ! 474: if (!(ii >> WS)) ! 475: return ii; ! 476: char c; ! 477: while (ii.get(c)) { ! 478: if (isspace(c)) { ! 479: ii.putback(c); ! 480: break; ! 481: } ! 482: ss.put(c); ! 483: } ! 484: return ii; ! 485: } ! 486: ! 487: String ! 488: sgets(istream& ii) ! 489: { ! 490: char c; ! 491: String ans; ! 492: while (ii.get(c) && c != '\n') ! 493: ans.put(c); ! 494: return ans; ! 495: } ! 496: ! 497: void ! 498: String::dump(char *s) _const ! 499: { ! 500: my_mcpy(s, d->start, d->len); ! 501: s[d->len] = '\0'; ! 502: } ! 503:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.