Rosetta Code

CHANGESTR.REX: Difference between revisions

Page Discussion

CHANGESTR.REX (view source)

Revision as of 20:23, 15 October 2018

6,976 bytes added ,  5 years ago
m
moved a category to TOF.
(added functionality to this version of the CHANGESTR function, changed comments, indentation. -- ~~~~)
m (moved a category to TOF.)
 
(12 intermediate revisions by 2 users not shown)
Line 1:
[[Category:REXX_library_routines]]
<lang rexx>/*REXX program emulates the CHANGESTR built-in function for older REXXes*/
/*──── This version has more functionality: limit the number of changes.*/
/*──── start of change occurance. */
/*──── start of change position. */
 
== the CHANGESTR function ==
/*╔══════════════════════════ CHANGESTR function ══════════════════════╗
This a RYO version of the REXX function &nbsp; '''changestr''' &nbsp; (<u>change</u> <u>str</u>ing).
╔═╩════════════════════════════════════════════════════════════════════╩═╗
 
║ The CHANGESTR function is used to replace some or all occurances of an ║
It is included in some of the more modern Classic REXXes, but older versions of
║ (old) string in a haystack with a new string. The changed string is ║
<br>Classic REXX don't have this function as a &nbsp; BIF &nbsp; (<u>B</u>uilt-<u>I</u>n-<u>F</u>unction).
║ returned. If the haystack doesn't contain the old string, the ║
 
║ original haystack is returned. If the old string is a null string, ║
 
║ then the original string is prefixed with the new string. ║
 
║ ║
This version of the &nbsp; '''changestr''' &nbsp; BIF has more functionality than the standard BIF.
║ new string to be used►──────────┐ ┌─────◄limit of # changes (times).║
 
║ original string (haystack)►──────┐ │ │ [default: ≈ one billian]║
 
║ old string to be replaced►──┐ │ │ │ ┌────◄begin at this occurance #.║
__TOC__
║ {O, H, and N can be null.} │ │ │ │ │ ┌──◄start position (default=1)║
 
╚═╦════════════════════════════╗ │ │ │ │ │ │ ╔═════════════════════════╦═╝
 
╚════════════════════════════╝ │ │ │ │ │ │ ╚═════════════════════════╝
 
↓ ↓ ↓ ↓ ↓ ↓ */
===the CHANGESTR (external) program source===
changestr: parse arg o,h,n,t,b,p /* T, B, & P are optional.*/
The following &nbsp; CHANGESTR &nbsp; program can be coded as is when the intention is to be an external routine (function).
$='' /*$: the returned string.*/
<lang rexx>/*REXX program emulates the CHANGESTR BIF (built-in function) for older REXXes.*/
/*optional arguments ··· */
/*──────────── This version has more functionality: limit the number of changes. */
t=word(t 999999999 , 1) /*maybe use the default? */
b=word(b/*──────────── 1 , 1) /* " " " " start of change occurrence#. */
p=word(p/*──────────── 1 , 1) /* " " " start "of change position. */
 
if arg() < 3 then signal syntax /*not enough arguments. */
/* ╔═══════════════════════════ CHANGESTR function ════════════════════════╗
if arg() > 6 then signal syntax /*too many arguments. */
╔═╩═══════════════════════════════════════════════════════════════════════╩═╗
if \datatype(t,'W') then signal syntax /*4th arg not an integer. */
║ The CHANGESTR function is used to replace some or all occurrences of an ║
if \datatype(b,'W') then signal syntax /*5th " " " " */
║ (old) string in a haystack with a new string. The changed string is ║
if \datatype(p,'W') then signal syntax /*5th arg " " " */
if t<0 ║ returned. If the haystack doesn't contain the old then signalstring, syntax the /*4th arg not non-negative*/║
║ original haystack is returned. If the old string is a null string, ║
if b<1 then signal syntax /*5th arg not positive. */
if p<1 ║ then the original string is prefixed with the new then signal syntax /*6th " " string. " */║
L=length(o) ║ /*length of OLD string. */ ║
║ new string to be used ►──────┐ ┌──────◄ limit of # changes (times).║
if L==0 & t\=0 then return n || h /*changing a null char? */
║ original string (haystack) ►────┐ │ │ [default: ≈ one billion] ║
f='' /*first part of H if P>1. */
║ old string to be replaced ►──┐ │ │ │ ┌────◄ begin at this occurrence # ║
if p\=1 then do /*if P ¬= 1, adjust F & H.*/
║ {O, H, and N can be null.} │ │ │ │ │ ┌──◄ start position (default=1) ║
f=left(h, min(p-1, length(h))) /*keep first part intact. */
╚═╦═════════════════════════════╗ │ │ │ │ │ │ ╔═══════════════════════════╦═╝
h=substr(h,p) /*only use this part of H.*/
╚═════════════════════════════╝ │ │ │ │ │ │ ╚═══════════════════════════╝
end /*now, proceed as usual. */
#=0 ↓ ↓ ↓ ↓ ↓ ↓ /*# of changed occurances.*/
do j=1 while # < t parse arg o,h,n,t,b,p, ,$ f /*keep changing, T times. ◄────────────────────┐*/
parse var h y (o) _ +(L) h /*parseT, theB, haystackP ···are optional ►─┘*/
if _= t=''word(t 999999999, 1) then return f || $ || y /*nomaybe more left,use the return.default? */
$ b=$word(b ||1 y , 1) /*append the residual" " " " txt.*/
if j<b p=word(p 1 , 1) then $=$ || o /*append OLD if" " " " too soon. */
if arg() < else do 3 then signal syntax /*metnot theenough arguments. occurance test. */
if arg() > 6 $=$ || n then signal syntax /*too many arguments. /*append the NEW string.*/
if \datatype(t, 'W') then signal #=#+1 syntax /*bump4th arg occurancenot an numberinteger. */
if \datatype(b, 'W') then signal syntax end/*5th " " " " */
if \datatype(p, 'W') then signal syntax /*6th " " " " */
end /*j*/
if t<0 then signal syntax /*4th " " /*Note: Most REXX BIFs··· non-negative.*/
return f || $ || h if b<1 then signal syntax /*5th only support" 3 options " positive. */</lang>
if p<1 then signal syntax /*6th " " " */
L=length(o) /*length of OLD string. */
if L==0 & t\=0 then return n || h /*changing a [null] char? */
/* [↓] check for position*/
if p\=1 then do /*P¬=1? Then ajust F & H.*/
f=left(h, min(p-1, length(h))) /*keep first part intact. */
h=substr(h, p) /*only use this part of H.*/
end /*now, proceed as usual. */
#=0 /*# of changed occurrences*/
do j=1 while # < t /*keep changing, T times. */
parse var h y (o) _ +(L) h /*parse the haystack ··· */
if _=='' then return f || $ || y /*no more left, return. */
$=$ || y /*append the residual txt.*/
/* [↓] check if too soon.*/
if j<b then $=$ || o /*append OLD if too soon. */
else do /*met the occurrence test.*/
$=$ || n /*append the NEW string.*/
#=#+1 /*bump occurrence number. */
end /* [↑] append new string.*/
end /*j*/ /*Note: most REXX ··· */
/* CHANGESTR BIFs only ···*/
return f || $ || h /* support three options. */</lang>
 
=== the CHANGESTR (internal) procedure source ===
The following CHANGESTR program can be coded as is when the intention is to be an internal routine (function).
 
Only the '''changestr:''' statement is changed &nbsp; (by adding a &nbsp; '''procedure''' &nbsp; to the label).
<lang rexx>/*REXX program emulates the CHANGESTR BIF (built-in function) for older REXXes.*/
/*──────────── This version has more functionality: limit the number of changes. */
/*──────────── start of change occurrence#. */
/*──────────── start of change position. */
 
/* ╔═══════════════════════════ CHANGESTR function ════════════════════════╗
╔═╩═══════════════════════════════════════════════════════════════════════╩═╗
║ The CHANGESTR function is used to replace some or all occurrences of an ║
║ (old) string in a haystack with a new string. The changed string is ║
║ returned. If the haystack doesn't contain the old string, the ║
║ original haystack is returned. If the old string is a null string, ║
║ then the original string is prefixed with the new string. ║
║ ║
║ new string to be used ►──────┐ ┌──────◄ limit of # changes (times).║
║ original string (haystack) ►────┐ │ │ [default: ≈ one billion] ║
║ old string to be replaced ►──┐ │ │ │ ┌────◄ begin at this occurrence # ║
║ {O, H, and N can be null.} │ │ │ │ │ ┌──◄ start position (default=1) ║
╚═╦═════════════════════════════╗ │ │ │ │ │ │ ╔═══════════════════════════╦═╝
╚═════════════════════════════╝ │ │ │ │ │ │ ╚═══════════════════════════╝
↓ ↓ ↓ ↓ ↓ ↓ */
changestr: procedure; parse arg o,h,n,t,b,p, ,$ f /* ◄────────────────────┐*/
/*T, B, P are optional ►─┘*/
t=word(t 999999999, 1) /*maybe use the default? */
b=word(b 1 , 1) /* " " " " */
p=word(p 1 , 1) /* " " " " */
if arg() < 3 then signal syntax /*not enough arguments. */
if arg() > 6 then signal syntax /*too many arguments. */
if \datatype(t, 'W') then signal syntax /*4th arg not an integer. */
if \datatype(b, 'W') then signal syntax /*5th " " " " */
if \datatype(p, 'W') then signal syntax /*6th " " " " */
if t<0 then signal syntax /*4th " " non-negative.*/
if b<1 then signal syntax /*5th " " positive. */
if p<1 then signal syntax /*6th " " " */
L=length(o) /*length of OLD string. */
if L==0 & t\=0 then return n || h /*changing a [null] char? */
/* [↓] check for position*/
if p\=1 then do /*P¬=1? Then ajust F & H.*/
f=left(h, min(p-1, length(h))) /*keep first part intact. */
h=substr(h, p) /*only use this part of H.*/
end /*now, proceed as usual. */
#=0 /*# of changed occurrences*/
do j=1 while # < t /*keep changing, T times. */
parse var h y (o) _ +(L) h /*parse the haystack ··· */
if _=='' then return f || $ || y /*no more left, return. */
$=$ || y /*append the residual txt.*/
/* [↓] check if too soon.*/
if j<b then $=$ || o /*append OLD if too soon. */
else do /*met the occurrence test.*/
$=$ || n /*append the NEW string.*/
#=#+1 /*bump occurrence number. */
end /* [↑] append new string.*/
end /*j*/ /*Note: most REXX ··· */
/* CHANGESTR BIFs only ···*/
return f || $ || h /* support three options. */</lang>
Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/223475...223488"