REGCMP(3PW)             COMMAND REFERENCE             REGCMP(3PW)



NAME
     regcmp, regex - compile and execute regular expression

SYNOPSIS
     char *regcmp(string1 [, string2, ...], 0)
     char *string1, *string2, ...;

     char *regex(re, subject[, ret0, ...])
     char *re, *subject, *ret0, ...;

     extern char *loc1;

DESCRIPTION
     Regcmp compiles a regular expression and returns a pointer
     to the compiled form.  A NULL return from regcmp indicates
     an incorrect argument.  Regcmp(1) has been written to
     generally preclude the need for this routine at execution
     time.

     Regex executes a compiled pattern against the subject
     string.  Additional arguments are passed to receive values
     back.  Regex returns NULL on failure or a pointer to the
     next unmatched character on success.  A global character
     pointer __loc1 points to where the match began.  Regcmp and
     regex were mostly borrowed from the editor, ed(1); however,
     the syntax and semantics have been changed slightly.  The
     following are the valid symbols and their associated
     meanings:

     []*.^     These symbols retain their current meaning.

     $         Matches the end of the string; \n matches the
               newline.

     -         Within brackets the dash means through.  For
               example, [a-z] is equivalent to [abcd...xyz].  The
               - can appear as itself only if used as the last or
               first character.  For example, the character class
               expression []-] matches the characters ] and -.

     +         A regular expression followed by + means one or
               more times.  For example, [0-9]+ is equivalent to
               [0-9][0-9]*.

     {m} {m,} {m,u}
               Integer values enclosed in {} indicate the number
               of times the preceding regular expression is to be
               applied.  M is the minimum number and u is a
               number, less than 256, which is the maximum.  If
               only m is present (for example, {m} ), it
               indicates the exact number of times the regular
               expression is to be applied.  {m,} is analogous to



Printed 10/17/86                                                1

REGCMP(3PW)             COMMAND REFERENCE             REGCMP(3PW)



               {m,infinity}.  The plus (+) and star (*)
               operations are equivalent to {1,} and {0,}
               respectively.

     ( ... )$n The value of the enclosed regular expression is to
               be returned.  The value will be stored in the
               (n+1)th argument following the subject argument.
               At present, at most ten enclosed regular
               expressions are allowed.  Regex makes its
               assignments unconditionally.

     ( ... )   Parentheses are used for grouping.  An operator,
               for example, *, +, or {}, can work on a single
               character or a regular expression enclosed in
               parenthesis.  For example, (a*(cb+)*)$0.

     By necessity, all the above defined symbols are special.
     They must, therefore, be escaped to be used as themselves.

EXAMPLES
     This example will match a leading newline in the subject
     string pointed at by cursor:



          char *cursor, *newcursor, *ptr;
               ...
          newcursor = regex((ptr = regcmp("^\n", 0)), cursor);
          free(ptr);


     This next example will match through the string Testing3 and
     will return the address of the character after the last
     matched character (cursor+11).  The string Testing3 will be
     copied to the character array ret0.



          char ret0[9];
          char *newcursor, *name;
               ...
          name = regcmp("([A-Za-z][A-za-z0-9_]{0,7})$0", 0);
          newcursor = regex(name, "123Testing321", ret0);


     And this next example applies a precompiled regular
     expression in file.i (see regcmp(1)) against string.

     This routine is kept in /usr/lib/libPW.a.






Printed 10/17/86                                                2

REGCMP(3PW)             COMMAND REFERENCE             REGCMP(3PW)



          #include "file.i"
          char *string, *newcursor;
               ...
          newcursor = regex(name, string);


CAVEATS
     The user program may run out of memory if regcmp is called
     iteractively without freeing the vectors no longer required.
     This is because regcmp uses malloc(3c) which does not use
     free space.  The following user-supplied replacement for
     malloc(3c) reuses the same vector saving time and space:

          /* user's program */
               ...
          malloc(n) {
               static int rebuf[256];
               return rebuf;
          }

SEE ALSO
     ed(1), regcmp(1), malloc(3c).

































Printed 10/17/86                                                3

%%index%%
na:72,90;
sy:162,1088;
de:1250,2644;4038,1158;
ex:5196,1031;6371,128;
ca:6499,624;
se:7123,152;
%%index%%000000000129