sys/src/libregexp/regaux.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include "regexp.h"
   4 #include "regcomp.h"
   5
   6
   7 /*
   8  *  save a new match in mp
   9  */
  10 extern void
  11 _renewmatch(Resub *mp, int ms, Resublist *sp)
  12 {
  13         int i;
  14
  15         if(mp==0 || ms<=0)
  16                 return;
  17         if(mp[0].sp==0 || sp->m[0].sp<mp[0].sp ||
  18            (sp->m[0].sp==mp[0].sp && sp->m[0].ep>mp[0].ep)){
  19                 for(i=0; i<ms && i<NSUBEXP; i++)
  20                         mp[i] = sp->m[i];
  21                 for(; i<ms; i++)
  22                         mp[i].sp = mp[i].ep = 0;
  23         }
  24 }
  25
  26 /*
  27  * Note optimization in _renewthread:
  28  *      *lp must be pending when _renewthread called; if *l has been looked
  29  *              at already, the optimization is a bug.
  30  */
  31 extern Relist*
  32 _renewthread(Relist *lp,        /* _relist to add to */
  33         Reinst *ip,             /* instruction to add */
  34         int ms,
  35         Resublist *sep)         /* pointers to subexpressions */
  36 {
  37         Relist *p;
  38
  39         for(p=lp; p->inst; p++){
  40                 if(p->inst == ip){
  41                         if(sep->m[0].sp < p->se.m[0].sp){
  42                                 if(ms > 1)
  43                                         p->se = *sep;
  44                                 else
  45                                         p->se.m[0] = sep->m[0];
  46                         }
  47                         return 0;
  48                 }
  49         }
  50         p->inst = ip;
  51         if(ms > 1)
  52                 p->se = *sep;
  53         else
  54                 p->se.m[0] = sep->m[0];
  55         (++p)->inst = 0;
  56         return p;
  57 }
  58
  59 /*
  60  * same as renewthread, but called with
  61  * initial empty start pointer.
  62  */
  63 extern Relist*
  64 _renewemptythread(Relist *lp,   /* _relist to add to */
  65         Reinst *ip,             /* instruction to add */
  66         int ms,
  67         char *sp)               /* pointers to subexpressions */
  68 {
  69         Relist *p;
  70
  71         for(p=lp; p->inst; p++){
  72                 if(p->inst == ip){
  73                         if(sp < p->se.m[0].sp) {
  74                                 if(ms > 1)
  75                                         memset(&p->se, 0, sizeof(p->se));
  76                                 p->se.m[0].sp = sp;
  77                         }
  78                         return 0;
  79                 }
  80         }
  81         p->inst = ip;
  82         if(ms > 1)
  83                 memset(&p->se, 0, sizeof(p->se));
  84         p->se.m[0].sp = sp;
  85         (++p)->inst = 0;
  86         return p;
  87 }
  88
  89 extern Relist*
  90 _rrenewemptythread(Relist *lp,  /* _relist to add to */
  91         Reinst *ip,             /* instruction to add */
  92         int ms,
  93         Rune *rsp)              /* pointers to subexpressions */
  94 {
  95         Relist *p;
  96
  97         for(p=lp; p->inst; p++){
  98                 if(p->inst == ip){
  99                         if(rsp < p->se.m[0].rsp) {
 100                                 if(ms > 1)
 101                                         memset(&p->se, 0, sizeof(p->se));
 102                                 p->se.m[0].rsp = rsp;
 103                         }
 104                         return 0;
 105                 }
 106         }
 107         p->inst = ip;
 108         if(ms > 1)
 109                 memset(&p->se, 0, sizeof(p->se));
 110         p->se.m[0].rsp = rsp;
 111         (++p)->inst = 0;
 112         return p;
 113 }