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

Re: [Clip] GetDocMatchAll

Expand Messages
  • Don - HtmlFixIt.com
    Okay, I don t understand regex at all ... in this context .... so this is just a guess, but I think you are excluding the ending return. Isn t that what ^
    Message 1 of 19 , Dec 6, 2008
    • 0 Attachment
      Okay, I don't understand regex at all ... in this context .... so this
      is just a guess, but I think you are excluding the ending return. Isn't
      that what ^ means? Exclude that? So this is meant to work line by line.
      You need a delimiter to create the array. The return is in fact the
      delimiter, therefore there is no delimiter. That is my guess. Leave
      off the last exclude line.

      ebbtidalflats wrote:
      > Hi Y'all,
      >
      > Can anyone suggest a way to use ^$GetDocMatchAll to match lines that
      > do _NOT_ contain a target word?
      >
      > I've tried various combinations of assertions, but without success.
      > Either the function returns ALL lines in a document, including the
      > ones containing the unwanted target, or it returns NOTHING.
      >
      > Here is the basis of what I'm testing (TARGET is the unwanted word):
      >
      > ^!SetListDelimiter ^%nl%
      > ^!SetArray %keepers%=^$GetDocMatchAll("^[^\r\n]*(?!TARGET)[^\r\n]*")$
      > ^!Select ALL
      > ^!InsertText ^%keepers%
      >
      > By the way, stripping lines that do not contain the target with:
      >
      > ^!Set %keepers%=^$GetDocMatchAll("^[^\r\n]*?^%target%[^\r\n]*?$")$
      >
      > works fine.
      >
      >
      > Go ahead, point out any stupid mistakes I'm making!
      >
      >
      >
      > Thanks,
      >
      >
      > Eb
      >
      >
      > ------------------------------------
      >
      > Fookes Software: http://www.fookes.com/
      > NoteTab website: http://www.notetab.com/
      > NoteTab Discussion Lists: http://www.notetab.com/groups.php
      >
      > ***
      > Yahoo! Groups Links
      >
      >
      >
      >
    • Sheri
      You probably need the latest NoteTab release for this: ^!Toolbar New Document Some Target Bla Subject Bla Bla Target Bla Bla Interesting ^!Jump Doc_End ;begin
      Message 2 of 19 , Dec 6, 2008
      • 0 Attachment
        You probably need the latest NoteTab release for this:

        ^!Toolbar New Document
        Some Target Bla
        Subject
        Bla Bla Target Bla Bla
        Interesting
        ^!Jump Doc_End
        ;begin long line
        ^!InsertSelect "^$GetDocListAll("(?i)(^.*\bTarget\b.*)|(^.+)";"$2\r\n")$"
        ;end long line
        ^!If ^$GetSelSize$=0 Next Else Skip_2
        ^!Set %result%=""
        ^!Goto Quit
        ^!Set %result%=^$GetDocReplaceAll("^\R+";"")$
        ^!InsertText ^%Empty%
        :Quit
        ^!Select All
        ^!Continue Replace Content with Result Shown Below?^%NL%^%result%
        ^%result%
        ;end of clip
      • ebbtidalflats
        Verrry Interrrestingg, Thanks Sheri. Your test lines work as desired. But, (Eric, are you lurking?) the code does not work when I remove the New Document
        Message 3 of 19 , Dec 6, 2008
        • 0 Attachment
          Verrry Interrrestingg,

          Thanks Sheri. Your test lines work as desired.

          But,

          (Eric, are you lurking?) the code does not work when I
          remove the New Document command and the test text, then
          run it on an open document.

          It still jumps to the end of the doc, and runs the same
          from then on. And the clip removes 65 lines from the
          document. But only 24 lines contained the target word,
          some of which targets were NOT removed!


          Plus, there is a BONUS BUG? ;-)


          The Confirm promt is larger than the screen, leaving the user to guess
          what the options are. ESC and ENTER work, but what about a newbie to
          NoteTab, when the bottom line is somewhere down-under?

          Multiline prompts have their uses, and I could fix the prompt size.
          But I would expect a well-behaved application to create windows with
          _accessible_ controls.


          I see the code working, when I single-step. But I do not understand
          what is happening.

          --- In ntb-clips@yahoogroups.com, "Sheri" <silvermoonwoman@...> wrote:
          >
          > ;begin long line
          > ^!InsertSelect
          "^$GetDocListAll("(?i)(^.*\bTarget\b.*)|(^.+)";"$2\r\n")$"
          > ;end long line

          What is the purpose of "|(^.+)"?
          What is the purpose of "$2\r\n"?
          I do not understand how the next line sets the desired "keeper" lines.


          > ^!Set %result%=^$GetDocReplaceAll("^\R+";"")$

          On first blush this looks like you'r just stripping empty lines.



          Regards,



          Eb
        • ebbtidalflats
          Thanks for the suggestion, Don. ... Isn t ... line. Yes, more or less. But I know I m getting delimited data. When I use only the lookahead assertion, It
          Message 4 of 19 , Dec 6, 2008
          • 0 Attachment
            Thanks for the suggestion, Don.

            --- In ntb-clips@yahoogroups.com, "Don - HtmlFixIt.com" <don@...> wrote:
            >
            > Okay, I don't understand regex at all ... in this context .... so this
            > is just a guess, but I think you are excluding the ending return.
            Isn't
            > that what ^ means? Exclude that? So this is meant to work line by
            line.


            Yes, more or less. But I know I'm getting delimited data. When I use
            only the lookahead assertion, It returns ALL lines, delimited!


            But when I try to integrate the lookbehind assertion, the function
            matches NOTHING.



            Eb
          • Flo
            ... Eb, Sheri, and all, This is an another instructive solution presented by Sheri! Regarding ... I would say: The RegEx matches either a line that contains
            Message 5 of 19 , Dec 6, 2008
            • 0 Attachment
              --- In ntb-clips@yahoogroups.com, "ebbtidalflats" <ebbtidalflats@...>
              wrote:
              >
              > Verrry Interrrestingg,
              >
              > Thanks Sheri. Your test lines work as desired.
              > I see the code working, when I single-step. But I do not understand
              > what is happening...

              Eb, Sheri, and all,

              This is an another instructive solution presented by Sheri! Regarding
              Eb's questions, I would like to try the following reply:

              >>"^$GetDocListAll("(?i)(^.*\bTarget\b.*)|(^.+)";"$2\r\n")$"
              >
              > What is the purpose of "|(^.+)"?
              > What is the purpose of "$2\r\n"?

              I would say: The RegEx matches either a line that
              contains "Target" OR it matches any line. If "Target" is found, the
              RegEx Machine immediately stops the search and doesn't care for the
              rest. It replaces the match with $2 and a CRNL. Since the search has
              been stopped, $2 is empty, and the line is replaced with a CRNL only
              (that's why it outputs empty lines in this case). If "Target" isn't
              found, the whole line is captured with $2 (those are the lines you
              want to select since they don't contain "Target").

              So, choosing Sheri's four lines, the function returns...

              [empty][CRNL]
              Subject[CRNL]
              [empty][CRNL]
              Interesting[CRNL]

              This is inserted at the Doc_End and selected.

              Next,...

              ^!Set %result%=^$GetDocReplaceAll("^\R+";"")$

              assigns the selected text to %result%, that is: the hits only,
              removing those empty lines that were produced by ^$GetDocListAll$.

              Finally, the whole text is selected and replaced with the contents of
              %result%, that is: the two matching lines only (if we don't cancel
              the job). I get into trouble with...

              ^!InsertText ^%Empty%

              It removes the hits, but - in the end - those are removed anyway.
              Maybe its useful to see these hits in case we cancel the replacing of
              the whole text with the hits?

              *** I hope this interpretation will survive Sheri's critical eye ;-)
              ***

              Eb, in case you insist on ^$GetDocMatchAll$, I would like to present
              to you another version based on Sheri's concept...


              ^!SetClipboard ^$GetDocMatchAll("(^.*TARGET.*$)|(^.+$)";2)$
              ^!SetClipboard ^$StrReplace(";";"^P";^$GetClipboard$;0;0)$
              ^!Toolbar Paste New
              ^!Replace "^\r\n" >> "" AWRS


              Want some more? What about this...


              ^!SetArray %Lines%=^$GetDocMatchAll(^.+$)$
              ^!Set %Count%=1
              :Loop
              ^!IfMatch "^.*TARGET.*$" "^%Lines^%Count%%" Skip
              ^!Append %Select%=^%Lines^%Count%%^%NL%
              ^!Inc %Count%
              ^!If ^%Count% = ^%Lines0% Out
              ^!Goto Loop
              :Out
              ^!Toolbar New Document
              ^!InsertText ^%Select%
              ^!ClearVariable %Select%


              Eb, maybe it's interesting to understand why your first idea...

              ^$GetDocMatchAll("^[^\r\n]*(?!TARGET)[^\r\n]*")$

              didn't work. I think combining a Negative Lookahead Assertion
              with "[^\r\n]*" can't work.

              The RegEx says: "Find a position from where you don't see "TARGET"
              when looking ahead. This position must be preceded or not preceded or
              followed or not followed by anything that is no CRNL".

              That means: This RegEx is always true. That's why your concept
              selects all lines without excluding lines which contain "TARGET".

              I think in a more conventional way we just would remove lines
              containing "TARGET" in order to get lines NOT containing that word.
              This still works with "good old" ^!Replace...

              ^!Replace "^.*TARGET.*(\r\n|\Z)" >> "" AWRS

              This is my homework for today...

              Flo :-P

              Note: Never post to this forum unlesse you are prepared to make a
              fool of yourself!
               
            • Sheri
              ... You would need to present your doc and clip for help explaining that. Two things come to mind. First, in the pattern I used: (?i)(^.* bTarget b.*)|(^.+)
              Message 6 of 19 , Dec 6, 2008
              • 0 Attachment
                --- In ntb-clips@yahoogroups.com, "ebbtidalflats" <ebbtidalflats@...>
                wrote:

                > the code does not work when I
                > remove the New Document command and the test text, then
                > run it on an open document.
                >
                > It still jumps to the end of the doc, and runs the same
                > from then on. And the clip removes 65 lines from the
                > document. But only 24 lines contained the target word,
                > some of which targets were NOT removed!

                You would need to present your doc and clip for help explaining that.
                Two things come to mind. First, in the pattern I used:

                (?i)(^.*\bTarget\b.*)|(^.+)

                the \b's require the target text to be whole words, e.g., "targets",
                "targeting" and "targeted" are not being in/excluded.

                Second, if you change the target text, you need to make sure any
                metacharacters it contains are escaped. You can't for example use a
                variable that might contain metacharacters like "^" without escaping
                them, like "\^".

                Flo has given a very good explanation of what the pattern does.
                Regular expressions search for text that affirmatively matches a
                pattern, not one that doesn't. Even when you use a negative assertion,
                you are actually searching for something that follows from a given
                position.

                Regular expressions always work from left to right. Both of the
                subpatterns match whole lines that are not empty lines. If a line
                fails to match the first subpattern (because it doesn't contain
                "target"), it must match the second subpattern because that subpattern
                matches anything (except linebreaks). The vertical bar says "or"
                between the subpatterns. But if it matches the first subpattern, it
                doesn't try the second. In the format string, we ask only for the
                second subpattern, aka $2 in GetDocListAll or just 2 in GetDocMatchAll.

                There was a long standing bug until the latest NoteTab version that
                prevented this type of pattern from working properly in
                GetDocMatchall. Cheers to Eric that its fixed now. :)

                Regards,
                Sheri
              • Sheri
                Hi Flo, ... That is probably the most direct approach. If for some reason we wanted the result in a variable instead of the document we could use the new
                Message 7 of 19 , Dec 7, 2008
                • 0 Attachment
                  Hi Flo,

                  > I think in a more conventional way we just would remove lines
                  > containing "TARGET" in order to get lines NOT containing that word.
                  > This still works with "good old" ^!Replace...
                  >
                  > ^!Replace "^.*TARGET.*(\r\n|\Z)" >> "" AWRS

                  That is probably the most direct approach. If for some reason we
                  wanted the result in a variable instead of the document we could use
                  the new ^$GetDocReplaceall$ function instead. But I think you meant to
                  use \z instead of \Z... :D

                  Also my list pattern could have been improved resource-wise by not
                  capturing substring #1 (since it wasn't needed), e.g.,

                  "(?i)(?:^.*\bTarget\b.*)|(^.+)";"$1\r\n"

                  >
                  > This is my homework for today...

                  A+ :D

                  Regards,
                  Sheri
                • ebbtidalflats
                  Hi Flo, Sheri, That s a lot to digest, and it will take me awhile. I may not get a chance to try your suggestions until this weekend, thanks very much for your
                  Message 8 of 19 , Dec 8, 2008
                  • 0 Attachment
                    Hi Flo, Sheri,


                    That's a lot to digest, and it will take me awhile.
                    I may not get a chance to try your suggestions until
                    this weekend, thanks very much for your tips.

                    The document I'm testing has 525 lines. A bit much to
                    append. But it's all text, whole words, actually a
                    bunch of random SQL statements, which I searched for
                    "SELECT" and NOT "SELECT".



                    Regards,


                    Eb

                    --- In ntb-clips@yahoogroups.com, "Sheri" <silvermoonwoman@...> wrote:
                    >
                    > > ...

                    > You would need to present your doc and clip for help explaining that.
                    > Two things come to mind. First, in the pattern I used:
                    >
                    > (?i)(^.*\bTarget\b.*)|(^.+)
                    >
                    > the \b's require the target text to be whole words, e.g., "targets",
                    > "targeting" and "targeted" are not being in/excluded.
                    >
                    > Second, if you change the target text, you need to make sure any
                    > metacharacters it contains are escaped. You can't for example use a
                    > variable that might contain metacharacters like "^" without escaping
                    > them, like "\^".
                    >
                    > Flo has given a very good explanation of what the pattern does.
                    > Regular expressions search for text that affirmatively matches a
                    > pattern, not one that doesn't. Even when you use a negative assertion,
                    > you are actually searching for something that follows from a given
                    > position.
                    >
                    > Regular expressions always work from left to right. Both of the
                    > subpatterns match whole lines that are not empty lines. If a line
                    > fails to match the first subpattern (because it doesn't contain
                    > "target"), it must match the second subpattern because that subpattern
                    > matches anything (except linebreaks). The vertical bar says "or"
                    > between the subpatterns. But if it matches the first subpattern, it
                    > doesn't try the second. In the format string, we ask only for the
                    > second subpattern, aka $2 in GetDocListAll or just 2 in GetDocMatchAll.
                    >
                  • ebbtidalflats
                    Sheri, Flo, Thanks very much for your help and explanations. It turns out that there were two reasons Sheri s clip didn t work on MY document: 1. I screwed up
                    Message 9 of 19 , Dec 11, 2008
                    • 0 Attachment
                      Sheri, Flo,

                      Thanks very much for your help and explanations.

                      It turns out that there were two reasons Sheri's clip didn't work
                      on MY document:

                      1. I screwed up
                      -- didn't replace "target" with the real keyword D=8.

                      This resulted in NO lines being removed by THIS test,
                      but see below

                      2. The code did strip blank lines, intended to remove
                      those created by the replace algorithm.

                      There happened to be 25 original blank lines
                      and 24 keywords in the doc. Coincident!
                      25 lines removed, verifying code faked out.

                      Result: Wild Goose Chase.

                      When I finally pinned this down, I moved the EoLs into the search
                      pattern to handle them in the same step. The working part is now down
                      to 3 lines:

                      ;Sheri's fix, modified to single step
                      ;long line ---
                      ^!Set
                      %keepers%="^$GetDocReplaceAll("(?i)(^.*\bSELECT\b.*\r\n)|(^.+\r\n)";"$2")$"
                      ;end long line ---
                      ^!Select All
                      ^%keepers%
                      ;clip end ---


                      As long as blocks of text are organized in single lines, the algorithm
                      can remove sentences (lines) containing keywords.
                      It's complement removes sentences NOT containing the keyword.



                      Regards,


                      Eb
                    • Sheri
                      ... %keepers%= ^$GetDocReplaceAll( (?i)(^.* bSELECT b.* r n)|(^.+ r n) ; $2 )$ ... Hi Eb, It s not necessary to use the alternation and substrings if using
                      Message 10 of 19 , Dec 11, 2008
                      • 0 Attachment
                        --- In ntb-clips@yahoogroups.com, "ebbtidalflats" <ebbtidalflats@...>
                        wrote:
                        >
                        > Sheri, Flo,
                        >
                        > Thanks very much for your help and explanations.
                        >
                        > It turns out that there were two reasons Sheri's clip didn't work
                        > on MY document:
                        >
                        > 1. I screwed up
                        > -- didn't replace "target" with the real keyword D=8.
                        >
                        > This resulted in NO lines being removed by THIS test,
                        > but see below
                        >
                        > 2. The code did strip blank lines, intended to remove
                        > those created by the replace algorithm.
                        >
                        > There happened to be 25 original blank lines
                        > and 24 keywords in the doc. Coincident!
                        > 25 lines removed, verifying code faked out.
                        >
                        > Result: Wild Goose Chase.
                        >
                        > When I finally pinned this down, I moved the EoLs into the search
                        > pattern to handle them in the same step. The working part is now down
                        > to 3 lines:
                        >
                        > ;Sheri's fix, modified to single step
                        > ;long line ---
                        > ^!Set
                        >
                        %keepers%="^$GetDocReplaceAll("(?i)(^.*\bSELECT\b.*\r\n)|(^.+\r\n)";"$2")$"
                        > ;end long line ---
                        > ^!Select All
                        > ^%keepers%
                        > ;clip end ---
                        >
                        >
                        > As long as blocks of text are organized in single lines, the
                        > algorithm can remove sentences (lines) containing keywords. It's
                        > complement removes sentences NOT containing the keyword.

                        Hi Eb,

                        It's not necessary to use the alternation and substrings if using
                        ^$GetDocReplaceAll$.

                        You would just replace the matching lines with an empty string, just
                        like in regex ^!Replace.

                        Main difference is, no special switches. If text is selected it
                        applies only in the selection. Otherwise it applies to the whole
                        document. Other difference is the result isn't pasted into the
                        document window (unless you choose to paste it).

                        e.g.,

                        ^!Set %keepers%="^$GetDocReplaceAll("(?i)(^.*\bSELECT\b.*\r\n)";"")$"

                        Regards,
                        Sheri
                      • ebbtidalflats
                        ... Thanks Sheri, I _LIKE_ shorter code. Eb
                        Message 11 of 19 , Dec 11, 2008
                        • 0 Attachment
                          --- In ntb-clips@yahoogroups.com, "Sheri" <silvermoonwoman@...> wrote:
                          >
                          > --- In ntb-clips@yahoogroups.com, "ebbtidalflats" <ebbtidalflats@>
                          > wrote:
                          > >
                          > It's not necessary to use the alternation and substrings if using
                          > ^$GetDocReplaceAll$.
                          >
                          > You would just replace the matching lines with an empty string, just
                          > like in regex ^!Replace.
                          >
                          > Main difference is, no special switches. If text is selected it
                          > applies only in the selection. Otherwise it applies to the whole
                          > document. Other difference is the result isn't pasted into the
                          > document window (unless you choose to paste it).
                          >
                          > e.g.,
                          >
                          > ^!Set %keepers%="^$GetDocReplaceAll("(?i)(^.*\bSELECT\b.*\r\n)";"")$"
                          >


                          Thanks Sheri,

                          I _LIKE_ shorter code.

                          Eb
                        • hsavage
                          My regex education is lacking and I would appreciate assistance from our regex stars if they have time. I m trying to refine a browser selection clip using,
                          Message 12 of 19 , Dec 12, 2008
                          • 0 Attachment
                            My regex education is lacking and I would appreciate assistance from our
                            regex stars if they have time.

                            I'm trying to refine a browser selection clip using,
                            ^!Set %browser%=^$GetDocMatchaLL("^\[.+\]")$
                            to collect the name headings within the browsers.dat file.

                            The line above works fine but requires 2 ^$StrReplace( lines to get rid
                            of the brackets. Is there a regex answer that will find the bracketed
                            titles and return only the text between them using a modified example of
                            the line above.

                            Help is appreciated.

                            ·············································
                            ºvº SL_day# 347 - created 2008.12.12_15.04.47

                            World's Shortest Books
                            • Different Ways To Spell Bob

                            € hrs € hsavage € pobox € com
                          • Flo
                            ... Harvey, Try... ^!Set %browser%=^$GetDocMatchAll( ^ [ K[^]]+ )$ ^!Info ^%browser% In my tests, the closing bracket ] needs not to be escaped inside the
                            Message 13 of 19 , Dec 12, 2008
                            • 0 Attachment
                              --- In ntb-clips@yahoogroups.com, hsavage <hsavage@...> wrote:
                              >
                              > I'm trying to refine a browser selection clip using,
                              > ^!Set %browser%=^$GetDocMatchaLL("^\[.+\]")$
                              > to collect the name headings within the browsers.dat file.
                              > The line above works fine but requires 2 ^$StrReplace( lines to get
                              > rid of the brackets. Is there a regex answer that will find the
                              > bracketed titles and return only the text between them...

                              Harvey,

                              Try...

                              ^!Set %browser%=^$GetDocMatchAll("^\[\K[^]]+")$
                              ^!Info ^%browser%

                              In my tests, the closing bracket "]" needs not to be escaped inside
                              the Character Class. If you have any problems with that, try [^\]] or
                              [^\x5D].

                              Regards,
                              Flo
                               
                            • hsavage
                              ... Flo, Thanks very much, it appears to work exactly as I wanted and needed.
                              Message 14 of 19 , Dec 12, 2008
                              • 0 Attachment
                                Flo wrote:
                                > Harvey,
                                >
                                > Try...
                                >
                                > ^!Set %browser%=^$GetDocMatchAll("^\[\K[^]]+")$
                                > ^!Info ^%browser%
                                >
                                > In my tests, the closing bracket "]" needs not to be escaped inside
                                > the Character Class. If you have any problems with that, try [^\]] or
                                > [^\x5D].
                                >
                                > Regards,
                                > Flo

                                Flo,

                                Thanks very much, it appears to work exactly as I wanted and needed.

                                ·············································
                                ºvº SL_day# 347 - created 2008.12.12_17.48.10

                                World's Shortest Books
                                • Different Ways To Spell Bob

                                € hrs € hsavage € pobox € com
                              • Sheri
                                ... Hi Harvey, Flo, You consider adding r n [ into the character class e.g.: ^ [ K[^ r n [ ]]+ Although you wouldn t expect to encounter a situation where a
                                Message 15 of 19 , Dec 12, 2008
                                • 0 Attachment
                                  --- In ntb-clips@yahoogroups.com, "Flo" <flo.gehrke@...> wrote:
                                  >
                                  > --- In ntb-clips@yahoogroups.com, hsavage <hsavage@> wrote:
                                  > >
                                  > > I'm trying to refine a browser selection clip using,
                                  > > ^!Set %browser%=^$GetDocMatchaLL("^\[.+\]")$
                                  > > to collect the name headings within the browsers.dat file.
                                  > > The line above works fine but requires 2 ^$StrReplace( lines to get
                                  > > rid of the brackets. Is there a regex answer that will find the
                                  > > bracketed titles and return only the text between them...
                                  >
                                  > Harvey,
                                  >
                                  > Try...
                                  >
                                  > ^!Set %browser%=^$GetDocMatchAll("^\[\K[^]]+")$
                                  > ^!Info ^%browser%
                                  >
                                  > In my tests, the closing bracket "]" needs not to be escaped inside
                                  > the Character Class. If you have any problems with that, try [^\]] or
                                  > [^\x5D].
                                  >
                                  > Regards,
                                  > Flo
                                  >  
                                  >

                                  Hi Harvey, Flo,

                                  You consider adding \r\n\[ into the character class e.g.:

                                  "^\[\K[^\r\n\[\]]+"

                                  Although you wouldn't expect to encounter a situation where a closing
                                  bracket is missing and another opening bracket exists before a closing
                                  bracket, as is, the pattern would match across multiple lines right up
                                  to the next closing bracket.

                                  Regards,
                                  Sheri
                                • Sheri
                                  ... Oops my fingers got ahead of me, I meant to say You might want to consider ... :)
                                  Message 16 of 19 , Dec 12, 2008
                                  • 0 Attachment
                                    --- In ntb-clips@yahoogroups.com, "Sheri" <silvermoonwoman@...> wrote:
                                    > Hi Harvey, Flo,
                                    >
                                    > You consider adding \r\n\[ into the character class e.g.:

                                    Oops my fingers got ahead of me, I meant to say "You might want to
                                    consider ..." :)
                                  • hsavage
                                    ... Sheri, Flo, This works also, thanks again. For those interested this clip picks up the title of the browsers.dat entries, creates an Array from them and
                                    Message 17 of 19 , Dec 12, 2008
                                    • 0 Attachment
                                      Sheri wrote:
                                      >
                                      > Hi Harvey, Flo,
                                      >
                                      > You consider adding \r\n\[ into the character class e.g.:
                                      >
                                      > "^\[\K[^\r\n\[\]]+"
                                      >
                                      > Although you wouldn't expect to encounter a situation where a closing
                                      > bracket is missing and another opening bracket exists before a closing
                                      > bracket, as is, the pattern would match across multiple lines right up
                                      > to the next closing bracket.
                                      >
                                      > Regards,
                                      > Sheri

                                      Sheri, Flo,

                                      This works also, thanks again.

                                      For those interested this clip picks up the title of the browsers.dat
                                      entries, creates an Array from them and uses any number of them to view
                                      a html file.

                                      Users can choose 1 or greater number of browsers to view the file at the
                                      same time.

                                      I currently use 6 browsers and can view the file in all 6 by selecting
                                      all when the clip is run.

                                      Of course, the browsers.dat entries must work correctly for the clip to
                                      work.

                                      H="MultiBrowsers"
                                      ; • Modified-Updated~Created_2008.12.12
                                      ; • hrs ø hsavage·pobox·com_09:45:31p
                                      ; • Uses Browsers.Dat File Entries
                                      ; • create necessary entries in browsers.dat
                                      ; • to exclude browsers.dat entries from clip list
                                      ; • place semi-colon before name in browsers.dat
                                      ^!ClearVariables
                                      ^!SetScreenUpdate 0
                                      ^!Set %di%=C:\Documents and Settings\User\desktop\emdoc.emd
                                      ^!SetWizardWidth 100
                                      ^!SetWizardTitle "Select ALTERNATE Browsers"
                                      ^!SetWizardLabel "PICK A BROWSER,^%nL%MAY SELECT MORE THAN ONE -"
                                      ^!SetListDelimiter |
                                      ^!Open ^$GetAppPath$browsers.dat
                                      ^!Set %browser%=^$GetDocMatchAll("^\[\K[^\r\n\[\]]+")$
                                      ^!Close
                                      ^!SetDocIndex ^$GetDocIndex(^%di%)$
                                      ; • this first ^!Set %url% line is very long, may get wrapped in email.
                                      ^!Set %url%=^?{(T=O;H=11)VIEW THIS FILE, OR, SELECT
                                      ANOTHER==C:\Documents and Settings\User\desktop\emdoc.emd};
                                      %browser%="^?{(T=A;H=9)BROWSER TO VIEW FILE WITH==^%browser%}"
                                      ;
                                      ^!Set %url%=^$StrReplace("|";":";"^$FileToUrl(^%url%)$";0;0)$
                                      ^!SetArray %browser%=^%browser%
                                      ^!Set %count%=^%browser0%; %loop%=0
                                      :LOOP
                                      ^!Inc %loop%
                                      ^!Url ["^%browser^%loop%%"] "^%url%"
                                      ^!If ^%loop% < ^%count% LOOP

                                      ·············································
                                      ºvº SL_day# 347 - created 2008.12.12_23.14.23

                                      World's Shortest Books
                                      • Different Ways To Spell Bob

                                      € hrs € hsavage € pobox € com
                                    • hsavage
                                      Sheri, Flo, All, In the previous cut&paste some of the variables in the clip were expanded, hopefully this will take care of that problem. H= MultiBrowsers ;
                                      Message 18 of 19 , Dec 12, 2008
                                      • 0 Attachment
                                        Sheri, Flo, All,

                                        In the previous cut&paste some of the variables in the clip were
                                        expanded, hopefully this will take care of that problem.

                                        H="MultiBrowsers"
                                        ; • Modified-Updated~Created_2008.12.12
                                        ; • hrs ø hsavage·pobox·com_09:45:31p
                                        ; • Uses Browsers.Dat File Entries
                                        ; • create necessary entries in browsers.dat
                                        ; • to exclude browsers.dat entries from clip list
                                        ; • place semi-colon before name in browsers.dat
                                        ^!ClearVariables
                                        ^!SetScreenUpdate 0
                                        ^!Set %di%=^##
                                        ^!SetWizardWidth 100
                                        ^!SetWizardTitle "Select ALTERNATE Browsers"
                                        ^!SetWizardLabel "PICK A BROWSER,^%nL%MAY SELECT MORE THAN ONE -"
                                        ^!SetListDelimiter |
                                        ^!Open ^$GetAppPath$browsers.dat
                                        ^!Set %browser%=^$GetDocMatchAll("^\[\K[^\r\n\[\]]+")$
                                        ^!Close
                                        ^!SetDocIndex ^$GetDocIndex(^%di%)$
                                        ; • this first ^!Set %url% line is very long, may get wrapped in email.
                                        ^!Set %url%=^?{(T=O;H=11)VIEW THIS FILE, OR, SELECT ANOTHER==^##};
                                        %browser%="^?{(T=A;H=9)BROWSER TO VIEW FILE WITH==^%browser%}"
                                        ;
                                        ^!Set %url%=^$StrReplace("|";":";"^$FileToUrl(^%url%)$";0;0)$
                                        ^!SetArray %browser%=^%browser%
                                        ^!Set %count%=^%browser0%; %loop%=0
                                        :LOOP
                                        ^!Inc %loop%
                                        ^!Url ["^%browser^%loop%%"] "^%url%"
                                        ^!If ^%loop% < ^%count% LOOP

                                        --
                                        ·············································
                                        ºvº SL_day# 347 - created 2008.12.12_23.26.11

                                        World's Shortest Books
                                        • Different Ways To Spell Bob

                                        € hrs € hsavage € pobox € com
                                      Your message has been successfully submitted and would be delivered to recipients shortly.