Re: regexec - chopping a large text string into chunks

[Scott Klement <rpg400-l@xxxxxxxxxxxxxxxx>]

Hi Aaron,

What is your pattern intended to do?  I know you want to split the line 
up every 40 characters, but...   why not use %subst() to do that?  I 
assume you want to do something more, like split it up on a whitespace 
boundary, right?  Can you explain a little more?

Also, I see you're using fixed-format RPG for the OCCUR op-code.  Are 
you aware that there's an %OCCUR BIF?  With that BIF, you don't need to 
switch to fixed format.

Also, I see you're manually null-terminating your strings, and then 
passing pointers to the API.  Are you aware of OPTIONS(*STRING) which 
automatically null-terminates strings, and obviates the need to use 
%ADDR() when calling the APIs?

Anyway...  if you can elaborate on what your pattern is supposed to do, 
I'd appreciate it.  Right now, I'm banging my head on the wall trying to 
figure it out :)

Aaron Bartell wrote:
> Hi all,
>
> I am trying to use regular expressions to take a long text string (from a
> browser text box) and "splice" it out to fit into multiple DB2 records which
> are 40 characters long each.  I have found articles by Scott Klement and Bob
> Cozzi and they have gotten me pretty far, but I seem to be getting odd
> results and am wondering if anybody can see where I might be wrong.
>
> Basically I have an all inclusive program (see below) that hard codes a long
> string.  Then I compile the regex and execute it.  Both of these steps are
> successful but when I loop through it with a FOR opcode I get weird results
> where the first entry of regmatch_t is as expected, but the second and the
> third aren't what I am expecting.  For the second I would expect a starting
> string offset different than the first, but it is not.  For their third
> iteration I get it matching up with a single character.
>
> Any glaring mistakes given my general need?
>
> Aaron Bartell
> http://mowyourlawn.com
>
>      H BNDDIR('QC2LE') DFTACTGRP(*NO)
>
>      D regex_t         DS                  Qualified  DIM(1) ALIGN
>      D  re_nsub                      10U 0
>      D  re_comp                        *   Inz(*NULL)
>      D  re_cflags                    10I 0
>      D  re_erroff                    10U 0
>      D  re_len                       10U 0
>      D  re_ucoll                     10I 0 Dim(2)
>      D  re_lsub                        *   Inz(*NULL)
>      D  lsub_ar                      10I 0 Dim(16)
>      D  esub_ar                      10I 0 Dim(16)
>      D  reserved1                      *   Inz(*NULL)
>      D  re_esub                        *   Inz(*NULL)
>      D  re_specchar                    *   Inz(*NULL)
>      D  re_phdl                        *   Inz(*NULL)
>      D  comp_spc                      1A   Dim(112)
>      D  re_map                        1A   Dim(256)
>      D  re_shift                      5I 0
>      D  re_dbcs                       5I 0
>
>      D regmatch_t      DS                  occurs(maxEntry)
> align               start offset
>      D  rm_so                        10I 0
>      D  rm_ss                         5I 0
>      D  rm_eo                        10I
> 0                                      end offset
>      D  rm_es                         5I 0
>
>      D regcomp         PR            10I 0 extproc('regcomp')
>      D   preg                          *   value
>      D   pattern                       *   value
>      D   cflags                      10I 0 value
>
>      D regexec         PR            10I 0 extproc('regexec')
>      D   preg                          *   value
>      D   string                        *   value
>      D   nmatch                      10U 0 value
>      d   pmatch                        *   value
>      D   eflags                      10I 0 value
>
>      D regerror        PR            10U 0 extproc('regerror')
>      D   errcode                     10I 0 value
>      D   preg                          *   value
>      D   errbuf                        *   value
>      D   errbuf_size                 10I 0 const
>
>      D regfree         PR                  extproc('regfree')
>      D   preg                          *   value
>
>      D REG_BASIC       C                   Const(X'00')
>      D REG_EXTENDED    C                   Const(X'01')
>      D REG_ICASE       C                   Const(X'02')
>      D REG_ICASEX      C                   Const(X'03')
>      D REG_NEWLINE     C                   Const(X'04')
>      D REG_NOSUB       C                   Const(X'08')
>      D REG_ALT_NL      C                   Const(X'10')
>
>
>      D maxEntry        c                   const(10)
>      D preg            S               *
>      D pmatch          S               *
>      D string          S            256A
>      D len             S             10I 0
>      D rc              S             10I 0
>      D nmatch          S             10U 0 INZ(maxEntry)
>      D buf             S            256A
>      D pattern         S             50A
>      D temp            s            100a   varying
>      D x               s             10i 0
>       /free
>
>        *inlr = *on;
>        string = 'This is a line of text 111111. T2his i2s al2so a2 lin2e' +
>          'will eventuallyrunoverats  string is longer than normal. Somwer' +
>          'some more text'+ x'0D25' + 'over at some point simple stri.'+
>          'This is the last sentence in the paragraph.' + x'00';
>        pattern = '(\S\S{40,}|.{1,40})(\s+|$)' + x'00';
>       /END-FREE
>      c     1             occur     regmatch_t
>       /FREE
>        preg = %addr(regex_t);
>        pmatch = %addr(regmatch_t);
>
>        // Compile RE
>        rc=regcomp(preg:%addr(pattern): REG_ICASEX);
>        if rc <> 0;
>          regerror(rc: preg: %addr(buf): %size(buf));
>          temp = 'comp() failed with: ' + %str(%addr(buf));
>        return;
>        endif;
>
>        // Execute RE
>        rc = regexec(preg: %addr(string): nmatch: pmatch: 0);
>        if rc <> 0;
>          regerror(rc: preg: %addr(buf): %size(buf));
>          regfree(preg);
>          temp = 'regexec() failed with: ' + %str(%addr(buf));
>          return;
>        endif;
>
>        for x = 1 to nmatch;
>       /end-free
>      c     x             occur     regmatch_t
>       /FREE
>        // Done processing if these are negative
>          if rm_eo = -1 or rm_so = -1;
>            leave;
>          endif;
>          len = rm_eo - rm_so;
>          rm_so = rm_so + 1;
>          temp = %subst(string: rm_so: len);
>        endfor;
>
>        regfree(preg);
>
>        return;
>       /END-FREE