assume you got routine that takes long string/literal char* txt
as an input

i need to scan for some patterns in it like "..." in this exist
convenient is to check

for(char* c = text; c<txt+end; c++)
if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found

the problem is if it dont gets over a string and reads
two chars before its begining

what is the best and simplest way to do it correctly?

tnx

On 26/04/2022 16:35, fir wrote:
> assume you got routine that takes long string/literal char* txt
> as an input
>
> i need to scan for some patterns in it like "..." in this exist
> convenient is to check
>
> for(char* c = text; c<txt+end; c++)
> if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
>
> the problem is if it dont gets over a string and reads
> two chars before its begining
>
> what is the best and simplest way to do it correctly?
>
> tnx
>
Try using strstr function:

char *strstr(const char *s1, const char *s2);

<https://www.ibm.com/docs/en/i/7.4?topic=functions-strstr-locate-substring>

On 26/04/2022 16:35, fir wrote:
> assume you got routine that takes long string/literal char* txt
> as an input
>
> i need to scan for some patterns in it like "..." in this exist
> convenient is to check
>
> for(char* c = text; c<txt+end; c++)
> if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
>
> the problem is if it dont gets over a string and reads
> two chars before its begining
>
> what is the best and simplest way to do it correctly?
>
> tnx
>

What is wrong with: strstr(text, "...") ?

wtorek, 26 kwietnia 2022 o 19:00:08 UTC+2 Richard Harnden napisał(a):
> On 26/04/2022 16:35, fir wrote:
> > assume you got routine that takes long string/literal char* txt
> > as an input
> >
> > i need to scan for some patterns in it like "..." in this exist
> > convenient is to check
> >
> > for(char* c = text; c<txt+end; c++)
> > if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
> >
> > the problem is if it dont gets over a string and reads
> > two chars before its begining
> >
> > what is the best and simplest way to do it correctly?
> >
> > tnx
> >
> What is wrong with: strstr(text, "...") ?

i need genarally this loop to be preserved
for(char* c = text; c<txt+end; c++)
{
//acces *c here
}

becouse i do more things here in that loop besides this kind of scanning is more general pattaern which i encounter from time to time

if you curious for example this is a pattern of what i call splitter function which is very core function
in various text based programing i do (this splitter breaks input text onto say logical lines ready for
use for the rest of code)..for various things you could have various splitters but the basic one is like

chunks SplitOnLogLines4Furia(chunk text )
{

int current_chunk_number = 0;

static chunk* ram4chunks = NULL;
ram4chunks = (chunk*) realloc(ram4chunks, (current_chunk_number+1 )* sizeof(chunk) );
ram4chunks[current_chunk_number].beg = text.beg;

int parenthesis_count =0;
int inside_commentary =0;

for(char* c = text.beg; c <= text.end; c++ )
{
if(*c== '\"') quote_mark_count++;
if(*c== '/' && *(c-1)== '/') inside_commentary = 1;

int do_break;
do_break = 0;

if(!inside_commentary)
if(*c==0x0a ||*c==',')
if(quote_mark_count%2==0)
do_break=1;

if(inside_commentary)
if(*c==0x0a)
do_break=1;

if(do_break)
{
//do break
inside_commentary = 0;
quote_mark_count =0;

ram4chunks[current_chunk_number].end = c-1;

if(c+1<=text.end) // open next
{
current_chunk_number ++;
ram4chunks = (chunk*) realloc(ram4chunks, (current_chunk_number+1) * sizeof(chunk) );
ram4chunks[current_chunk_number].beg = c + 1;
}
}
}
ram4chunks[current_chunk_number].end = text.end; //finish last
//send output
chunks splited = {ram4chunks, ram4chunks + current_chunk_number} ;
return splited;

}

