Loading ...
Sorry, an error occurred while loading the content.

Would like better way to increment filename by one

Expand Messages
  • joy8388608
    I thought this would be easier than it was and can t shake the feeling that there is a better way than what I can come up with so I ask for creative ideas
    Message 1 of 13 , Dec 3, 2012
    • 0 Attachment
      I thought this would be easier than it was and can't shake the feeling that there is a better way than what I can come up with so I ask for creative ideas here.

      I wanted a subroutine to increment trailing digits of filename. This is useful for creating backups and sequential files.

      Parsing the filename itself is no problem (i.e., picking off the folder, drive, etc. to isolate the actual file name). What I want is to increment the trailing digits while leaving AT LEAST the same number of digits as examples below.

      bkup3->bkup4 bkup01->bkup02 bkup99->bkup100 bkup0098->bkup0099->bkup0100

      If no numeric trailing digits, append 01. bkup->bkup01

      This is all relatively simple except for the keeping (at least) the same number of digits since ^!Inc strips leading zeros and adding one to 0098 would give 99.

      I created the routine by isolating the trailing digits, adding one and padding the result to the proper length.

      Can anyone come up with an elegant way to convert bkup009 to bkup010 and bkup999 to bkup1000?

      (This would be a nice built-in function, eh?)

      Thanks,
      Joy
    • Don
      This was answered just yesterday Joy. Search the messages from yesterday.
      Message 2 of 13 , Dec 3, 2012
      • 0 Attachment
        This was answered just yesterday Joy. Search the messages from yesterday.
      • Axel Berger
        ... Don t know about elegant. You have isolated your 0098 or 999. Get its length and save. Increment. Get length of result and save max of that and the former
        Message 3 of 13 , Dec 3, 2012
        • 0 Attachment
          joy8388608 wrote:
          > Can anyone come up with an elegant way

          Don't know about elegant. You have isolated your 0098 or 999.
          Get its length and save.
          Increment.
          Get length of result and save max of that and the former saved value.
          Pad to resulting length.

          My own clips are living things. I often open one I wrote months ago to
          make some small change after having long forgotten what I did back then
          and why. Primitive, plodding code I can follow at a glance is then
          superior to very clever one-liners, so my solutions are rarely if ever
          elegant.

          Axel
        • Axel Berger
          ... Not quite. Padding as such was, and Joy said, he/she s got that. The new question was finding out to what length to pad. Axel
          Message 4 of 13 , Dec 3, 2012
          • 0 Attachment
            Don wrote:
            > This was answered just yesterday Joy.

            Not quite. Padding as such was, and Joy said, he/she's got that. The new
            question was finding out to what length to pad.

            Axel
          • Ian NTnerd
            I don t think this is elegant. (Brute force comes to mind). I could not find any RegEx in string handling that was useful for this and would eliminate the
            Message 5 of 13 , Dec 4, 2012
            • 0 Attachment
              I don't think this is elegant. (Brute force comes to mind). I could not
              find any RegEx in string handling that was useful for this and would
              eliminate the loop.

              This becomes a custom function that when passed the filename
              word0999999999 will return word1000000000. Ten digit limit set by
              ^%loopcount% but could be increased.

              H="_incfile"

              |Untitled

              |Untitled

              |Untitled

              |^!SetDebug Off
              ^!set %input%=^&
              ^!Set %Index%=0
              ^!Set %LoopCount%=10
              ^!IfCancel End
              :LoopStart
              ^!Inc %Index%
              ^!If ^%Index% > ^%LoopCount% EndLoop
              ^!if ^$IsNumber(^$StrCopyRight("^%input%";^%index%)$)$=0 endloop
              ^!set %zeros%=^%zeros%0
              ^!GoTo LoopStart
              :EndLoop
              ^!if ^%index%=1 nonumber else hasnumber
              :nonumber
              ^!set %numb%=1
              ^!set %return%=^%input%^%numb%
              ^!goto return
              :hasnumber
              ^!dec %index%
              ^!set %alpha%=^$StrDeleteRight("^%input%";^%index%)$
              ^!set %numb%=^$StrCopyRight("^%input%";^%index%)$
              ^!inc %numb%
              ^!set %return%=^%alpha%^$StrCopyRight("^%zeros%^%numb%";^%index%)$
              :return
              ^!result ^%return%
              ||||

              ||
              H="TestInc"
              ^$incfile(^?[File name to use with max 10 digit number=word0101010108])$

              Ian

              On 4/12/2012 2:28 PM, Axel Berger wrote:
              >
              > Don wrote:
              > > This was answered just yesterday Joy.
              >
              > Not quite. Padding as such was, and Joy said, he/she's got that. The new
              > question was finding out to what length to pad.
              >
              > Axel
              >
              >



              [Non-text portions of this message have been removed]
            • John Shotsky
              If I were doing it, I wouldn t start with leading zeros and then fight them. I d choose an actual number, such as 10000 as my zero and increment that.
              Message 6 of 13 , Dec 4, 2012
              • 0 Attachment
                If I were doing it, I wouldn't start with leading zeros and then fight them. I'd choose an actual number, such as 10000
                as my 'zero' and increment that.

                Regards,
                John
                RecipeTools Web Site: <http://recipetools.gotdns.com/> http://recipetools.gotdns.com/

                From: ntb-clips@yahoogroups.com [mailto:ntb-clips@yahoogroups.com] On Behalf Of joy8388608
                Sent: Monday, December 03, 2012 15:52
                To: ntb-Clips@yahoogroups.com
                Subject: [Clip] Would like better way to increment filename by one


                I thought this would be easier than it was and can't shake the feeling that there is a better way than what I can come
                up with so I ask for creative ideas here.

                I wanted a subroutine to increment trailing digits of filename. This is useful for creating backups and sequential
                files.

                Parsing the filename itself is no problem (i.e., picking off the folder, drive, etc. to isolate the actual file name).
                What I want is to increment the trailing digits while leaving AT LEAST the same number of digits as examples below.

                bkup3->bkup4 bkup01->bkup02 bkup99->bkup100 bkup0098->bkup0099->bkup0100

                If no numeric trailing digits, append 01. bkup->bkup01

                This is all relatively simple except for the keeping (at least) the same number of digits since ^!Inc strips leading
                zeros and adding one to 0098 would give 99.

                I created the routine by isolating the trailing digits, adding one and padding the result to the proper length.

                Can anyone come up with an elegant way to convert bkup009 to bkup010 and bkup999 to bkup1000?

                (This would be a nice built-in function, eh?)

                Thanks,
                Joy



                [Non-text portions of this message have been removed]
              • flo.gehrke
                ... If I m not mistaken this should match your data and expected results: ; Long line start ^!SetArray
                Message 7 of 13 , Dec 4, 2012
                • 0 Attachment
                  --- In ntb-clips@yahoogroups.com, "joy8388608" <mycroftj@...> wrote:
                  >
                  > What I want is to increment the trailing digits while leaving
                  > AT LEAST the same number of digits as examples below.
                  >
                  > bkup3->bkup4 bkup01->bkup02 bkup99->bkup100 bkup0098->bkup0099->bkup0100
                  >
                  > If no numeric trailing digits, append 01. bkup->bkup01
                  > (...)
                  > Can anyone come up with an elegant way to convert bkup009 to bkup010 and bkup999 to bkup1000?

                  If I'm not mistaken this should match your data and expected results:

                  ; Long line start
                  ^!SetArray %List%=bkup;bkup3;bkup9;bkup01;bkup98;bkup99;bkup0098;bkup0099;bkup0998;bkup0999;bkup1000;bkup9998
                  ; Long line end
                  ^!Set %i%=1
                  :Loop
                  ^!Set %FileName%=^%List^%i%%
                  ^!IfSame "bkup" "^%FileName%" Next Else Skip_2
                  ^!Set %Nr%=01
                  ^!Goto Insert
                  ^!Set %Nr%=^$StrReplace("[^\d]";"";"^%FileName%";RA)$
                  ^!Set %Size%=^$StrSize(^%Nr%)$
                  ^!IfMatch "bkup99|bkup9" "^%FileName%" ^!Inc %Size%
                  ^!Inc %Nr%
                  ^!Set %Nr%=^$StrCopyRight("000^%Nr%";^%Size%)$
                  :Insert
                  ^!InsertText Next backup for ^%FileName% is bkup^%Nr%^%NL%
                  ^!Inc %i%
                  ^!If ^%i% > ^%List0% End
                  ^!Goto Loop

                  I'll leave it open whether it's "elegant" or not... ;-)

                  Regards,
                  Flo
                • Eb
                  Joy, John s excellent suggestion eliminates a lot of code, to left-pad the version number. Separating the version number from the name makes isolating the
                  Message 8 of 13 , Dec 4, 2012
                  • 0 Attachment
                    Joy,

                    John's excellent suggestion eliminates a lot of code, to left-pad the version number. Separating the version number from the name makes isolating the number easier.

                    I leave it to you to generate the original filename. A couple of tips though:

                    Use something like the following to create a permanent default numbering system:

                    ^!Set %width%=^?{enter the width of your version numbers}
                    ^!IfFalse ^$IsNumber(^%width%)$ SKIP_-1
                    ^!SaveValue FileVer:Width=^%width%
                    ;
                    ^!Dec %width%
                    ^!Set %ver%=1^$StrFill("0";^%width%)$

                    Use an underscore between the filename and the version number, like "filename_1000.txt". This will let you extract the version number as an array element. See below.


                    Incrementing the file version of the current document,
                    like "c:\path\file_10000.txt":

                    H="IncDocVersion"
                    :UNTESTED
                    ;separate the filespec into 4 parts:
                    ; path + file + version + extension
                    ^!Set %path%=^$GetPath(^**)$
                    ^!Set %fname%=^$GetName(^**)$
                    ^!Set %ext%=^$GetExt(^**)$
                    ;
                    ^!SetListDelimiter _
                    ^!SetArray %cname%=^%fname%
                    ;Error trap for files w/o "_nnn"
                    ^!If ^%cname0%<2 NO_VERNUM
                    ;
                    ;Increment the version number
                    ^!Inc %cname2%
                    ;
                    :SAVE_NEW_NAME
                    ;Reassemble the name
                    ^!Save AS "^%path%^%cname%^%ext%"
                    ^!Goto END
                    :NO_VERNUM
                    ^!Set %width%=^$GetValue(Value FileVer:Width)$
                    ^!Dec %width%
                    ^!Set %ver%=1^$StrFill("0";^%width%)$
                    ^!SetArray %cname%=^%cname%_^%ver%
                    ^!Goto SAVE_NEW_NAME

                    If the underscore interferes with your naming scheme, use a different character, that is unique in the name, AND is a legal character for filenames.


                    Cheers,


                    Eb

                    --- In ntb-clips@yahoogroups.com, "John Shotsky" <jshotsky@...> wrote:
                    >
                    > If I were doing it, I wouldn't start with leading zeros and then fight them. I'd choose an actual number, such as 10000
                    > as my 'zero' and increment that.
                    > ...
                    > From: ntb-clips@yahoogroups.com [mailto:ntb-clips@yahoogroups.com] On Behalf Of joy8388608
                    >
                    > ... ask for creative ideas here.
                    >
                    > I wanted a subroutine to increment trailing digits of filename. This is useful for creating backups and sequential
                    > files.
                    ...

                    > bkup3->bkup4 bkup01->bkup02 bkup99->bkup100 bkup0098->bkup0099->bkup0100
                    >
                    > If no numeric trailing digits, append 01. bkup->bkup01
                    >
                    > This is all relatively simple except for the keeping (at least) the same number of digits since ^!Inc strips leading
                    > zeros and adding one to 0098 would give 99.
                    >
                    > I created the routine by isolating the trailing digits, adding one and padding the result to the proper length.
                    >
                    > Can anyone come up with an elegant way to convert bkup009 to bkup010 and bkup999 to bkup1000?
                    >
                    > (This would be a nice built-in function, eh?)
                    >
                    > Thanks,
                    > Joy
                    >
                    >
                    >
                    > [Non-text portions of this message have been removed]
                    >
                  • joy8388608
                    ... Very interesting thoughts from everyone and I m kind of happy that there have been no why didn t *I* think of that answers so far. To clarify some
                    Message 9 of 13 , Dec 4, 2012
                    • 0 Attachment
                      --- In ntb-clips@yahoogroups.com, "flo.gehrke" <flo.gehrke@...> wrote:
                      >
                      > --- In ntb-clips@yahoogroups.com, "joy8388608" <mycroftj@> wrote:
                      > >
                      > > What I want is to increment the trailing digits while leaving
                      > > AT LEAST the same number of digits as examples below.
                      > >
                      > > bkup3->bkup4 bkup01->bkup02 bkup99->bkup100 bkup0098->bkup0099->bkup0100
                      > >
                      > > If no numeric trailing digits, append 01. bkup->bkup01
                      > > (...)
                      > > Can anyone come up with an elegant way to convert bkup009 to bkup010 and bkup999 to bkup1000?
                      >
                      > If I'm not mistaken this should match your data and expected results:
                      >
                      > ; Long line start
                      > ^!SetArray %List%=bkup;bkup3;bkup9;bkup01;bkup98;bkup99;bkup0098;bkup0099;bkup0998;bkup0999;bkup1000;bkup9998
                      > ; Long line end
                      > ^!Set %i%=1
                      > :Loop
                      > ^!Set %FileName%=^%List^%i%%
                      > ^!IfSame "bkup" "^%FileName%" Next Else Skip_2
                      > ^!Set %Nr%=01
                      > ^!Goto Insert
                      > ^!Set %Nr%=^$StrReplace("[^\d]";"";"^%FileName%";RA)$
                      > ^!Set %Size%=^$StrSize(^%Nr%)$
                      > ^!IfMatch "bkup99|bkup9" "^%FileName%" ^!Inc %Size%
                      > ^!Inc %Nr%
                      > ^!Set %Nr%=^$StrCopyRight("000^%Nr%";^%Size%)$
                      > :Insert
                      > ^!InsertText Next backup for ^%FileName% is bkup^%Nr%^%NL%
                      > ^!Inc %i%
                      > ^!If ^%i% > ^%List0% End
                      > ^!Goto Loop
                      >
                      > I'll leave it open whether it's "elegant" or not... ;-)
                      >
                      > Regards,
                      > Flo
                      >


                      Very interesting thoughts from everyone and I'm kind of happy that there have been no "why didn't *I* think of that" answers so far.

                      To clarify some things...

                      "bkup" was just an example. I want a routine that works with any and all file names.
                      For this same reason, starting numbering with 10000 and using an underscore to make the number easier to find is not an option.

                      I do very much agree with Axel in that clear, plodding code that can be easily understood is usually better than shorter, "clever" code that is difficult to follow. That and lots of comments! Anyone who has had to modify other people's code know what I'm talking about.

                      Other languages have numeric formatting and special commands that would make this easy but NT does not. So, for now, I think what I have is the best I've come across unless someone comes up with an idea. My code is not available to me at this moment but I'd be happy to post what I have later if anyone has an interest. Just ask.

                      I'll be still thinking about this one.
                      Thanks!
                      Joy
                    • Ian NTnerd
                      ... Sorry my last post had junk in it. Let me know what you think. I d like to see what you have now. Ian H= _incfile ^!SetDebug Off ; Get the file name (no
                      Message 10 of 13 , Dec 4, 2012
                      • 0 Attachment
                        On 5/12/2012 6:46 AM, joy8388608 wrote:
                        >
                        >
                        > Very interesting thoughts from everyone and I'm kind of happy that
                        > there have been no "why didn't *I* think of that" answers so far.
                        >
                        > To clarify some things...
                        >
                        > "bkup" was just an example. I want a routine that works with any and
                        > all file names.
                        > For this same reason, starting numbering with 10000 and using an
                        > underscore to make the number easier to find is not an option.
                        >
                        > I do very much agree with Axel in that clear, plodding code that can
                        > be easily understood is usually better than shorter, "clever" code
                        > that is difficult to follow. That and lots of comments! Anyone who has
                        > had to modify other people's code know what I'm talking about.
                        >
                        > Other languages have numeric formatting and special commands that
                        > would make this easy but NT does not. So, for now, I think what I have
                        > is the best I've come across unless someone comes up with an idea. My
                        > code is not available to me at this moment but I'd be happy to post
                        > what I have later if anyone has an interest. Just ask.
                        >
                        > I'll be still thinking about this one.
                        > Thanks!
                        > Joy
                        >
                        >
                        Sorry my last post had junk in it. Let me know what you think. I'd like
                        to see what you have now.

                        Ian

                        H="_incfile"
                        ^!SetDebug Off
                        ; Get the file name (no path or extension)
                        ^!set %input%=^&
                        ; start loop from ClipHelp.clb
                        ^!Set %Index%=0
                        ^!Set %LoopCount%=10
                        ^!IfCancel End
                        :LoopStart
                        ^!Inc %Index%
                        ^!If ^%Index% > ^%LoopCount% EndLoop
                        ; test if the string that is ^%index% chars long is a number if not end loop
                        ^!if ^$IsNumber(^$StrCopyRight("^%input%";^%index%)$)$=0 endloop
                        ; create a string of zeros to be longer than needed
                        ^!set %zeros%=^%zeros%0
                        ; return to ClipHelp.clb closing section
                        ^!GoTo LoopStart
                        :EndLoop

                        ; test if the ^%index% is 1, if it is then there is no number at the
                        end. Do nonumber else do has number.
                        ^!if ^%index%=1 nonumber else hasnumber
                        :nonumber
                        ; if no number create the string to return
                        ^!set %return%=^%input%01
                        ^!goto return
                        :hasnumber
                        ; if number found, decrease the index to the correct figure.
                        ^!dec %index%
                        ; get the non number part of the string
                        ^!set %alpha%=^$StrDeleteRight("^%input%";^%index%)$
                        ; get the number part and increase it by one
                        ^!set %numb%=^$StrCopyRight("^%input%";^%index%)$
                        ^!inc %numb%
                        ; set the return value with alpha part and new number trimed to the
                        input length.
                        ; this will fail if your input string is 99 and it is increased to 100
                        ^!set %return%=^%alpha%^$StrCopyRight("^%zeros%^%numb%";^%index%)$
                        :return
                        ^!result ^%return%

                        H="TestInc"
                        ^$incfile(^?[Word to use=word0101010108])$



                        [Non-text portions of this message have been removed]
                      • joy8388608
                        ... Sure. Sorry for the delay. I was away. I usually use farclips instead of functions since I can call them from any library. The calling clip sets a variable
                        Message 11 of 13 , Dec 6, 2012
                        • 0 Attachment
                          --- In ntb-clips@yahoogroups.com, Ian NTnerd <indiamcq@...> wrote:
                          >
                          > On 5/12/2012 6:46 AM, joy8388608 wrote:
                          > >
                          > >
                          > > Very interesting thoughts from everyone and I'm kind of happy that
                          > > there have been no "why didn't *I* think of that" answers so far.
                          > >
                          > > To clarify some things...
                          > >
                          > > "bkup" was just an example. I want a routine that works with any and
                          > > all file names.
                          > > For this same reason, starting numbering with 10000 and using an
                          > > underscore to make the number easier to find is not an option.
                          > >
                          > > I do very much agree with Axel in that clear, plodding code that can
                          > > be easily understood is usually better than shorter, "clever" code
                          > > that is difficult to follow. That and lots of comments! Anyone who has
                          > > had to modify other people's code know what I'm talking about.
                          > >
                          > > Other languages have numeric formatting and special commands that
                          > > would make this easy but NT does not. So, for now, I think what I have
                          > > is the best I've come across unless someone comes up with an idea. My
                          > > code is not available to me at this moment but I'd be happy to post
                          > > what I have later if anyone has an interest. Just ask.
                          > >
                          > > I'll be still thinking about this one.
                          > > Thanks!
                          > > Joy
                          > >
                          > >
                          > Sorry my last post had junk in it. Let me know what you think. I'd like
                          > to see what you have now.
                          >
                          > Ian


                          Sure. Sorry for the delay. I was away.

                          I usually use farclips instead of functions since I can call them from any library. The calling clip sets a variable and the result(s) are passed back in another variable.

                          Now that everyone sees what I came up with, I'm sure someone will improve upon it!

                          Joy

                          Increment_FileName
                          ; Increment number at end of passed file name
                          ; IN: %Incr_FN_I% is filename with optional drive and path and extension
                          ;
                          ; OUT: %Incr_FN_O% is new filename with added or incremented number
                          ;
                          ; Increments trailing digits of filename.
                          ; If no numeric trailing digits, append 01.
                          ; Incremented number is at least as long as original number.
                          ; 3->4 01->02 99->100 0098->0099->0100

                          ; call with ^!FarClip "<LibraryName>:Increment_FileName"
                          ; Handles trailing numeric value up to 9223372036854775806

                          ; Get just the File Name without path or extension
                          ^!Set %INFN_JUSTFN%=^$GetName(^%Incr_FN_I%)$

                          ; Find start position of trailing digits
                          ^!Set %INFN_StartPos_Trailing_Digits%=^$StrPos("\d+$";"^%INFN_JUSTFN%";R)$

                          ^!If ^%INFN_StartPos_Trailing_Digits% = 0 NO_NUMBERS

                          ; Isolate the trailing numbers
                          ^!Set %INFN_TrailingValue%=^$StrCopy("^%INFN_JUSTFN%";^%INFN_StartPos_Trailing_Digits%;100)$

                          ; Find number of digits at the end of filename
                          ^!Set %INFN_Num_of_Orig_Digits%=^$StrSize("^%INFN_TrailingValue%")$

                          ; Remove trailing numeric chars from the filename
                          ^!Set %INFN_FN_WITHOUT_TrailingNums%=^$StrCopyLeft("^%INFN_JUSTFN%";^$Calc(^$StrSize("^%INFN_JUSTFN%")$ - ^%INFN_Num_of_Orig_Digits%)$)$

                          ; Add one to trailing number
                          ^!Inc %INFN_TrailingValue%

                          ; If size original GT size new, add correct number of preceding zeros
                          ; If same size or smaller, leave var empty
                          ^!Set %INFN_SizeDiff%=^$Calc(^%INFN_Num_of_Orig_Digits% - ^$StrSize("^%INFN_TrailingValue%")$)$

                          ^!If ^%INFN_SizeDiff% <= 0 SKIP_1
                          ^!Set %INFN_Zeros%=^$StrFill("0";^%INFN_SizeDiff%)$

                          ; Create just the filename with the formatted incremented number
                          ^!Set %INFN_NEWFN%=^%INFN_FN_WITHOUT_TrailingNums%^%INFN_Zeros%^%INFN_TrailingValue%

                          ; If they were given, put back the path and extention
                          ^!Set %Incr_FN_O%=^$GetPath(^%Incr_FN_I%)$^%INFN_NEWFN%^$GetExt(^%Incr_FN_I%)$
                          ^!Goto INFN_CLEAR

                          :NO_NUMBERS
                          ; No trailing digits found so just append 01
                          ^!Set %Incr_FN_O%=^$GetPath(^%Incr_FN_I%)$^%INFN_JUSTFN%01^$GetExt(^%Incr_FN_I%)$

                          :INFN_CLEAR
                          ^!ClearVariable %INFN_Zeros%
                          ^!ClearVariable %INFN_NEWFN%
                          ^!ClearVariable %INFN_JUSTFN%
                          ^!ClearVariable %INFN_SizeDiff%
                          ^!ClearVariable %INFN_TrailingValue%
                          ^!ClearVariable %INFN_Num_of_Orig_Digits%
                          ^!ClearVariable %INFN_StartPos_Trailing_Digits%
                          ^!ClearVariable %INFN_FN_WITHOUT_TrailingNums%
                        • Ian NTnerd
                          ... Joy Your clip gots rid of the Loop I used with this RegEx. So it is faster. ^!Set %INFN_StartPos_Trailing_Digits%=^$StrPos( d+$ ; ^%INFN_JUSTFN% ;R)$ I
                          Message 12 of 13 , Dec 6, 2012
                          • 0 Attachment
                            On 7/12/2012 3:58 AM, joy8388608 wrote:
                            > I usually use farclips instead of functions since I can call them from
                            > any library. The calling clip sets a variable and the result(s) are
                            > passed back in another variable.
                            Joy

                            Your clip gots rid of the Loop I used with this RegEx. So it is faster.
                            ^!Set %INFN_StartPos_Trailing_Digits%=^$StrPos("\d+$";"^%INFN_JUSTFN%";R)$

                            I like that.

                            You mentioned you use farclips rather than functions. I have sometimes
                            used a local function called farfunc, so I get the convenience of a
                            function (used inline), and the re-usability of a far clip. You have to
                            modify your far clips to give the result in the variable ^%outvalue%

                            ; FarFunc can call some functions in another clipbook
                            ; expected parameter: farlibrary:farclip;param1;param2;paramX

                            ; assign the input to a variable
                            ^!set %input%=^&

                            ; make an array of the input
                            ^!setlistdelimiter ;
                            ^!setarray %part%=^%input%

                            ; Get just the parameters by removing the farlibrary and the farclip part
                            ^!set %param%=^$StrReplace("^%part1%;";"";"^%input%";No;No)$

                            ; call the far clip
                            ^!farclip "^%part1%" ^%param%

                            ; return the result
                            ^!result ^%outvalue%

                            That may make your basic code look more elegant.

                            Ian
                          • Ian NTnerd
                            ... Combining your variables with the tip from another post on padding to a length, the above could be rewritten as ^!Set
                            Message 13 of 13 , Dec 6, 2012
                            • 0 Attachment
                              On 7/12/2012 3:58 AM, joy8388608 wrote:
                              > ; If size original GT size new, add correct number of preceding zeros
                              > ; If same size or smaller, leave var empty
                              > ^!Set %INFN_SizeDiff%=^$Calc(^%INFN_Num_of_Orig_Digits% -
                              > ^$StrSize("^%INFN_TrailingValue%")$)$
                              >
                              > ^!If ^%INFN_SizeDiff% <= 0 SKIP_1
                              > ^!Set %INFN_Zeros%=^$StrFill("0";^%INFN_SizeDiff%)$
                              >
                              > ; Create just the filename with the formatted incremented number
                              > ^!Set
                              > %INFN_NEWFN%=^%INFN_FN_WITHOUT_TrailingNums%^%INFN_Zeros%^%INFN_TrailingValue%
                              >
                              > ; If they were given, put back the path and extention
                              > ^!Set
                              > %Incr_FN_O%=^$GetPath(^%Incr_FN_I%)$^%INFN_NEWFN%^$GetExt(^%Incr_FN_I%)$
                              > ^!Goto INFN_CLEAR
                              Combining your variables with the tip from another post on padding to a
                              length, the above could be rewritten as

                              ^!Set
                              %Incr_FN_O%=^$GetPath(^%Incr_FN_I%)$^$StrCopyRight("00000000000000000000^%%INFN_TrailingValue%%";^%INFN_Num_of_Orig_Digits%)$^$GetExt(^%Incr_FN_I%)$
                              ^!Goto INFN_CLEAR

                              Ian
                            Your message has been successfully submitted and would be delivered to recipients shortly.