home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Graphics / Misc / aa_m68k_Only / NDCamera.0.21 / Source / MiscSources.subproj / MiscStringReplacing.m < prev    next >
Encoding:
Text File  |  1995-04-12  |  24.6 KB  |  639 lines
  1. //
  2. //    MiscStringReplacing.m
  3. //        Written by Don Yacktman Copyright (c) 1993 by Don Yacktman.
  4. //                Version 1.95  All rights reserved.
  5. //        This notice may not be removed from this source code.
  6. //
  7. //    This object is included in the MiscKit by permission from the author
  8. //    and its use is governed by the MiscKit license, found in the file
  9. //    "LICENSE.rtf" in the MiscKit distribution.  Please refer to that file
  10. //    for a list of all applicable permissions and restrictions.
  11. //    
  12.  
  13. #import <misckit/MiscString.h>
  14.  
  15. @implementation MiscString(Replacing)
  16.  
  17. // This category is composed of methods which modify a MiscString
  18. // by replacing a character or substring with a new character or
  19. // substring.
  20.  
  21. - replaceFrom:(int)start length:(int)len with:(const char *)aString
  22. {
  23.   return [[self removeFrom:start length:len] insert:aString at:start];
  24. }
  25.  
  26. - replaceFrom:(int)start to:(int)end with:(const char *)aString
  27. {
  28.   return [[self removeFrom:start to:end] insert:aString at:start];
  29. }
  30.  
  31. - replaceFrom:(int)start length:(int)len withString:(id)sender
  32. {
  33.   if (![sender respondsTo:@selector(stringValue)]) return self;
  34.   return [self replaceFrom:start length:len with:[sender stringValue]];
  35. }
  36.  
  37. - replaceFrom:(int)start to:(int)end withString:(id)sender
  38. {
  39.   if (![sender respondsTo:@selector(stringValue)]) return self;
  40.   return [self replaceFrom:start to:end with:[sender stringValue]];
  41. }
  42.  
  43. /* Two methods no longer used:
  44. - replace:(const char *)subString with:(const char *)newString
  45. {
  46.   const char *spot;
  47.   
  48.   if ((spot = [self strstr:subString]))
  49.     [self replaceFrom:(int)(spot-buffer) length:strlen(subString) with:newString];
  50.   return self;
  51. }
  52.  
  53. - replace:(const char *)subString withString:(id)sender
  54. {
  55.   if (![sender respondsTo:@selector(stringValue)]) return self;
  56.   return [self replace:subString with:[sender stringValue]];
  57. }
  58. */
  59.  
  60. - replaceCharAt:(int)index withChar:(char)aChar
  61. {    // no change if index is out of range.
  62.     // Other option is to limit index to be in range.  which is better?
  63.   if ((index < 0) || (index >= length)) return self;
  64.  
  65.   if (aChar == 0) return self; // should this return nil? DAY: leave it.
  66.  
  67.   buffer[index] = aChar;
  68.   return self;
  69. }
  70.  
  71. - replaceFrom:(int)start length:(int)len withChar:(char)aChar
  72. {
  73.     id retval,tempStr;
  74.    
  75.     if (aChar == 0) return nil;
  76.     tempStr = [[[[self class] alloc] init] addChar:aChar];
  77.     retval = [self  replaceFrom:start length:len
  78.                     withString:tempStr];
  79.     [tempStr free];
  80.     return retval;
  81. }
  82.  
  83. - replaceFrom:(int)start to:(int)end withChar:(char)aChar
  84. {
  85.   return [self replaceFrom:start length:end-start+1 withChar:aChar];
  86. }
  87.  
  88. - replaceEveryOccurrenceOfChars:(const char *)aString
  89.         with:(const char *)replaceString
  90. {
  91.     return [self replaceEveryOccurrenceOfChars:aString
  92.             with:replaceString caseSensitive:YES];
  93. }
  94.  
  95. - replaceEveryOccurrenceOfChars:(const char *)aString
  96.         with:(const char *)replaceString caseSensitive:(BOOL)sense
  97. {
  98.     int i;
  99.     id tempStr;
  100.  
  101.     if (!aString) return self;
  102.         // I think a null replace string should be allowed here...
  103.  
  104.     tempStr = [MiscString newWithString:aString];
  105.     for (i=length-1;i>=0;i--)
  106.     if ([tempStr spotOf:buffer[i] caseSensitive:sense] != -1)
  107.         [self replaceFrom:i to:i with:replaceString];
  108.  
  109.     [tempStr free];
  110.     return self;
  111. }
  112.  
  113. - replaceEveryOccurrenceOfChars:(const char *)aString
  114.         withChar:(char)replaceChar
  115. {
  116.     return [self replaceEveryOccurrenceOfChars:aString
  117.             withChar:replaceChar caseSensitive:YES];
  118. }
  119.  
  120. - replaceEveryOccurrenceOfChars:(const char *)aString
  121.         withChar:(char)replaceChar caseSensitive:(BOOL)sense
  122. {
  123.     int i;
  124.     id tempStr;
  125.  
  126.     if (!aString) return self;
  127.     if (!replaceChar) return nil;  //or return self?
  128.  
  129.     tempStr = [MiscString newWithString:aString];
  130.     for (i=length-1;i>=0;i--)
  131.         if ([tempStr spotOf:buffer[i] caseSensitive:sense] != -1)
  132.             buffer[i] = replaceChar;
  133.  
  134.     [tempStr free];
  135.     return self;
  136. }
  137.  
  138. - replaceEveryOccurrenceOfChars:(const char *)aString withString:(id)sender
  139. {
  140.     if (![sender respondsTo:@selector(stringValue)]) return self;
  141.     return [self replaceEveryOccurrenceOfChars:aString
  142.             with:[sender stringValue] caseSensitive:YES];
  143. }
  144.  
  145. - replaceEveryOccurrenceOfChars:(const char *)aString
  146.         withString:(id)sender caseSensitive:(BOOL)sense
  147. {
  148.     if (![sender respondsTo:@selector(stringValue)]) return self;
  149.     return [self replaceEveryOccurrenceOfChars:aString
  150.             with:[sender stringValue] caseSensitive:sense];
  151. }
  152.  
  153. - replaceEveryOccurrenceOfChar:(char)aChar with:(const char *)aString
  154.         caseSensitive:(BOOL)sense
  155. {
  156.     int i;
  157.  
  158.     if (!aChar) return self; // I think a null string should be allowed here...
  159.     if (sense) {
  160.         for (i=length-1;i>=0;i--)
  161.             if (buffer[i] == aChar)
  162.                 [self replaceFrom:i to:i with:aString];
  163.     } else {
  164.         for (i=length-1;i>=0;i--)
  165.             if (NXToUpper(buffer[i]) == NXToUpper(aChar))
  166.                 [self replaceFrom:i to:i with:aString];
  167.     }
  168.     return self;
  169. }
  170.  
  171. - replaceEveryOccurrenceOfChar:(char)aChar with:(const char *)aString
  172. {
  173.     return [self replaceEveryOccurrenceOfChar:aChar
  174.             with:aString caseSensitive:YES];
  175. }
  176.  
  177. - replaceEveryOccurrenceOfChar:(char)aChar withString:(id)sender
  178. {
  179.     if (![sender respondsTo:@selector(stringValue)]) return self;
  180.     return [self replaceEveryOccurrenceOfChar:aChar
  181.             with:[sender stringValue] caseSensitive:YES];
  182. }
  183.  
  184. - replaceEveryOccurrenceOfChar:(char)aChar withString:(id)sender
  185.         caseSensitive:(BOOL)sense
  186. {
  187.     if (![sender respondsTo:@selector(stringValue)]) return self;
  188.     return [self replaceEveryOccurrenceOfChar:aChar
  189.             with:[sender stringValue] caseSensitive:sense];
  190. }
  191.  
  192. - replaceEveryOccurrenceOfChar:(char)aChar withChar:(char)replaceChar
  193.         caseSensitive:(BOOL)sense
  194. {
  195.     int i;
  196.  
  197.     if (!aChar) return self;
  198.     if (!replaceChar) return nil;  //or return self?
  199.  
  200.     if (sense) {
  201.         for (i=length-1; i>=0; i--)
  202.             if (buffer[i] == aChar)
  203.                 buffer[i] = replaceChar;
  204.     } else {
  205.         for (i=length-1; i>=0; i--)
  206.             if (NXToUpper(buffer[i]) == NXToUpper(aChar))
  207.                 buffer[i] = replaceChar;
  208.     }
  209.     return self;
  210. }
  211.  
  212.  
  213. - replaceEveryOccurrenceOfChar:(char)aChar withChar:(char)replaceChar
  214. {
  215.     return [self replaceEveryOccurrenceOfChar:aChar
  216.             withChar:replaceChar caseSensitive:YES];
  217. }
  218.  
  219. /* old methods no longer used:
  220. // string replacements by Bruce McKenzie <bruce@trwlasd.com>
  221. - replaceEveryOccurrenceOf:(const char *)subString    
  222.     with:(const char *)newString
  223. {
  224.     const char *spot;
  225.     int subStringLen;
  226.     
  227.     if (!subString) return nil;
  228.     subStringLen = strlen(subString);
  229.     if (!subStringLen) return nil;
  230.     while ((spot = [self strstr:subString]))
  231.         [self replaceFrom:(int)(spot-buffer) length:subStringLen
  232.                 with:(newString ? newString : "")];
  233.     return self;
  234. }
  235.  
  236. // and three extra covers by Don Yacktman:
  237. - replaceEveryOccurrenceOfString:(id)subString with:(const char *)newString
  238. {
  239.     return [self replaceEveryOccurrenceOf:[subString stringValue]
  240.                 with:newString];
  241. }
  242.  
  243. - replaceEveryOccurrenceOf:(const char *)subString withString:(id)newString
  244. {
  245.     return [self replaceEveryOccurrenceOf:subString
  246.                 with:[newString stringValue]];
  247. }
  248.  
  249. - replaceEveryOccurrenceOfString:(id)subString withString:(id)newString
  250. {
  251.     return [self replaceEveryOccurrenceOf:[subString stringValue]
  252.                 with:[newString stringValue]];
  253. }
  254. */
  255.  
  256. - replaceType:(int)type with:(const char *)str occurrenceNum:(int)n
  257. {
  258.   int spot;
  259.  
  260.   if (n == MISC_STRING_LAST) spot = [self rspotOfType:type occurrenceNum:0];
  261.   else spot = [self spotOfType:type occurrenceNum:n];
  262.  
  263.   if (spot < 0) return self;
  264.   return [self replaceFrom:spot length:1 with:str];
  265. }
  266.  
  267. - replaceType:(int)type withString:(id)sender occurrenceNum:(int)n
  268. { 
  269.   if (![sender respondsTo:@selector(stringValue)]) return self;
  270.   return [self replaceType:type with:[sender stringValue] occurrenceNum:0];
  271. }
  272.  
  273. - replaceType:(int)type withChar:(char)aChar occurrenceNum:(int)n
  274. { 
  275.   char str[2] = {aChar, 0};
  276.   return [self replaceType:type with:str occurrenceNum:n]; 
  277. }
  278.  
  279.  
  280. - replaceEveryOccurrenceOfType:(int)type with:(const char *)str
  281. {
  282.   int i;
  283.   id tmpStr = [[[self class] alloc] initCapacity:length];
  284.  
  285.   for (i=0;i<length;i++) {
  286.     if (type & MISC_UPPER)  if (NXIsUpper(buffer[i]))  {[tmpStr cat:str]; continue;}
  287.     if (type & MISC_LOWER)  if (NXIsLower(buffer[i]))  {[tmpStr cat:str]; continue;}
  288.     if (type & MISC_DIGIT)  if (NXIsDigit(buffer[i]))  {[tmpStr cat:str]; continue;}
  289.     if (type & MISC_XDIGIT) if (NXIsXDigit(buffer[i])) {[tmpStr cat:str]; continue;}
  290.     if (type & MISC_PUNCT)  if (NXIsPunct(buffer[i]))  {[tmpStr cat:str]; continue;}
  291.     if (type & MISC_ASCII)  if (NXIsAscii(buffer[i]))  {[tmpStr cat:str]; continue;}
  292.     if (type & MISC_CNTRL)  if (NXIsCntrl(buffer[i]))  {[tmpStr cat:str]; continue;}
  293.     if (type & MISC_PRINT)  if (NXIsPrint(buffer[i]))  {[tmpStr cat:str]; continue;}
  294.     if (type & MISC_SPACE)  if (NXIsSpace(buffer[i]))  {[tmpStr cat:str]; continue;}
  295.     if (type & MISC_GRAPH)  if (NXIsGraph(buffer[i]))  {[tmpStr cat:str]; continue;}
  296.     [tmpStr addChar:buffer[i]];
  297.    }
  298.  
  299.   [self takeStringValueFrom:tmpStr];
  300.   [tmpStr free];
  301.   return self;
  302. }
  303.  
  304.  
  305. - replaceEveryOccurrenceOfType:(int)type withChar:(char)aChar 
  306. {
  307.   char str[2] = {aChar, 0};
  308.   return [self replaceEveryOccurrenceOfType:type with:str];
  309. }
  310.  
  311. - replaceEveryOccurrenceOfType:(int)type withString:(id)sender
  312. { 
  313.   if (![sender respondsTo:@selector(stringValue)]) return self;
  314.   return [self replaceEveryOccurrenceOfType:type with:[sender stringValue]]; 
  315. }
  316.  
  317. - (int)replaceEveryOccurrenceOf:(const char *)str with:(const char *)repl caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  318. {
  319.   char fchar;
  320.   int currspot = 0, len, lastspot = 0, currnum = 0;
  321.   id tmpStr;
  322.  
  323.   if (!str || ((len = strlen(str)) == 0)) return 0;
  324.   tmpStr = [[[self class] alloc] initCapacity:length];
  325.   fchar = (sense)? str[0]:NXToUpper(str[0]);
  326.   
  327.   while (currspot <= (length-len)) {
  328.     while ((currspot <= (length-len)) && (fchar != ((sense)?
  329.            buffer[currspot]:NXToUpper(buffer[currspot]))))
  330.       currspot++;
  331.     if (!NXOrderStrings((unsigned char *)str,(unsigned char *)buffer+currspot,sense,len,orderTable)) {
  332.       if ((currspot-lastspot) > 0)  // Can't -cat:n: if n < 0, so don't try (happens if overlapping)
  333.         [tmpStr cat:buffer+lastspot n:currspot-lastspot];
  334.       [tmpStr cat:repl];
  335.       lastspot=currspot+len;
  336.       if (overlap) currspot++;
  337.       else currspot+=len;
  338.       currnum++;
  339.      }
  340.     else currspot++;
  341.    }
  342.   
  343.   if (currnum) {  //there was a change made
  344.     [tmpStr cat:buffer+lastspot n:length-lastspot];
  345.     [self takeStringValueFrom:tmpStr];
  346.    }
  347.   [tmpStr free];
  348.   return currnum;
  349. }
  350.  
  351. - (int)replaceEveryOccurrenceOf:(const char *)str withChar:(char)aChar caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  352. {
  353.   char tmp[2] = {aChar,0};
  354.   return [self replaceEveryOccurrenceOf:str with:tmp caseSensitive:sense overlap:overlap];
  355. }
  356.  
  357. - (int)replaceEveryOccurrenceOf:(const char *)str withString:(id)sender caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  358. {
  359.   if (![sender respondsTo:@selector(stringValue)]) return 0;
  360.   return [self replaceEveryOccurrenceOf:str with:[sender stringValue] caseSensitive:sense overlap:overlap];
  361. }
  362.  
  363. - (int)replaceEveryOccurrenceOfString:(id)sender with:(const char *)repl caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  364. {
  365.   if (![sender respondsTo:@selector(stringValue)]) return 0;
  366.   return [self replaceEveryOccurrenceOf:[sender stringValue] with:repl caseSensitive:sense overlap:overlap];
  367. }
  368.  
  369. - (int)replaceEveryOccurrenceOfString:(id)sender withChar:(char)aChar caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  370. {
  371.   char str[2] = {aChar,0};
  372.   if (![sender respondsTo:@selector(stringValue)]) return 0;
  373.   return [self replaceEveryOccurrenceOf:[sender stringValue] with:str caseSensitive:sense overlap:overlap];
  374. }
  375.  
  376. - (int)replaceEveryOccurrenceOfString:(id)sender withString:(id)repl caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  377. {
  378.   if (![sender respondsTo:@selector(stringValue)]) return 0;
  379.   if (![repl   respondsTo:@selector(stringValue)]) return 0;
  380.   return [self replaceEveryOccurrenceOf:[sender stringValue] 
  381.       with:[repl stringValue] caseSensitive:sense overlap:overlap];
  382. }
  383.  
  384. - replace:(const char *)str with:(const char *)repl occurrenceNum:(int)n caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  385. {
  386.   int spot, len;
  387.  
  388.   if (n == MISC_STRING_LAST)
  389.     spot = [self rspotOfStr:str occurrenceNum:0 caseSensitive:sense overlap:overlap];
  390.   else spot = [self spotOfStr:str occurrenceNum:n caseSensitive:sense overlap:overlap];
  391.  
  392.   if (spot<0) return self;
  393.   len = strlen(str); //str is not NULL here for sure
  394.   
  395.   return [self replaceFrom:spot length:len with:repl];
  396. }
  397.  
  398. - replace:(const char *)str withChar:(char)aChar occurrenceNum:(int)n caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  399. {
  400.   char tmp[2] = {aChar, 0};
  401.   return [self replace:str with:tmp occurrenceNum:n caseSensitive:sense overlap:overlap];
  402. }
  403.  
  404. - replace:(const char *)str withString:(id)sender occurrenceNum:(int)n caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  405. {
  406.   if (![sender respondsTo:@selector(stringValue)]) return self;
  407.   return [self replace:str with:[sender stringValue] occurrenceNum:n caseSensitive:sense overlap:overlap];
  408. }
  409.  
  410. - replaceString:(id)sender with:(const char *)repl occurrenceNum:(int)n caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  411. {
  412.   if (![sender respondsTo:@selector(stringValue)]) return self;
  413.   return [self replace:[sender stringValue] with:repl occurrenceNum:n caseSensitive:sense overlap:overlap];
  414. }
  415.  
  416. - replaceString:(id)sender withChar:(char)aChar occurrenceNum:(int)n caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  417. {
  418.   if (![sender respondsTo:@selector(stringValue)]) return self;
  419.   return [self replace:[sender stringValue] withChar:aChar occurrenceNum:n caseSensitive:sense overlap:overlap];
  420. }
  421.  
  422. - replaceString:(id)sender withString:(id)repl occurrenceNum:(int)n caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  423. {
  424.   if (![sender respondsTo:@selector(stringValue)]) return self;
  425.   if (![repl   respondsTo:@selector(stringValue)]) return self;
  426.   return [self replace:[sender stringValue] with:[repl stringValue] occurrenceNum:n caseSensitive:sense overlap:overlap];
  427. }
  428.  
  429. /*******************************************************************/
  430. /**************   Convenience methods ******************************/
  431. /*******************************************************************/
  432.  
  433.  
  434. - replaceType:(int)type with:(const char *)str
  435. { return [self replaceType:type with:str occurrenceNum:0]; }
  436.  
  437. - replaceType:(int)type withChar:(char)aChar
  438. { return [self replaceType:type withChar:aChar occurrenceNum:0]; }
  439.  
  440. - replaceType:(int)type withString:(id)sender
  441. { return [self replaceType:type withString:sender occurrenceNum:0]; }
  442.  
  443. - (int)replaceEveryOccurrenceOf:(const char *)str with:(const char *)repl
  444. { return [self replaceEveryOccurrenceOf:str with:repl caseSensitive:YES overlap:NO]; }
  445.  
  446. - (int)replaceEveryOccurrenceOf:(const char *)str with:(const char *)repl caseSensitive:(BOOL)sense
  447. { return [self replaceEveryOccurrenceOf:str with:repl caseSensitive:sense overlap:NO]; }
  448.  
  449. - (int)replaceEveryOccurrenceOf:(const char *)str with:(const char *)repl overlap:(BOOL)overlap
  450. { return [self replaceEveryOccurrenceOf:str with:repl caseSensitive:YES overlap:overlap]; }
  451.  
  452.  
  453. - (int)replaceEveryOccurrenceOf:(const char *)str withChar:(char)aChar
  454. { return [self replaceEveryOccurrenceOf:str withChar:aChar caseSensitive:YES overlap:NO]; }
  455.  
  456. - (int)replaceEveryOccurrenceOf:(const char *)str withChar:(char)aChar caseSensitive:(BOOL)sense
  457. { return [self replaceEveryOccurrenceOf:str withChar:aChar caseSensitive:sense overlap:NO]; }
  458.  
  459. - (int)replaceEveryOccurrenceOf:(const char *)str withChar:(char)aChar overlap:(BOOL)overlap
  460. { return [self replaceEveryOccurrenceOf:str withChar:aChar caseSensitive:YES overlap:overlap]; }
  461.  
  462.  
  463. - (int)replaceEveryOccurrenceOf:(const char *)str withString:(id)sender
  464. { return [self replaceEveryOccurrenceOf:str withString:sender caseSensitive:YES overlap:NO]; }
  465.  
  466. - (int)replaceEveryOccurrenceOf:(const char *)str withString:(id)sender caseSensitive:(BOOL)sense
  467. { return [self replaceEveryOccurrenceOf:str withString:sender caseSensitive:sense overlap:NO]; }
  468.  
  469. - (int)replaceEveryOccurrenceOf:(const char *)str withString:(id)sender overlap:(BOOL)overlap
  470. { return [self replaceEveryOccurrenceOf:str withString:sender caseSensitive:YES overlap:overlap]; }
  471.  
  472.  
  473.  
  474. - (int)replaceEveryOccurrenceOfString:(id)sender with:(const char *)repl
  475. { return [self replaceEveryOccurrenceOfString:sender with:repl caseSensitive:YES overlap:NO]; }
  476.  
  477. - (int)replaceEveryOccurrenceOfString:(id)sender with:(const char *)repl caseSensitive:(BOOL)sense
  478. { return [self replaceEveryOccurrenceOfString:sender with:repl caseSensitive:sense overlap:NO]; }
  479.  
  480. - (int)replaceEveryOccurrenceOfString:(id)sender with:(const char *)repl overlap:(BOOL)overlap
  481. { return [self replaceEveryOccurrenceOfString:sender with:repl caseSensitive:YES overlap:overlap]; }
  482.  
  483.  
  484. - (int)replaceEveryOccurrenceOfString:(id)sender withChar:(char)aChar
  485. { return [self replaceEveryOccurrenceOfString:sender withChar:aChar caseSensitive:YES overlap:NO]; }
  486.  
  487. - (int)replaceEveryOccurrenceOfString:(id)sender withChar:(char)aChar caseSensitive:(BOOL)sense
  488. { return [self replaceEveryOccurrenceOfString:sender withChar:aChar caseSensitive:sense overlap:NO]; }
  489.  
  490. - (int)replaceEveryOccurrenceOfString:(id)sender withChar:(char)aChar overlap:(BOOL)overlap
  491. { return [self replaceEveryOccurrenceOfString:sender withChar:aChar caseSensitive:YES overlap:overlap]; }
  492.  
  493.  
  494. - (int)replaceEveryOccurrenceOfString:(id)sender withString:(id)repl
  495. { return [self replaceEveryOccurrenceOfString:sender withString:repl caseSensitive:YES overlap:NO]; }
  496.  
  497. - (int)replaceEveryOccurrenceOfString:(id)sender withString:(id)repl caseSensitive:(BOOL)sense
  498. { return [self replaceEveryOccurrenceOfString:sender withString:repl caseSensitive:sense overlap:NO]; }
  499.  
  500. - (int)replaceEveryOccurrenceOfString:(id)sender withString:(id)repl overlap:(BOOL)overlap
  501. { return [self replaceEveryOccurrenceOfString:sender withString:repl caseSensitive:YES overlap:overlap]; }
  502.  
  503.  
  504.  
  505. - replace:(const char *)str with:(const char *)repl
  506. { return [self replace:str with:repl occurrenceNum:0 caseSensitive:YES overlap:NO]; }
  507.  
  508. - replace:(const char *)str with:(const char *)repl occurrenceNum:(int)n
  509. { return [self replace:str with:repl occurrenceNum:n caseSensitive:YES overlap:NO]; }
  510.  
  511. - replace:(const char *)str with:(const char *)repl caseSensitive:(BOOL)sense
  512. { return [self replace:str with:repl occurrenceNum:0 caseSensitive:sense overlap:NO]; }
  513.  
  514. - replace:(const char *)str with:(const char *)repl occurrenceNum:(int)n caseSensitive:(BOOL)sense
  515. { return [self replace:str with:repl occurrenceNum:n caseSensitive:sense overlap:NO]; }
  516.  
  517. - replace:(const char *)str with:(const char *)repl overlap:(BOOL)overlap
  518. { return [self replace:str with:repl occurrenceNum:0 caseSensitive:YES overlap:overlap]; }
  519.  
  520. - replace:(const char *)str with:(const char *)repl occurrenceNum:(int)n overlap:(BOOL)overlap
  521. { return [self replace:str with:repl occurrenceNum:n caseSensitive:YES overlap:overlap]; }
  522.  
  523. - replace:(const char *)str with:(const char *)repl caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  524. { return [self replace:str with:repl occurrenceNum:0 caseSensitive:sense overlap:overlap]; }
  525.  
  526.  
  527. - replace:(const char *)str withChar:(char)aChar
  528. { return [self replace:str withChar:aChar occurrenceNum:0 caseSensitive:YES overlap:NO]; }
  529.  
  530. - replace:(const char *)str withChar:(char)aChar occurrenceNum:(int)n
  531. { return [self replace:str withChar:aChar occurrenceNum:n caseSensitive:YES overlap:NO]; }
  532.  
  533. - replace:(const char *)str withChar:(char)aChar caseSensitive:(BOOL)sense
  534. { return [self replace:str withChar:aChar occurrenceNum:0 caseSensitive:sense overlap:NO]; }
  535.  
  536. - replace:(const char *)str withChar:(char)aChar occurrenceNum:(int)n caseSensitive:(BOOL)sense
  537. { return [self replace:str withChar:aChar occurrenceNum:n caseSensitive:sense overlap:NO]; }
  538.  
  539. - replace:(const char *)str withChar:(char)aChar overlap:(BOOL)overlap
  540. { return [self replace:str withChar:aChar occurrenceNum:0 caseSensitive:YES overlap:overlap]; }
  541.  
  542. - replace:(const char *)str withChar:(char)aChar occurrenceNum:(int)n overlap:(BOOL)overlap
  543. { return [self replace:str withChar:aChar occurrenceNum:n caseSensitive:YES overlap:overlap]; }
  544.  
  545. - replace:(const char *)str withChar:(char)aChar caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  546. { return [self replace:str withChar:aChar occurrenceNum:0 caseSensitive:sense overlap:overlap]; }
  547.  
  548.  
  549. - replace:(const char *)str withString:(id)sender
  550. { return [self replace:str withString:sender occurrenceNum:0 caseSensitive:YES overlap:NO]; }
  551.  
  552. - replace:(const char *)str withString:(id)sender occurrenceNum:(int)n
  553. { return [self replace:str withString:sender occurrenceNum:n caseSensitive:YES overlap:NO]; }
  554.  
  555. - replace:(const char *)str withString:(id)sender caseSensitive:(BOOL)sense
  556. { return [self replace:str withString:sender occurrenceNum:0 caseSensitive:sense overlap:NO]; }
  557.  
  558. - replace:(const char *)str withString:(id)sender occurrenceNum:(int)n caseSensitive:(BOOL)sense
  559. { return [self replace:str withString:sender occurrenceNum:n caseSensitive:sense overlap:NO]; }
  560.  
  561. - replace:(const char *)str withString:(id)sender overlap:(BOOL)overlap
  562. { return [self replace:str withString:sender occurrenceNum:0 caseSensitive:YES overlap:overlap]; }
  563.  
  564. - replace:(const char *)str withString:(id)sender occurrenceNum:(int)n overlap:(BOOL)overlap
  565. { return [self replace:str withString:sender occurrenceNum:n caseSensitive:YES overlap:overlap]; }
  566.  
  567. - replace:(const char *)str withString:(id)sender caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  568. { return [self replace:str withString:sender occurrenceNum:0 caseSensitive:sense overlap:overlap]; }
  569.  
  570.  
  571.  
  572. - replaceString:(id)sender with:(const char *)repl
  573. { return [self replaceString:sender with:repl occurrenceNum:0 caseSensitive:YES overlap:NO]; }
  574.  
  575. - replaceString:(id)sender with:(const char *)repl occurrenceNum:(int)n
  576. { return [self replaceString:sender with:repl occurrenceNum:n caseSensitive:YES overlap:NO]; }
  577.  
  578. - replaceString:(id)sender with:(const char *)repl caseSensitive:(BOOL)sense
  579. { return [self replaceString:sender with:repl occurrenceNum:0 caseSensitive:sense overlap:NO]; }
  580.  
  581. - replaceString:(id)sender with:(const char *)repl occurrenceNum:(int)n caseSensitive:(BOOL)sense
  582. { return [self replaceString:sender with:repl occurrenceNum:n caseSensitive:sense overlap:NO]; }
  583.  
  584. - replaceString:(id)sender with:(const char *)repl overlap:(BOOL)overlap
  585. { return [self replaceString:sender with:repl occurrenceNum:0 caseSensitive:YES overlap:overlap]; }
  586.  
  587. - replaceString:(id)sender with:(const char *)repl occurrenceNum:(int)n overlap:(BOOL)overlap
  588. { return [self replaceString:sender with:repl occurrenceNum:n caseSensitive:YES overlap:overlap]; }
  589.  
  590. - replaceString:(id)sender with:(const char *)repl caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  591. { return [self replaceString:sender with:repl occurrenceNum:0 caseSensitive:sense overlap:overlap]; }
  592.  
  593.  
  594. - replaceString:(id)sender withChar:(char)aChar
  595. { return [self replaceString:sender withChar:aChar occurrenceNum:0 caseSensitive:YES overlap:NO]; }
  596.  
  597. - replaceString:(id)sender withChar:(char)aChar occurrenceNum:(int)n
  598. { return [self replaceString:sender withChar:aChar occurrenceNum:n caseSensitive:YES overlap:NO]; }
  599.  
  600. - replaceString:(id)sender withChar:(char)aChar caseSensitive:(BOOL)sense
  601. { return [self replaceString:sender withChar:aChar occurrenceNum:0 caseSensitive:sense overlap:NO]; }
  602.  
  603. - replaceString:(id)sender withChar:(char)aChar occurrenceNum:(int)n caseSensitive:(BOOL)sense
  604. { return [self replaceString:sender withChar:aChar occurrenceNum:n caseSensitive:sense overlap:NO]; }
  605.  
  606. - replaceString:(id)sender withChar:(char)aChar overlap:(BOOL)overlap
  607. { return [self replaceString:sender withChar:aChar occurrenceNum:0 caseSensitive:YES overlap:overlap]; }
  608.  
  609. - replaceString:(id)sender withChar:(char)aChar occurrenceNum:(int)n overlap:(BOOL)overlap
  610. { return [self replaceString:sender withChar:aChar occurrenceNum:n caseSensitive:YES overlap:overlap]; }
  611.  
  612. - replaceString:(id)sender withChar:(char)aChar caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  613. { return [self replaceString:sender withChar:aChar occurrenceNum:0 caseSensitive:sense overlap:overlap]; }
  614.  
  615.  
  616. - replaceString:(id)sender withString:(id)repl
  617. { return [self replaceString:sender withString:repl occurrenceNum:0 caseSensitive:YES overlap:NO]; }
  618.  
  619. - replaceString:(id)sender withString:(id)repl occurrenceNum:(int)n
  620. { return [self replaceString:sender withString:repl occurrenceNum:n caseSensitive:YES overlap:NO]; }
  621.  
  622. - replaceString:(id)sender withString:(id)repl caseSensitive:(BOOL)sense
  623. { return [self replaceString:sender withString:repl occurrenceNum:0 caseSensitive:sense overlap:NO]; }
  624.  
  625. - replaceString:(id)sender withString:(id)repl occurrenceNum:(int)n caseSensitive:(BOOL)sense
  626. { return [self replaceString:sender withString:repl occurrenceNum:n caseSensitive:sense overlap:NO]; }
  627.  
  628. - replaceString:(id)sender withString:(id)repl overlap:(BOOL)overlap
  629. { return [self replaceString:sender withString:repl occurrenceNum:0 caseSensitive:YES overlap:overlap]; }
  630.  
  631. - replaceString:(id)sender withString:(id)repl occurrenceNum:(int)n overlap:(BOOL)overlap
  632. { return [self replaceString:sender withString:repl occurrenceNum:n caseSensitive:YES overlap:overlap]; }
  633.  
  634. - replaceString:(id)sender withString:(id)repl caseSensitive:(BOOL)sense overlap:(BOOL)overlap
  635. { return [self replaceString:sender withString:repl occurrenceNum:0 caseSensitive:sense overlap:overlap]; }
  636.  
  637.  
  638. @end
  639.