g++ still cannot handled [restrict].
[kopensolaris-gnu/glibc.git] / posix / tst-regex2.c
1 #include <fcntl.h>
2 #include <locale.h>
3 #include <regex.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #include <sys/stat.h>
8 #include <time.h>
9 #include <unistd.h>
10
11 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
12 static clockid_t cl;
13 static int use_clock;
14 #endif
15
16 static int
17 do_test (void)
18 {
19 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
20 # if _POSIX_CPUTIME == 0
21   if (sysconf (_SC_CPUTIME) < 0)
22     use_clock = 0;
23   else
24 # endif
25     /* See whether we can use the CPU clock.  */
26     use_clock = clock_getcpuclockid (0, &cl) == 0;
27 #endif
28
29   static const char *pat[] = {
30     ".?.?.?.?.?.?.?Log\\.13",
31     "(.?)(.?)(.?)(.?)(.?)(.?)(.?)Log\\.13",
32     "((((((((((.?))))))))))((((((((((.?))))))))))((((((((((.?))))))))))"
33     "((((((((((.?))))))))))((((((((((.?))))))))))((((((((((.?))))))))))"
34     "((((((((((.?))))))))))Log\\.13" };
35
36   int fd = open ("../ChangeLog.14", O_RDONLY);
37   if (fd < 0)
38     {
39       printf ("Couldn't open ChangeLog.14: %m\n");
40       return 1;
41     }
42
43   struct stat64 st;
44   if (fstat64 (fd, &st) < 0)
45     {
46       printf ("Couldn't fstat ChangeLog.14: %m\n");
47       return 1;
48     }
49
50   char *buf = malloc (st.st_size + 1);
51   if (buf == NULL)
52     {
53       printf ("Couldn't allocate buffer: %m\n");
54       return 1;
55     }
56
57   if (read (fd, buf, st.st_size) != (ssize_t) st.st_size)
58     {
59       puts ("Couldn't read ChangeLog.14");
60       return 1;
61     }
62
63   close (fd);
64   buf[st.st_size] = '\0';
65
66   setlocale (LC_ALL, "de_DE.UTF-8");
67
68   char *string = buf;
69   size_t len = st.st_size;
70
71 #ifndef WHOLE_FILE_TIMING
72   /* Don't search the whole file normally, it takes too long.  */
73   if (len > 500000 + 64)
74     {
75       string += 500000;
76       len -= 500000;
77     }
78 #endif
79
80   for (int testno = 0; testno < 4; ++testno)
81     for (int i = 0; i < sizeof (pat) / sizeof (pat[0]); ++i)
82       {
83         printf ("test %d pattern %d", testno, i);
84
85         regex_t rbuf;
86         struct re_pattern_buffer rpbuf;
87         int err;
88         if (testno < 2)
89           {
90             err = regcomp (&rbuf, pat[i],
91                            REG_EXTENDED | (testno ? REG_NOSUB : 0));
92             if (err != 0)
93               {
94                 putchar ('\n');
95                 char errstr[300];
96                 regerror (err, &rbuf, errstr, sizeof (errstr));
97                 puts (errstr);
98                 return err;
99               }
100           }
101         else
102           {
103             re_set_syntax (RE_SYNTAX_POSIX_EGREP
104                            | (testno == 3 ? RE_NO_SUB : 0));
105
106             memset (&rpbuf, 0, sizeof (rpbuf));
107             const char *s = re_compile_pattern (pat[i], strlen (pat[i]),
108                                                 &rpbuf);
109             if (s != NULL)
110               {
111                 printf ("\n%s\n", s);
112                 return 1;
113               }
114
115             /* Just so that this can be tested with earlier glibc as well.  */
116             if (testno == 3)
117               rpbuf.no_sub = 1;
118           }
119
120 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
121       struct timespec start, stop;
122       if (use_clock)
123         use_clock = clock_gettime (cl, &start) == 0;
124 #endif
125
126       if (testno < 2)
127         {
128           regmatch_t pmatch[71];
129           err = regexec (&rbuf, string, 71, pmatch, 0);
130           if (err == REG_NOMATCH)
131             {
132               puts ("\nregexec failed");
133               return 1;
134             }
135
136           if (testno == 0)
137             {
138               if (pmatch[0].rm_eo != pmatch[0].rm_so + 13
139                   || pmatch[0].rm_eo > len
140                   || pmatch[0].rm_so < len - 100
141                   || strncmp (string + pmatch[0].rm_so,
142                               " ChangeLog.13 for earlier changes",
143                               sizeof " ChangeLog.13 for earlier changes" - 1)
144                      != 0)
145                 {
146                   puts ("\nregexec without REG_NOSUB did not find the correct match");
147                   return 1;
148                 }
149
150               if (i > 0)
151                 for (int j = 0, l = 1; j < 7; ++j)
152                   for (int k = 0; k < (i == 1 ? 1 : 10); ++k, ++l)
153                     if (pmatch[l].rm_so != pmatch[0].rm_so + j
154                         || pmatch[l].rm_eo != pmatch[l].rm_so + 1)
155                       {
156                         printf ("\npmatch[%d] incorrect\n", l);
157                         return 1;
158                       }
159             }
160         }
161       else
162         {
163           struct re_registers regs;
164
165           memset (&regs, 0, sizeof (regs));
166           int match = re_search (&rpbuf, string, len, 0, len,
167                                  &regs);
168           if (match < 0)
169             {
170               puts ("\nre_search failed");
171               return 1;
172             }
173
174           if (match + 13 > len
175               || match < len - 100
176               || strncmp (string + match,
177                           " ChangeLog.13 for earlier changes",
178                           sizeof " ChangeLog.13 for earlier changes" - 1)
179                   != 0)
180             {
181               puts ("\nre_search did not find the correct match");
182               return 1;
183             }
184
185           if (testno == 2)
186             {
187               if (regs.num_regs != 2 + (i == 0 ? 0 : i == 1 ? 7 : 70))
188                 {
189                   printf ("\nincorrect num_regs %d\n", regs.num_regs);
190                   return 1;
191                 }
192
193               if (regs.start[0] != match || regs.end[0] != match + 13)
194                 {
195                   printf ("\nincorrect regs.{start,end}[0] = { %d, %d}\n",
196                           regs.start[0], regs.end[0]);
197                   return 1;
198                 }
199
200               if (regs.start[regs.num_regs - 1] != -1
201                   || regs.end[regs.num_regs - 1] != -1)
202                 {
203                   puts ("\nincorrect regs.{start,end}[num_regs - 1]");
204                   return 1;
205                 }
206
207               if (i > 0)
208                 for (int j = 0, l = 1; j < 7; ++j)
209                   for (int k = 0; k < (i == 1 ? 1 : 10); ++k, ++l)
210                     if (regs.start[l] != match + j
211                         || regs.end[l] != regs.start[l] + 1)
212                       {
213                         printf ("\nregs.{start,end}[%d] incorrect\n", l);
214                         return 1;
215                       }
216             }
217         }
218
219 #if defined _POSIX_CPUTIME && _POSIX_CPUTIME >= 0
220       if (use_clock)
221         use_clock = clock_gettime (cl, &stop) == 0;
222       if (use_clock)
223         {
224           stop.tv_sec -= start.tv_sec;
225           if (stop.tv_nsec < start.tv_nsec)
226             {
227               stop.tv_sec--;
228               stop.tv_nsec += 1000000000 - start.tv_nsec;
229             }
230           else
231             stop.tv_nsec -= start.tv_nsec;
232           printf (": %ld.%09lds\n", (long) stop.tv_sec, (long) stop.tv_nsec);
233         }
234       else
235 #endif
236         putchar ('\n');
237
238       if (testno < 2)
239         regfree (&rbuf);
240       else
241         regfree (&rpbuf);
242     }
243
244   return 0;
245 }
246
247 #define TIMEOUT 20
248 #define TEST_FUNCTION do_test ()
249 #include "../test-skeleton.c"