CHANGESTR.REX: Difference between revisions

From Rosetta Code
Content added Content deleted
m (updated some comments in this version of the BIF. -- ~~~~)
m (moved a category to TOF.)
 
(11 intermediate revisions by 2 users not shown)
Line 1:
[[Category:REXX_library_routines]]
 
== the CHANGESTR function ==
This a RYO version of the REXX function &nbsp; '''changestr''' &nbsp; (<u>change</u> <u>str</u>ing).
 
It is included in some of the more modern Classic REXXes, but older versions of
<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).
 
 
 
This version of the &nbsp; '''changestr''' &nbsp; BIF has more functionality than the standard BIF.
 
<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 occurrence#.*/
/*──── start of change position. */
 
__TOC__
/*╔══════════════════════════ 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 ║
===the CHANGESTR (external) program source===
║ returned. If the haystack doesn't contain the old string, the ║
The following &nbsp; CHANGESTR &nbsp; program can be coded as is when the intention is to be an external routine (function).
║ original haystack is returned. If the old string is a null string, ║
<lang rexx>/*REXX program emulates the CHANGESTR BIF (built-in function) for older REXXes.*/
║ then the original string is prefixed with the new string. ║
/*──────────── This version has more functionality: limit the number of changes. */
║ ║
/*──────────── start of change occurrence#. */
║ new string to be used►──────────┐ ┌─────◄limit of # changes (times).║
/*──────────── start of change position. */
║ original string (haystack)►──────┐ │ │ [default: ≈ one billion]║
 
║ old string to be replaced►──┐ │ │ │ ┌────◄begin at this occurrence #║
/* ╔═══════════════════════════ CHANGESTR function ════════════════════════╗
║ {O, H, and N can be null.} │ │ │ │ │ ┌──◄start position (default=1)║
╔═╩═══════════════════════════════════════════════════════════════════════╩═╗
╚═╦════════════════════════════╗ │ │ │ │ │ │ ╔═════════════════════════╦═╝
║ 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 ║
↓ ↓ ↓ ↓ ↓ ↓ */
changestr: ║ returned. If the haystack parse argdoesn't contain o,h,n,t,b,pthe /*old T, Bstring, & Pthe are optional.*/ ║
║ original haystack is returned. If the old string is a null string, ║
$='' /*$: the returned string.*/
║ then the original string is prefixed with the new string. /*optional arguments ··· */║
t=word(t 999999999 ,║ 1) /*maybe use the default? */ ║
║ new string to be used ►──────┐ ┌──────◄ limit of # changes (times).║
b=word(b 1 , 1) /* " " " " */
║ original string (haystack) ►────┐ │ │ [default: ≈ one billion] ║
p=word(p 1 , 1) /* " " " " */
║ old string to be replaced ►──┐ │ │ │ ┌────◄ begin at this occurrence # ║
if arg() < 3 then signal syntax /*not enough arguments. */
║ {O, H, and N can be null.} │ │ │ │ │ ┌──◄ start position (default=1) ║
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 /*5th arg " " " ↓ ↓ ↓ ↓ ↓ ↓ */
if t<0 then signal syntax /*4thparse arg not non-negative o,h,n,t,b,p, ,$ f /* ◄────────────────────┐*/
if b<1 then signal syntax /*5th argT, notB, positive.P are optional ►─┘*/
if p<1 t=word(t 999999999, 1) then signal syntax /*6th " " " /*maybe use the default? */
L b=lengthword(o) b 1 , 1) /*length of " " " " OLD string. */
if L==0 & t\ p=0word(p 1 , 1) then return n || h /*changing a null" " " " char? */
f='' if arg() < 3 then signal syntax /*firstnot partenough ofarguments. H if P>1. */
if p\=1 then do if arg() > 6 then signal syntax /*iftoo P ¬=many 1, adjustarguments. F & H.*/
if f=left\datatype(ht, min(p-1, length(h))'W') then signal syntax /*keep4th arg firstnot partan intactinteger. */
if h=substr\datatype(hb,p 'W') then signal syntax /*5th " " " /*only use this part" of H.*/
if \datatype(p, 'W') end then signal syntax /*6th " " " " /*now, proceed as usual. */
#=0 if t<0 then signal syntax /*4th " " /*# of changed occurrencesnon-negative.*/
do j= if b<1 while # < t then signal syntax /*keep5th changing, T" times " positive. */
parse var if hp<1 y (o) _ +(L) h then signal syntax /*parse6th " " " the haystack ··· */
if _= L=''length(o) then return f || $ || y /*nolength moreof left, OLD return. string. */
$=$ || y if L==0 & t\=0 then return n || h /*appendchanging a the[null] residualchar? txt.*/
if j<b then $=$ || o /*append OLD[↓] if toocheck soon.for position*/
if p\=1 then do else do /*metP¬=1? Then ajust theF occurrence& testH.*/
$=$ || n f=left(h, min(p-1, length(h))) /*appendkeep thefirst part NEWintact. string.*/
# h=#+1substr(h, p) /*bumponly use this part occurrenceof numberH.*/
end /*now, proceed as usual. */
end #=0 /*j*/ /*Note: most REXX ··· /*# of changed occurrences*/
do j=1 while # < t /*keep CHANGESTRchanging, BIFsT onlytimes. ···*/
return f || $ || h parse var h y (o) _ +(L) h /*parse supportthe threehaystack ··· options. */</lang>
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>

Latest revision as of 20:23, 15 October 2018


the CHANGESTR function

This a RYO version of the REXX function   changestr   (change string).

It is included in some of the more modern Classic REXXes, but older versions of
Classic REXX don't have this function as a   BIF   (Built-In-Function).


This version of the   changestr   BIF has more functionality than the standard BIF.



the CHANGESTR (external) program source

The following   CHANGESTR   program can be coded as is when the intention is to be an external routine (function). <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) ║
  ╚═╦═════════════════════════════╗ │ │ │ │ │ │ ╔═══════════════════════════╦═╝
    ╚═════════════════════════════╝ │ │ │ │ │ │ ╚═══════════════════════════╝
                                    ↓ ↓ ↓ ↓ ↓ ↓                                   */
                        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>

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   (by adding a   procedure   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/CHANGESTR.REX?oldid=223488"