wtorek, 26 kwietnia 2022 o 19:14:06 UTC+2 fir napisał(a):
> wtorek, 26 kwietnia 2022 o 19:00:08 UTC+2 Richard Harnden napisał(a):
> > On 26/04/2022 16:35, fir wrote:
> > > assume you got routine that takes long string/literal char* txt
> > > as an input
> > >
> > > i need to scan for some patterns in it like "..." in this exist
> > > convenient is to check
> > >
> > > for(char* c = text; c<txt+end; c++)
> > > if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
> > >
> > > the problem is if it dont gets over a string and reads
> > > two chars before its begining
> > >
> > > what is the best and simplest way to do it correctly?
> > >
> > > tnx
> > >
> > What is wrong with: strstr(text, "...") ?
> i need genarally this loop to be preserved
> for(char* c = text; c<txt+end; c++)
> {
> //acces *c here
> }
>
> becouse i do more things here in that loop besides this kind of scanning is more general pattaern which i encounter from time to time
>
> if you curious for example this is a pattern of what i call splitter function which is very core function
> in various text based programing i do (this splitter breaks input text onto say logical lines ready for
> use for the rest of code)..for various things you could have various splitters but the basic one is like
>
> chunks SplitOnLogLines4Furia(chunk text )
> {
>
> int current_chunk_number = 0;
>
> static chunk* ram4chunks = NULL;
> ram4chunks = (chunk*) realloc(ram4chunks, (current_chunk_number+1 )* sizeof(chunk) );
> ram4chunks[current_chunk_number].beg = text.beg;
>
> int parenthesis_count =0;

shoud be int quote_mark_count = 0;

> int inside_commentary =0;
>
> for(char* c = text.beg; c <= text.end; c++ )
> {
> if(*c== '\"') quote_mark_count++;
> if(*c== '/' && *(c-1)== '/') inside_commentary = 1;
>
>
> int do_break;
> do_break = 0;
>
> if(!inside_commentary)
> if(*c==0x0a ||*c==',')
> if(quote_mark_count%2==0)
> do_break=1;
>
> if(inside_commentary)
> if(*c==0x0a)
> do_break=1;
>
> if(do_break)
> {
> //do break
> inside_commentary = 0;
> quote_mark_count =0;
>
> ram4chunks[current_chunk_number].end = c-1;
>
> if(c+1<=text.end) // open next
> {
> current_chunk_number ++;
> ram4chunks = (chunk*) realloc(ram4chunks, (current_chunk_number+1) * sizeof(chunk) );
> ram4chunks[current_chunk_number].beg = c + 1;
> }
> }
> }
> ram4chunks[current_chunk_number].end = text.end; //finish last
> //send output
> chunks splited = {ram4chunks, ram4chunks + current_chunk_number} ;
> return splited;
>
> }

