Re: regexec - chopping a large text string into chunks

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