wtorek, 26 kwietnia 2022 o 19:14:06 UTC+2 fir napisał(a):
>
> for(char* c = text.beg; c <= text.end; c++ )
> {
> if(*c== '\"') quote_mark_count++;
> if(*c== '/' && *(c-1)== '/') inside_commentary = 1;
>

probably suficient way here is

if(c-text.beg>=1) if(*c== '/' && *(c-1)== '/') inside_commentary = 1;

though this is probably runtime not optimal (and i may put megabyte long texts thru that too)

changing the loop header is strongly not welcome to me becouse i like the
clarity and generality of this loop (scan)

in this situation i would prefer the runtime slower form for my typical use, unles someone maybe see something better?

wtorek, 26 kwietnia 2022 o 19:32:23 UTC+2 fir napisał(a):
> wtorek, 26 kwietnia 2022 o 19:14:06 UTC+2 fir napisał(a):
> >
> > for(char* c = text.beg; c <= text.end; c++ )
> > {
> > if(*c== '\"') quote_mark_count++;
> > if(*c== '/' && *(c-1)== '/') inside_commentary = 1;
> >
> probably suficient way here is
>
> if(c-text.beg>=1) if(*c== '/' && *(c-1)== '/') inside_commentary = 1;
>
> though this is probably runtime not optimal (and i may put megabyte long texts thru that too)
>
> changing the loop header is strongly not welcome to me becouse i like the
> clarity and generality of this loop (scan)
>
> in this situation i would prefer the runtime slower form for my typical use, unles someone maybe see something better?
well that probably is better?

if(*c== '/') if(c-text.beg>=1) if( *(c-1)== '/') inside_commentary = 1;

looks unnatural but spares many ifs

Richard Harnden <richard.nospam@gmail.com> writes:
>On 26/04/2022 16:35, fir wrote:
....
>>for(char* c = text; c<txt+end; c++)
>>if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
....
>What is wrong with: strstr(text, "...") ?

This has a different meaning.

WRT the OP code: c[ -2 ] only is permissible when c >= text + 2.
Under this assumption, one might also use !memcmp( c-2, "...", 3 ).

btw bartc was once asking on speed of compiler processing sources

i checked now how many sole such splitter takes (though i not do much care
for cerefull testing and observations)

100 iterations of splitting 1MB of some .c code (which has 50k lines before splitting and
the splitting result had 70k entries (i splitted on 0xa and ";" ) took 1.7 second
which is like 100 MB o 1.7 second which is 58 MB/s and 2.9 M lines per second (hovever my
tests was not much carefull)
(tested on 10 year old pc)
i could eventually say that 58 MB/s not seem to be fast, but this is not optimised
this splitter obviously calls realloc on each break this is it calls 7M reallocks in the process
(which are calls becouse minority of them do reall reallocking)
i got somewhere version that spares reallocks but not use it last times

whait a second i will preallock 100k entries in front and delete reallock
0.34 second 294 MB/s 14.7 M lines/s - this is more reasonable especially as it
may probably be tried to oplimise yet slightly

On 4/26/2022 8:35 AM, fir wrote:
> assume you got routine that takes long string/literal char* txt
> as an input
>
> i need to scan for some patterns in it like "..." in this exist
> convenient is to check
>
> for(char* c = text; c<txt+end; c++)
> if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
>
> the problem is if it dont gets over a string and reads
> two chars before its begining
>
> what is the best and simplest way to do it correctly?

Um... Start searching from `text + 2`, obviously. And generally from
`pattern_length - 1` position. The pattern cannot possibly occur before
that position, no point in searching there.

--
Best regards,
Andrey Tarasevich

wtorek, 26 kwietnia 2022 o 22:32:01 UTC+2 Andrey Tarasevich napisał(a):
> On 4/26/2022 8:35 AM, fir wrote:
> > assume you got routine that takes long string/literal char* txt
> > as an input
> >
> > i need to scan for some patterns in it like "..." in this exist
> > convenient is to check
> >
> > for(char* c = text; c<txt+end; c++)
> > if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
> >
> > the problem is if it dont gets over a string and reads
> > two chars before its begining
> >
> > what is the best and simplest way to do it correctly?
> Um... Start searching from `text + 2`, obviously. And generally from
> `pattern_length - 1` position. The pattern cannot possibly occur before
> that position, no point in searching there.
>
it seems most people do this way but in respect to what i was sayin this seem to me to be kinda bad pattern

On 4/26/2022 1:51 PM, fir wrote:
> wtorek, 26 kwietnia 2022 o 22:32:01 UTC+2 Andrey Tarasevich napisał(a):
>> On 4/26/2022 8:35 AM, fir wrote:
>>> assume you got routine that takes long string/literal char* txt
>>> as an input
>>>
>>> i need to scan for some patterns in it like "..." in this exist
>>> convenient is to check
>>>
>>> for(char* c = text; c<txt+end; c++)
>>> if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
>>>
>>> the problem is if it dont gets over a string and reads
>>> two chars before its begining
>>>
>>> what is the best and simplest way to do it correctly?
>> Um... Start searching from `text + 2`, obviously. And generally from
>> `pattern_length - 1` position. The pattern cannot possibly occur before
>> that position, no point in searching there.
>>
> it seems most people do this way but in respect to what i was sayin this seem to me to be kinda bad pattern

Quite the opposite! This is actually a very elegant and useful pattern,
which I'd personally call "strive to prologue/epilogue the special case"
or something more catchy.

Pretty often when people write cyclic code they run into situations when
the cycle has to watch for a one-off special case, which occurs only
once. Keeping this special processing inside the cycle's body usually
requires checking for it (e.g. with an `if`) on every iteration. Doing
it that way reeks to high heaven: spending an effort on _every_
iteration to catch something that happens _only_ _once_ is a bad pattern.

In many cases, if you put your mind to it, you might discover a way to
pull that one-off special processing into cycle's prologue or epilogue
code, thus relieving the actual cycle from the burden of watching for
that special case. It is a nice, elegant and very useful refactoring
pattern that not only improves efficiency, but also improves readability
of the code.

One example that comes to mind is processing edges of a polygon
represented as an array of vertices. One edge - the one between the last
and the first vertex - is an obvious special case, which can be handled
very nicely by this pattern.

What you have above is a more trivial variation of that pattern as well.

P.S. On a related note: sometimes I see people who seem to be
consciously doing the opposite: for no apparent reason they push cycle's
prologue and/or epilogue _into_ the cycle's body. Something along the
lines of

for (unsigned i = 0; i < n; ++i)
{
if (i == 0)
{
// Initialize some cycle-related stuff
}

// The actual "work"

if (i == n - 1)
{
// Cleanup some cycle-related stuff
}
}

It is weird, but I encounter it often enough to conclude that those
people are "learning" this from someone/someplace and then using this in
a cargo-cult fashion.

--
Best regards,
Andrey Tarasevich

środa, 27 kwietnia 2022 o 00:05:02 UTC+2 Andrey Tarasevich napisał(a):
> On 4/26/2022 1:51 PM, fir wrote:
> > wtorek, 26 kwietnia 2022 o 22:32:01 UTC+2 Andrey Tarasevich napisał(a):
> >> On 4/26/2022 8:35 AM, fir wrote:
> >>> assume you got routine that takes long string/literal char* txt
> >>> as an input
> >>>
> >>> i need to scan for some patterns in it like "..." in this exist
> >>> convenient is to check
> >>>
> >>> for(char* c = text; c<txt+end; c++)
> >>> if(*c=='.' && *(c-1)=='.' *(c-2)=='.') ...found
> >>>
> >>> the problem is if it dont gets over a string and reads
> >>> two chars before its begining
> >>>
> >>> what is the best and simplest way to do it correctly?
> >> Um... Start searching from `text + 2`, obviously. And generally from
> >> `pattern_length - 1` position. The pattern cannot possibly occur before
> >> that position, no point in searching there.
> >>
> > it seems most people do this way but in respect to what i was sayin this seem to me to be kinda bad pattern
> Quite the opposite! This is actually a very elegant and useful pattern,
> which I'd personally call "strive to prologue/epilogue the special case"
> or something more catchy.
>
> Pretty often when people write cyclic code they run into situations when
> the cycle has to watch for a one-off special case, which occurs only
> once. Keeping this special processing inside the cycle's body usually
> requires checking for it (e.g. with an `if`) on every iteration. Doing
> it that way reeks to high heaven: spending an effort on _every_
> iteration to catch something that happens _only_ _once_ is a bad pattern.
>
> In many cases, if you put your mind to it, you might discover a way to
> pull that one-off special processing into cycle's prologue or epilogue
> code, thus relieving the actual cycle from the burden of watching for
> that special case. It is a nice, elegant and very useful refactoring
> pattern that not only improves efficiency, but also improves readability
> of the code.
>
> One example that comes to mind is processing edges of a polygon
> represented as an array of vertices. One edge - the one between the last
> and the first vertex - is an obvious special case, which can be handled
> very nicely by this pattern.
>
> What you have above is a more trivial variation of that pattern as well.
>
> P.S. On a related note: sometimes I see people who seem to be
> consciously doing the opposite: for no apparent reason they push cycle's
> prologue and/or epilogue _into_ the cycle's body. Something along the
> lines of
>
> for (unsigned i = 0; i < n; ++i)
> {
> if (i == 0)
> {
> // Initialize some cycle-related stuff
> }
>
> // The actual "work"
>
> if (i == n - 1)
> {
> // Cleanup some cycle-related stuff
> }
> }
>
> It is weird, but I encounter it often enough to conclude that those
> people are "learning" this from someone/someplace and then using this in
> a cargo-cult fashion.

ifs are costly, so from optimisation/eficiency point of view probably,
but from 'nativity' point of view its probably worse imo as it complicates
a loop, ..as i pointet in such scann pass you may need to check for nomber
of various ;subwords etc .. what i was asking in title was to establish maybe
some better pattern of doing such things