صفحهٔ اصلی گشت‌و‌گذار راهنما
ورود
oss
/
uclibc-ng
4
1
انشعاب 0
پرونده‌ها مشکلات 3 درخواست واکشی 0 ویکی
درخت: c6df9c9452
شاخه‌ها تگ‌ها
uclibc-ng
/
test
/
regex
/
testregex.c

testregex.c 48 KB
تاريخچه خام

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119 
  1. /*
    2. 

  2.  * regex(3) test harness
    3. 

  3.  *
    4. 

  4.  * build:	cc -o testregex testregex.c
    5. 

  5.  * help:	testregex --man
    6. 

  6.  * note:	REG_* features are detected by #ifdef; if REG_* are enums
    7. 

  7.  *		then supply #define REG_foo REG_foo for each enum REG_foo
    8. 

  8.  *
    9. 

  9.  *	Glenn Fowler <gsf@research.att.com>
    10. 

  10.  *	AT&T Labs Research
    11. 

  11.  *
    12. 

  12.  * PLEASE: publish your tests so everyone can benefit
    13. 

  13.  *
    14. 

  14.  * Permission is hereby granted, free of charge, to any person obtaining a
    15. 

  15.  * copy of THIS SOFTWARE FILE (the "Software"), to deal in the Software
    16. 

  16.  * without restriction, including without limitation the rights to use,
    17. 

  17.  * copy, modify, merge, publish, distribute, and/or sell copies of the
    18. 

  18.  * Software, and to permit persons to whom the Software is furnished to do
    19. 

  19.  * so, subject to the following disclaimer:
    20. 

  20.  *
    21. 

  21.  * THIS SOFTWARE IS PROVIDED BY AT&T ``AS IS'' AND ANY EXPRESS OR IMPLIED
    22. 

  22.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
    23. 

  23.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
    24. 

  24.  * IN NO EVENT SHALL AT&T BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    25. 

  25.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    26. 

  26.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    27. 

  27.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    28. 

  28.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    29. 

  29.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    30. 

  30.  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    31. 

  31.  */
    32. 

  32. 

  33. static const char id[] = "\n@(#)$Id: testregex (AT&T Research) 2005-05-20 $\0\n";
    34. 

  34. 

  35. #if _PACKAGE_ast
    36. 

  36. #include <ast.h>
    37. 

  37. #else
    38. 

  38. #include <sys/types.h>
    39. 

  39. #endif
    40. 

  40. 

  41. #include <stdio.h>
    42. 

  42. #include <regex.h>
    43. 

  43. #include <ctype.h>
    44. 

  44. #include <setjmp.h>
    45. 

  45. #include <signal.h>
    46. 

  46. #include <string.h>
    47. 

  47. #include <unistd.h>
    48. 

  48. 

  49. #ifdef	__STDC__
    50. 

  50. #include <stdlib.h>
    51. 

  51. #include <locale.h>
    52. 

  52. #endif
    53. 

  53. 

  54. #if !_PACKAGE_ast
    55. 

  55. #undef	REG_DISCIPLINE
    56. 

  56. #endif
    57. 

  57. 

  58. #ifndef REG_DELIMITED
    59. 

  59. #undef	_REG_subcomp
    60. 

  60. #endif
    61. 

  61. 

  62. #define TEST_ARE		0x00000001
    63. 

  63. #define TEST_BRE		0x00000002
    64. 

  64. #define TEST_ERE		0x00000004
    65. 

  65. #define TEST_KRE		0x00000008
    66. 

  66. #define TEST_LRE		0x00000010
    67. 

  67. #define TEST_SRE		0x00000020
    68. 

  68. 

  69. #define TEST_EXPAND		0x00000040
    70. 

  70. #define TEST_LENIENT		0x00000080
    71. 

  71. 

  72. #define TEST_QUERY		0x00000100
    73. 

  73. #define TEST_SUB		0x00000200
    74. 

  74. #define TEST_UNSPECIFIED	0x00000400
    75. 

  75. #define TEST_VERIFY		0x00000800
    76. 

  76. #define TEST_AND		0x00001000
    77. 

  77. #define TEST_OR			0x00002000
    78. 

  78. 

  79. #define TEST_DELIMIT		0x00010000
    80. 

  80. #define TEST_OK			0x00020000
    81. 

  81. #define TEST_SAME		0x00040000
    82. 

  82. 

  83. #define TEST_ACTUAL		0x00100000
    84. 

  84. #define TEST_BASELINE		0x00200000
    85. 

  85. #define TEST_FAIL		0x00400000
    86. 

  86. #define TEST_PASS		0x00800000
    87. 

  87. #define TEST_SUMMARY		0x01000000
    88. 

  88. 

  89. #define TEST_IGNORE_ERROR	0x02000000
    90. 

  90. #define TEST_IGNORE_OVER	0x04000000
    91. 

  91. #define TEST_IGNORE_POSITION	0x08000000
    92. 

  92. 

  93. #define TEST_CATCH		0x10000000
    94. 

  94. #define TEST_VERBOSE		0x20000000
    95. 

  95. 

  96. #define TEST_GLOBAL		(TEST_ACTUAL|TEST_AND|TEST_BASELINE|TEST_CATCH|TEST_FAIL|TEST_IGNORE_ERROR|TEST_IGNORE_OVER|TEST_IGNORE_POSITION|TEST_OR|TEST_PASS|TEST_SUMMARY|TEST_VERBOSE)
    97. 

  97. 

  98. #ifdef REG_DISCIPLINE
    99. 

  99. 

  100. 

  101. #include <stk.h>
    102. 

  102. 

  103. typedef struct Disc_s
    104. 

  104. {
    105. 

  105. 	regdisc_t	disc;
    106. 

  106. 	int		ordinal;
    107. 

  107. 	Sfio_t*		sp;
    108. 

  108. } Disc_t;
    109. 

  109. 

  110. static void*
    111. 

  111. compf(const regex_t* re, const char* xstr, size_t xlen, regdisc_t* disc)
    112. 

  112. {
    113. 

  113. 	Disc_t*		dp = (Disc_t*)disc;
    114. 

  114. 

  115. 	return (void*)++dp->ordinal;
    116. 

  116. }
    117. 

  117. 

  118. static int
    119. 

  119. execf(const regex_t* re, void* data, const char* xstr, size_t xlen, const char* sstr, size_t slen, char** snxt, regdisc_t* disc)
    120. 

  120. {
    121. 

  121. 	Disc_t*		dp = (Disc_t*)disc;
    122. 

  122. 

  123. 	sfprintf(dp->sp, "{%-.*s}(%d:%d)", xlen, xstr, (int)data, slen);
    124. 

  124. 	return atoi(xstr);
    125. 

  125. }
    126. 

  126. 

  127. static void*
    128. 

  128. resizef(void* handle, void* data, size_t size)
    129. 

  129. {
    130. 

  130. 	if (!size)
    131. 

  131. 		return 0;
    132. 

  132. 	return stkalloc((Sfio_t*)handle, size);
    133. 

  133. }
    134. 

  134. 

  135. #endif
    136. 

  136. 

  137. #ifndef NiL
    138. 

  138. #ifdef	__STDC__
    139. 

  139. #define NiL		0
    140. 

  140. #else
    141. 

  141. #define NiL		(char*)0
    142. 

  142. #endif
    143. 

  143. #endif
    144. 

  144. 

  145. #define H(x)		do{if(html)fprintf(stderr,x);}while(0)
    146. 

  146. #define T(x)		fprintf(stderr,x)
    147. 

  147. 

  148. static void
    149. 

  149. help(int html)
    150. 

  150. {
    151. 

  151. H("<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML//EN\">\n");
    152. 

  152. H("<HTML>\n");
    153. 

  153. H("<HEAD>\n");
    154. 

  154. H("<TITLE>testregex man document</TITLE>\n");
    155. 

  155. H("</HEAD>\n");
    156. 

  156. H("<BODY bgcolor=white>\n");
    157. 

  157. H("<PRE>\n");
    158. 

  158. T("NAME\n");
    159. 

  159. T("  testregex - regex(3) test harness\n");
    160. 

  160. T("\n");
    161. 

  161. T("SYNOPSIS\n");
    162. 

  162. T("  testregex [ options ]\n");
    163. 

  163. T("\n");
    164. 

  164. T("DESCRIPTION\n");
    165. 

  165. T("  testregex reads regex(3) test specifications, one per line, from the\n");
    166. 

  166. T("  standard input and writes one output line for each failed test. A\n");
    167. 

  167. T("  summary line is written after all tests are done. Each successful\n");
    168. 

  168. T("  test is run again with REG_NOSUB. Unsupported features are noted\n");
    169. 

  169. T("  before the first test, and tests requiring these features are\n");
    170. 

  170. T("  silently ignored.\n");
    171. 

  171. T("\n");
    172. 

  172. T("OPTIONS\n");
    173. 

  173. T("  -c	catch signals and non-terminating calls\n");
    174. 

  174. T("  -e	ignore error return mismatches\n");
    175. 

  175. T("  -h	list help on standard error\n");
    176. 

  176. T("  -n	do not repeat successful tests with regnexec()\n");
    177. 

  177. T("  -o	ignore match[] overrun errors\n");
    178. 

  178. T("  -p	ignore negative position mismatches\n");
    179. 

  179. T("  -s	use stack instead of malloc\n");
    180. 

  180. T("  -x	do not repeat successful tests with REG_NOSUB\n");
    181. 

  181. T("  -v	list each test line\n");
    182. 

  182. T("  -A	list failed test lines with actual answers\n");
    183. 

  183. T("  -B	list all test lines with actual answers\n");
    184. 

  184. T("  -F	list failed test lines\n");
    185. 

  185. T("  -P	list passed test lines\n");
    186. 

  186. T("  -S	output one summary line\n");
    187. 

  187. T("\n");
    188. 

  188. T("INPUT FORMAT\n");
    189. 

  189. T("  Input lines may be blank, a comment beginning with #, or a test\n");
    190. 

  190. T("  specification. A specification is five fields separated by one\n");
    191. 

  191. T("  or more tabs. NULL denotes the empty string and NIL denotes the\n");
    192. 

  192. T("  0 pointer.\n");
    193. 

  193. T("\n");
    194. 

  194. T("  Field 1: the regex(3) flags to apply, one character per REG_feature\n");
    195. 

  195. T("  flag. The test is skipped if REG_feature is not supported by the\n");
    196. 

  196. T("  implementation. If the first character is not [BEASKL] then the\n");
    197. 

  197. T("  specification is a global control line. One or more of [BEASKL] may be\n");
    198. 

  198. T("  specified; the test will be repeated for each mode.\n");
    199. 

  199. T("\n");
    200. 

  200. T("    B 	basic			BRE	(grep, ed, sed)\n");
    201. 

  201. T("    E 	REG_EXTENDED		ERE	(egrep)\n");
    202. 

  202. T("    A	REG_AUGMENTED		ARE	(egrep with negation)\n");
    203. 

  203. T("    S	REG_SHELL		SRE	(sh glob)\n");
    204. 

  204. T("    K	REG_SHELL|REG_AUGMENTED	KRE	(ksh glob)\n");
    205. 

  205. T("    L	REG_LITERAL		LRE	(fgrep)\n");
    206. 

  206. T("\n");
    207. 

  207. T("    a	REG_LEFT|REG_RIGHT	implicit ^...$\n");
    208. 

  208. T("    b	REG_NOTBOL		lhs does not match ^\n");
    209. 

  209. T("    c	REG_COMMENT		ignore space and #...\\n\n");
    210. 

  210. T("    d	REG_SHELL_DOT		explicit leading . match\n");
    211. 

  211. T("    e	REG_NOTEOL		rhs does not match $\n");
    212. 

  212. T("    f	REG_MULTIPLE		multiple \\n separated patterns\n");
    213. 

  213. T("    g	FNM_LEADING_DIR		testfnmatch only -- match until /\n");
    214. 

  214. T("    h	REG_MULTIREF		multiple digit backref\n");
    215. 

  215. T("    i	REG_ICASE		ignore case\n");
    216. 

  216. T("    j	REG_SPAN		. matches \\n\n");
    217. 

  217. T("    k	REG_ESCAPE		\\ to ecape [...] delimiter\n");
    218. 

  218. T("    l	REG_LEFT		implicit ^...\n");
    219. 

  219. T("    m	REG_MINIMAL		minimal match\n");
    220. 

  220. T("    n	REG_NEWLINE		explicit \\n match\n");
    221. 

  221. T("    o	REG_ENCLOSED		(|&) magic inside [@|&](...)\n");
    222. 

  222. T("    p	REG_SHELL_PATH		explicit / match\n");
    223. 

  223. T("    q	REG_DELIMITED		delimited pattern\n");
    224. 

  224. T("    r	REG_RIGHT		implicit ...$\n");
    225. 

  225. T("    s	REG_SHELL_ESCAPED	\\ not special\n");
    226. 

  226. T("    t	REG_MUSTDELIM		all delimiters must be specified\n");
    227. 

  227. T("    u	standard unspecified behavior -- errors not counted\n");
    228. 

  228. T("    w	REG_NOSUB		no subexpression match array\n");
    229. 

  229. T("    x	REG_LENIENT		let some errors slide\n");
    230. 

  230. T("    y	REG_LEFT		regexec() implicit ^...\n");
    231. 

  231. T("    z	REG_NULL		NULL subexpressions ok\n");
    232. 

  232. T("    $	                        expand C \\c escapes in fields 2 and 3\n");
    233. 

  233. T("    /	                        field 2 is a regsubcomp() expression\n");
    234. 

  234. T("\n");
    235. 

  235. T("  Field 1 control lines:\n");
    236. 

  236. T("\n");
    237. 

  237. T("    C		set LC_COLLATE and LC_CTYPE to locale in field 2\n");
    238. 

  238. T("\n");
    239. 

  239. T("    ?test ...	output field 5 if passed and != EXPECTED, silent otherwise\n");
    240. 

  240. T("    &test ...	output field 5 if current and previous passed\n");
    241. 

  241. T("    |test ...	output field 5 if current passed and previous failed\n");
    242. 

  242. T("    ; ...	output field 2 if previous failed\n");
    243. 

  243. T("    {test ...	skip if failed until }\n");
    244. 

  244. T("    }		end of skip\n");
    245. 

  245. T("\n");
    246. 

  246. T("    : comment		comment copied as output NOTE\n");
    247. 

  247. T("    :comment:test	:comment: ignored\n");
    248. 

  248. T("    N[OTE] comment	comment copied as output NOTE\n");
    249. 

  249. T("    T[EST] comment	comment\n");
    250. 

  250. T("\n");
    251. 

  251. T("    number		use number for nmatch (20 by default)\n");
    252. 

  252. T("\n");
    253. 

  253. T("  Field 2: the regular expression pattern; SAME uses the pattern from\n");
    254. 

  254. T("    the previous specification.\n");
    255. 

  255. T("\n");
    256. 

  256. T("  Field 3: the string to match.\n");
    257. 

  257. T("\n");
    258. 

  258. T("  Field 4: the test outcome. This is either one of the posix error\n");
    259. 

  259. T("    codes (with REG_ omitted) or the match array, a list of (m,n)\n");
    260. 

  260. T("    entries with m and n being first and last+1 positions in the\n");
    261. 

  261. T("    field 3 string, or NULL if REG_NOSUB is in effect and success\n");
    262. 

  262. T("    is expected. BADPAT is acceptable in place of any regcomp(3)\n");
    263. 

  263. T("    error code. The match[] array is initialized to (-2,-2) before\n");
    264. 

  264. T("    each test. All array elements from 0 to nmatch-1 must be specified\n");
    265. 

  265. T("    in the outcome. Unspecified endpoints (offset -1) are denoted by ?.\n");
    266. 

  266. T("    Unset endpoints (offset -2) are denoted by X. {x}(o:n) denotes a\n");
    267. 

  267. T("    matched (?{...}) expression, where x is the text enclosed by {...},\n");
    268. 

  268. T("    o is the expression ordinal counting from 1, and n is the length of\n");
    269. 

  269. T("    the unmatched portion of the subject string. If x starts with a\n");
    270. 

  270. T("    number then that is the return value of re_execf(), otherwise 0 is\n");
    271. 

  271. T("    returned.\n");
    272. 

  272. T("\n");
    273. 

  273. T("  Field 5: optional comment appended to the report.\n");
    274. 

  274. T("\n");
    275. 

  275. T("CAVEAT\n");
    276. 

  276. T("    If a regex implementation misbehaves with memory then all bets are off.\n");
    277. 

  277. T("\n");
    278. 

  278. T("CONTRIBUTORS\n");
    279. 

  279. T("  Glenn Fowler    gsf@research.att.com        (ksh strmatch, regex extensions)\n");
    280. 

  280. T("  David Korn      dgk@research.att.com        (ksh glob matcher)\n");
    281. 

  281. T("  Doug McIlroy    mcilroy@dartmouth.edu       (ast regex/testre in C++)\n");
    282. 

  282. T("  Tom Lord        lord@regexps.com            (rx tests)\n");
    283. 

  283. T("  Henry Spencer   henry@zoo.toronto.edu       (original public regex)\n");
    284. 

  284. T("  Andrew Hume     andrew@research.att.com     (gre tests)\n");
    285. 

  285. T("  John Maddock    John_Maddock@compuserve.com (regex++ tests)\n");
    286. 

  286. T("  Philip Hazel    ph10@cam.ac.uk              (pcre tests)\n");
    287. 

  287. T("  Ville Laurikari vl@iki.fi                   (libtre tests)\n");
    288. 

  288. H("</PRE>\n");
    289. 

  289. H("</BODY>\n");
    290. 

  290. H("</HTML>\n");
    291. 

  291. }
    292. 

  292. 

  293. #ifndef elementsof
    294. 

  294. #define elementsof(x)	(sizeof(x)/sizeof(x[0]))
    295. 

  295. #endif
    296. 

  296. 

  297. #ifndef streq
    298. 

  298. #define streq(a,b)	(*(a)==*(b)&&!strcmp(a,b))
    299. 

  299. #endif
    300. 

  300. 

  301. #define HUNG		2
    302. 

  302. #define NOTEST		(~0)
    303. 

  303. 

  304. #ifndef REG_TEST_DEFAULT
    305. 

  305. #define REG_TEST_DEFAULT	0
    306. 

  306. #endif
    307. 

  307. 

  308. #ifndef REG_EXEC_DEFAULT
    309. 

  309. #define REG_EXEC_DEFAULT	0
    310. 

  310. #endif
    311. 

  311. 

  312. static const char* unsupported[] =
    313. 

  313. {
    314. 

  314. 	"BASIC",
    315. 

  315. #ifndef REG_EXTENDED
    316. 

  316. 	"EXTENDED",
    317. 

  317. #endif
    318. 

  318. #ifndef REG_AUGMENTED
    319. 

  319. 	"AUGMENTED",
    320. 

  320. #endif
    321. 

  321. #ifndef REG_SHELL
    322. 

  322. 	"SHELL",
    323. 

  323. #endif
    324. 

  324. 

  325. #ifndef REG_COMMENT
    326. 

  326. 	"COMMENT",
    327. 

  327. #endif
    328. 

  328. #ifndef REG_DELIMITED
    329. 

  329. 	"DELIMITED",
    330. 

  330. #endif
    331. 

  331. #ifndef REG_DISCIPLINE
    332. 

  332. 	"DISCIPLINE",
    333. 

  333. #endif
    334. 

  334. #ifndef REG_ESCAPE
    335. 

  335. 	"ESCAPE",
    336. 

  336. #endif
    337. 

  337. #ifndef REG_ICASE
    338. 

  338. 	"ICASE",
    339. 

  339. #endif
    340. 

  340. #ifndef REG_LEFT
    341. 

  341. 	"LEFT",
    342. 

  342. #endif
    343. 

  343. #ifndef REG_LENIENT
    344. 

  344. 	"LENIENT",
    345. 

  345. #endif
    346. 

  346. #ifndef REG_LITERAL
    347. 

  347. 	"LITERAL",
    348. 

  348. #endif
    349. 

  349. #ifndef REG_MINIMAL
    350. 

  350. 	"MINIMAL",
    351. 

  351. #endif
    352. 

  352. #ifndef REG_MULTIPLE
    353. 

  353. 	"MULTIPLE",
    354. 

  354. #endif
    355. 

  355. #ifndef REG_MULTIREF
    356. 

  356. 	"MULTIREF",
    357. 

  357. #endif
    358. 

  358. #ifndef REG_MUSTDELIM
    359. 

  359. 	"MUSTDELIM",
    360. 

  360. #endif
    361. 

  361. #ifndef REG_NEWLINE
    362. 

  362. 	"NEWLINE",
    363. 

  363. #endif
    364. 

  364. #ifndef REG_NOTBOL
    365. 

  365. 	"NOTBOL",
    366. 

  366. #endif
    367. 

  367. #ifndef REG_NOTEOL
    368. 

  368. 	"NOTEOL",
    369. 

  369. #endif
    370. 

  370. #ifndef REG_NULL
    371. 

  371. 	"NULL",
    372. 

  372. #endif
    373. 

  373. #ifndef REG_RIGHT
    374. 

  374. 	"RIGHT",
    375. 

  375. #endif
    376. 

  376. #ifndef REG_SHELL_DOT
    377. 

  377. 	"SHELL_DOT",
    378. 

  378. #endif
    379. 

  379. #ifndef REG_SHELL_ESCAPED
    380. 

  380. 	"SHELL_ESCAPED",
    381. 

  381. #endif
    382. 

  382. #ifndef REG_SHELL_GROUP
    383. 

  383. 	"SHELL_GROUP",
    384. 

  384. #endif
    385. 

  385. #ifndef REG_SHELL_PATH
    386. 

  386. 	"SHELL_PATH",
    387. 

  387. #endif
    388. 

  388. #ifndef REG_SPAN
    389. 

  389. 	"SPAN",
    390. 

  390. #endif
    391. 

  391. #if REG_NOSUB & REG_TEST_DEFAULT
    392. 

  392. 	"SUBMATCH",
    393. 

  393. #endif
    394. 

  394. #if !_REG_nexec
    395. 

  395. 	"regnexec",
    396. 

  396. #endif
    397. 

  397. #if !_REG_subcomp
    398. 

  398. 	"regsubcomp",
    399. 

  399. #endif
    400. 

  400. 	0
    401. 

  401. };
    402. 

  402. 

  403. #ifndef REG_COMMENT
    404. 

  404. #define REG_COMMENT	NOTEST
    405. 

  405. #endif
    406. 

  406. #ifndef REG_DELIMITED
    407. 

  407. #define REG_DELIMITED	NOTEST
    408. 

  408. #endif
    409. 

  409. #ifndef REG_ESCAPE
    410. 

  410. #define REG_ESCAPE	NOTEST
    411. 

  411. #endif
    412. 

  412. #ifndef REG_ICASE
    413. 

  413. #define REG_ICASE	NOTEST
    414. 

  414. #endif
    415. 

  415. #ifndef REG_LEFT
    416. 

  416. #define REG_LEFT	NOTEST
    417. 

  417. #endif
    418. 

  418. #ifndef REG_LENIENT
    419. 

  419. #define REG_LENIENT	0
    420. 

  420. #endif
    421. 

  421. #ifndef REG_MINIMAL
    422. 

  422. #define REG_MINIMAL	NOTEST
    423. 

  423. #endif
    424. 

  424. #ifndef REG_MULTIPLE
    425. 

  425. #define REG_MULTIPLE	NOTEST
    426. 

  426. #endif
    427. 

  427. #ifndef REG_MULTIREF
    428. 

  428. #define REG_MULTIREF	NOTEST
    429. 

  429. #endif
    430. 

  430. #ifndef REG_MUSTDELIM
    431. 

  431. #define REG_MUSTDELIM	NOTEST
    432. 

  432. #endif
    433. 

  433. #ifndef REG_NEWLINE
    434. 

  434. #define REG_NEWLINE	NOTEST
    435. 

  435. #endif
    436. 

  436. #ifndef REG_NOTBOL
    437. 

  437. #define REG_NOTBOL	NOTEST
    438. 

  438. #endif
    439. 

  439. #ifndef REG_NOTEOL
    440. 

  440. #define REG_NOTEOL	NOTEST
    441. 

  441. #endif
    442. 

  442. #ifndef REG_NULL
    443. 

  443. #define REG_NULL	NOTEST
    444. 

  444. #endif
    445. 

  445. #ifndef REG_RIGHT
    446. 

  446. #define REG_RIGHT	NOTEST
    447. 

  447. #endif
    448. 

  448. #ifndef REG_SHELL_DOT
    449. 

  449. #define REG_SHELL_DOT	NOTEST
    450. 

  450. #endif
    451. 

  451. #ifndef REG_SHELL_ESCAPED
    452. 

  452. #define REG_SHELL_ESCAPED	NOTEST
    453. 

  453. #endif
    454. 

  454. #ifndef REG_SHELL_GROUP
    455. 

  455. #define REG_SHELL_GROUP	NOTEST
    456. 

  456. #endif
    457. 

  457. #ifndef REG_SHELL_PATH
    458. 

  458. #define REG_SHELL_PATH	NOTEST
    459. 

  459. #endif
    460. 

  460. #ifndef REG_SPAN
    461. 

  461. #define REG_SPAN	NOTEST
    462. 

  462. #endif
    463. 

  463. 

  464. #define REG_UNKNOWN	(-1)
    465. 

  465. 

  466. #ifndef REG_ENEWLINE
    467. 

  467. #define REG_ENEWLINE	(REG_UNKNOWN-1)
    468. 

  468. #endif
    469. 

  469. #ifndef REG_ENULL
    470. 

  470. #ifndef REG_EMPTY
    471. 

  471. #define REG_ENULL	(REG_UNKNOWN-2)
    472. 

  472. #else
    473. 

  473. #define REG_ENULL	REG_EMPTY
    474. 

  474. #endif
    475. 

  475. #endif
    476. 

  476. #ifndef REG_ECOUNT
    477. 

  477. #define REG_ECOUNT	(REG_UNKNOWN-3)
    478. 

  478. #endif
    479. 

  479. #ifndef REG_BADESC
    480. 

  480. #define REG_BADESC	(REG_UNKNOWN-4)
    481. 

  481. #endif
    482. 

  482. #ifndef REG_EMEM
    483. 

  483. #define REG_EMEM	(REG_UNKNOWN-5)
    484. 

  484. #endif
    485. 

  485. #ifndef REG_EHUNG
    486. 

  486. #define REG_EHUNG	(REG_UNKNOWN-6)
    487. 

  487. #endif
    488. 

  488. #ifndef REG_EBUS
    489. 

  489. #define REG_EBUS	(REG_UNKNOWN-7)
    490. 

  490. #endif
    491. 

  491. #ifndef REG_EFAULT
    492. 

  492. #define REG_EFAULT	(REG_UNKNOWN-8)
    493. 

  493. #endif
    494. 

  494. #ifndef REG_EFLAGS
    495. 

  495. #define REG_EFLAGS	(REG_UNKNOWN-9)
    496. 

  496. #endif
    497. 

  497. #ifndef REG_EDELIM
    498. 

  498. #define REG_EDELIM	(REG_UNKNOWN-9)
    499. 

  499. #endif
    500. 

  500. 

  501. static const struct { int code; char* name; } codes[] =
    502. 

  502. {
    503. 

  503. 	{REG_UNKNOWN,	"UNKNOWN"},
    504. 

  504. 	{REG_NOMATCH,	"NOMATCH"},
    505. 

  505. 	{REG_BADPAT,	"BADPAT"},
    506. 

  506. 	{REG_ECOLLATE,	"ECOLLATE"},
    507. 

  507. 	{REG_ECTYPE,	"ECTYPE"},
    508. 

  508. 	{REG_EESCAPE,	"EESCAPE"},
    509. 

  509. 	{REG_ESUBREG,	"ESUBREG"},
    510. 

  510. 	{REG_EBRACK,	"EBRACK"},
    511. 

  511. 	{REG_EPAREN,	"EPAREN"},
    512. 

  512. 	{REG_EBRACE,	"EBRACE"},
    513. 

  513. 	{REG_BADBR,	"BADBR"},
    514. 

  514. 	{REG_ERANGE,	"ERANGE"},
    515. 

  515. 	{REG_ESPACE,	"ESPACE"},
    516. 

  516. 	{REG_BADRPT,	"BADRPT"},
    517. 

  517. 	{REG_ENEWLINE,	"ENEWLINE"},
    518. 

  518. 	{REG_ENULL,	"ENULL"},
    519. 

  519. 	{REG_ECOUNT,	"ECOUNT"},
    520. 

  520. 	{REG_BADESC,	"BADESC"},
    521. 

  521. 	{REG_EMEM,	"EMEM"},
    522. 

  522. 	{REG_EHUNG,	"EHUNG"},
    523. 

  523. 	{REG_EBUS,	"EBUS"},
    524. 

  524. 	{REG_EFAULT,	"EFAULT"},
    525. 

  525. 	{REG_EFLAGS,	"EFLAGS"},
    526. 

  526. 	{REG_EDELIM,	"EDELIM"},
    527. 

  527. };
    528. 

  528. 

  529. static struct
    530. 

  530. {
    531. 

  531. 	regmatch_t	NOMATCH;
    532. 

  532. 	int		errors;
    533. 

  533. 	int		extracted;
    534. 

  534. 	int		ignored;
    535. 

  535. 	int		lineno;
    536. 

  536. 	int		passed;
    537. 

  537. 	int		signals;
    538. 

  538. 	int		unspecified;
    539. 

  539. 	int		verify;
    540. 

  540. 	int		warnings;
    541. 

  541. 	char*		file;
    542. 

  542. 	char*		stack;
    543. 

  543. 	char*		which;
    544. 

  544. 	jmp_buf		gotcha;
    545. 

  545. #ifdef REG_DISCIPLINE
    546. 

  546. 	Disc_t		disc;
    547. 

  547. #endif
    548. 

  548. } state;
    549. 

  549. 

  550. static void
    551. 

  551. quote(char* s, int len, unsigned long test)
    552. 

  552. {
    553. 

  553. 	unsigned char*	u = (unsigned char*)s;
    554. 

  554. 	unsigned char*	e;
    555. 

  555. 	int		c;
    556. 

  556. 

  557. 	if (!u)
    558. 

  558. 		printf("NIL");
    559. 

  559. 	else if (!*u && len <= 1)
    560. 

  560. 		printf("NULL");
    561. 

  561. 	else if (test & TEST_EXPAND)
    562. 

  562. 	{
    563. 

  563. 		if (len < 0)
    564. 

  564. 			len = strlen((char*)u);
    565. 

  565. 		e = u + len;
    566. 

  566. 		if (test & TEST_DELIMIT)
    567. 

  567. 			printf("\"");
    568. 

  568. 		while (u < e)
    569. 

  569. 			switch (c = *u++)
    570. 

  570. 			{
    571. 

  571. 			case '\\':
    572. 

  572. 				printf("\\\\");
    573. 

  573. 				break;
    574. 

  574. 			case '"':
    575. 

  575. 				if (test & TEST_DELIMIT)
    576. 

  576. 					printf("\\\"");
    577. 

  577. 				else
    578. 

  578. 					printf("\"");
    579. 

  579. 				break;
    580. 

  580. 			case '\a':
    581. 

  581. 				printf("\\a");
    582. 

  582. 				break;
    583. 

  583. 			case '\b':
    584. 

  584. 				printf("\\b");
    585. 

  585. 				break;
    586. 

  586. 			case 033:
    587. 

  587. 				printf("\\e");
    588. 

  588. 				break;
    589. 

  589. 			case '\f':
    590. 

  590. 				printf("\\f");
    591. 

  591. 				break;
    592. 

  592. 			case '\n':
    593. 

  593. 				printf("\\n");
    594. 

  594. 				break;
    595. 

  595. 			case '\r':
    596. 

  596. 				printf("\\r");
    597. 

  597. 				break;
    598. 

  598. 			case '\t':
    599. 

  599. 				printf("\\t");
    600. 

  600. 				break;
    601. 

  601. 			case '\v':
    602. 

  602. 				printf("\\v");
    603. 

  603. 				break;
    604. 

  604. 			default:
    605. 

  605. 				if (!iscntrl(c) && isprint(c))
    606. 

  606. 					putchar(c);
    607. 

  607. 				else
    608. 

  608. 					printf("\\x%02x", c);
    609. 

  609. 				break;
    610. 

  610. 			}
    611. 

  611. 		if (test & TEST_DELIMIT)
    612. 

  612. 			printf("\"");
    613. 

  613. 	}
    614. 

  614. 	else
    615. 

  615. 		printf("%s", s);
    616. 

  616. }
    617. 

  617. 

  618. static void
    619. 

  619. report(char* comment, char* fun, char* re, char* s, int len, char* msg, int flags, unsigned long test)
    620. 

  620. {
    621. 

  621. 	if (state.file)
    622. 

  622. 		printf("%s:", state.file);
    623. 

  623. 	printf("%d:", state.lineno);
    624. 

  624. 	if (re)
    625. 

  625. 	{
    626. 

  626. 		printf(" ");
    627. 

  627. 		quote(re, -1, test|TEST_DELIMIT);
    628. 

  628. 		if (s)
    629. 

  629. 		{
    630. 

  630. 			printf(" versus ");
    631. 

  631. 			quote(s, len, test|TEST_DELIMIT);
    632. 

  632. 		}
    633. 

  633. 	}
    634. 

  634. 	if (test & TEST_UNSPECIFIED)
    635. 

  635. 	{
    636. 

  636. 		state.unspecified++;
    637. 

  637. 		printf(" unspecified behavior");
    638. 

  638. 	}
    639. 

  639. 	else
    640. 

  640. 		state.errors++;
    641. 

  641. 	if (state.which)
    642. 

  642. 		printf(" %s", state.which);
    643. 

  643. 	if (flags & REG_NOSUB)
    644. 

  644. 		printf(" NOSUB");
    645. 

  645. 	if (fun)
    646. 

  646. 		printf(" %s", fun);
    647. 

  647. 	if (comment[strlen(comment)-1] == '\n')
    648. 

  648. 		printf(" %s", comment);
    649. 

  649. 	else
    650. 

  650. 	{
    651. 

  651. 		printf(" %s: ", comment);
    652. 

  652. 		if (msg)
    653. 

  653. 			printf("%s: ", msg);
    654. 

  654. 	}
    655. 

  655. }
    656. 

  656. 

  657. static void
    658. 

  658. error(regex_t* preg, int code)
    659. 

  659. {
    660. 

  660. 	char*	msg;
    661. 

  661. 	char	buf[256];
    662. 

  662. 

  663. 	switch (code)
    664. 

  664. 	{
    665. 

  665. 	case REG_EBUS:
    666. 

  666. 		msg = "bus error";
    667. 

  667. 		break;
    668. 

  668. 	case REG_EFAULT:
    669. 

  669. 		msg = "memory fault";
    670. 

  670. 		break;
    671. 

  671. 	case REG_EHUNG:
    672. 

  672. 		msg = "did not terminate";
    673. 

  673. 		break;
    674. 

  674. 	default:
    675. 

  675. 		regerror(code, preg, msg = buf, sizeof buf);
    676. 

  676. 		break;
    677. 

  677. 	}
    678. 

  678. 	printf("%s\n", msg);
    679. 

  679. }
    680. 

  680. 

  681. static void
    682. 

  682. bad(char* comment, char* re, char* s, int len, unsigned long test)
    683. 

  683. {
    684. 

  684. 	printf("bad test case ");
    685. 

  685. 	report(comment, NiL, re, s, len, NiL, 0, test);
    686. 

  686. 	exit(1);
    687. 

  687. }
    688. 

  688. 

  689. static int
    690. 

  690. escape(char* s)
    691. 

  691. {
    692. 

  692. 	char*	b;
    693. 

  693. 	char*	t;
    694. 

  694. 	char*	q;
    695. 

  695. 	char*	e;
    696. 

  696. 	int	c;
    697. 

  697. 

  698. 	for (b = t = s; (*t = *s); s++, t++)
    699. 

  699. 		if (*s == '\\')
    700. 

  700. 			switch (*++s)
    701. 

  701. 			{
    702. 

  702. 			case '\\':
    703. 

  703. 				break;
    704. 

  704. 			case 'a':
    705. 

  705. 				*t = '\a';
    706. 

  706. 				break;
    707. 

  707. 			case 'b':
    708. 

  708. 				*t = '\b';
    709. 

  709. 				break;
    710. 

  710. 			case 'c':
    711. 

  711. 				if ((*t = *++s))
    712. 

  712. 					*t &= 037;
    713. 

  713. 				else
    714. 

  714. 					s--;
    715. 

  715. 				break;
    716. 

  716. 			case 'e':
    717. 

  717. 			case 'E':
    718. 

  718. 				*t = 033;
    719. 

  719. 				break;
    720. 

  720. 			case 'f':
    721. 

  721. 				*t = '\f';
    722. 

  722. 				break;
    723. 

  723. 			case 'n':
    724. 

  724. 				*t = '\n';
    725. 

  725. 				break;
    726. 

  726. 			case 'r':
    727. 

  727. 				*t = '\r';
    728. 

  728. 				break;
    729. 

  729. 			case 's':
    730. 

  730. 				*t = ' ';
    731. 

  731. 				break;
    732. 

  732. 			case 't':
    733. 

  733. 				*t = '\t';
    734. 

  734. 				break;
    735. 

  735. 			case 'v':
    736. 

  736. 				*t = '\v';
    737. 

  737. 				break;
    738. 

  738. 			case 'u':
    739. 

  739. 			case 'x':
    740. 

  740. 				c = 0;
    741. 

  741. 				q = c == 'u' ? (s + 5) : (char*)0;
    742. 

  742. 				e = s + 1;
    743. 

  743. 				while (!e || !q || s < q)
    744. 

  744. 				{
    745. 

  745. 					switch (*++s)
    746. 

  746. 					{
    747. 

  747. 					case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
    748. 

  748. 						c = (c << 4) + *s - 'a' + 10;
    749. 

  749. 						continue;
    750. 

  750. 					case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
    751. 

  751. 						c = (c << 4) + *s - 'A' + 10;
    752. 

  752. 						continue;
    753. 

  753. 					case '0': case '1': case '2': case '3': case '4':
    754. 

  754. 					case '5': case '6': case '7': case '8': case '9':
    755. 

  755. 						c = (c << 4) + *s - '0';
    756. 

  756. 						continue;
    757. 

  757. 					case '{':
    758. 

  758. 					case '[':
    759. 

  759. 						if (s != e)
    760. 

  760. 						{
    761. 

  761. 							s--;
    762. 

  762. 							break;
    763. 

  763. 						}
    764. 

  764. 						e = 0;
    765. 

  765. 						continue;
    766. 

  766. 					case '}':
    767. 

  767. 					case ']':
    768. 

  768. 						if (e)
    769. 

  769. 							s--;
    770. 

  770. 						break;
    771. 

  771. 					default:
    772. 

  772. 						s--;
    773. 

  773. 						break;
    774. 

  774. 					}
    775. 

  775. 					break;
    776. 

  776. 				}
    777. 

  777. 				*t = c;
    778. 

  778. 				break;
    779. 

  779. 			case '0': case '1': case '2': case '3':
    780. 

  780. 			case '4': case '5': case '6': case '7':
    781. 

  781. 				c = *s - '0';
    782. 

  782. 				q = s + 2;
    783. 

  783. 				while (s < q)
    784. 

  784. 				{
    785. 

  785. 					switch (*++s)
    786. 

  786. 					{
    787. 

  787. 					case '0': case '1': case '2': case '3':
    788. 

  788. 					case '4': case '5': case '6': case '7':
    789. 

  789. 						c = (c << 3) + *s - '0';
    790. 

  790. 						break;
    791. 

  791. 					default:
    792. 

  792. 						q = --s;
    793. 

  793. 						break;
    794. 

  794. 					}
    795. 

  795. 				}
    796. 

  796. 				*t = c;
    797. 

  797. 				break;
    798. 

  798. 			default:
    799. 

  799. 				*(s + 1) = 0;
    800. 

  800. 				bad("invalid C \\ escape\n", s - 1, NiL, 0, 0);
    801. 

  801. 			}
    802. 

  802. 	return t - b;
    803. 

  803. }
    804. 

  804. 

  805. static void
    806. 

  806. matchoffprint(int off)
    807. 

  807. {
    808. 

  808. 	switch (off)
    809. 

  809. 	{
    810. 

  810. 	case -2:
    811. 

  811. 		printf("X");
    812. 

  812. 		break;
    813. 

  813. 	case -1:
    814. 

  814. 		printf("?");
    815. 

  815. 		break;
    816. 

  816. 	default:
    817. 

  817. 		printf("%d", off);
    818. 

  818. 		break;
    819. 

  819. 	}
    820. 

  820. }
    821. 

  821. 

  822. static void
    823. 

  823. matchprint(regmatch_t* match, int nmatch, int nsub, char* ans, unsigned long test)
    824. 

  824. {
    825. 

  825. 	int	i;
    826. 

  826. 

  827. 	for (; nmatch > nsub + 1; nmatch--)
    828. 

  828. 		if ((match[nmatch-1].rm_so != -1 || match[nmatch-1].rm_eo != -1) && (!(test & TEST_IGNORE_POSITION) || (match[nmatch-1].rm_so >= 0 && match[nmatch-1].rm_eo >= 0)))
    829. 

  829. 			break;
    830. 

  830. 	for (i = 0; i < nmatch; i++)
    831. 

  831. 	{
    832. 

  832. 		printf("(");
    833. 

  833. 		matchoffprint(match[i].rm_so);
    834. 

  834. 		printf(",");
    835. 

  835. 		matchoffprint(match[i].rm_eo);
    836. 

  836. 		printf(")");
    837. 

  837. 	}
    838. 

  838. 	if (!(test & (TEST_ACTUAL|TEST_BASELINE)))
    839. 

  839. 	{
    840. 

  840. 		if (ans)
    841. 

  841. 			printf(" expected: %s", ans);
    842. 

  842. 		printf("\n");
    843. 

  843. 	}
    844. 

  844. }
    845. 

  845. 

  846. static int
    847. 

  847. matchcheck(regmatch_t* match, int nmatch, int nsub, char* ans, char* re, char* s, int len, int flags, unsigned long test)
    848. 

  848. {
    849. 

  849. 	char*	p;
    850. 

  850. 	int	i;
    851. 

  851. 	int	m;
    852. 

  852. 	int	n;
    853. 

  853. 

  854. 	if (streq(ans, "OK"))
    855. 

  855. 		return test & (TEST_BASELINE|TEST_PASS|TEST_VERIFY);
    856. 

  856. 	for (i = 0, p = ans; i < nmatch && *p; i++)
    857. 

  857. 	{
    858. 

  858. 		if (*p == '{')
    859. 

  859. 		{
    860. 

  860. #ifdef REG_DISCIPLINE
    861. 

  861. 			char*	x;
    862. 

  862. 

  863. 			x = sfstruse(state.disc.sp);
    864. 

  864. 			if (strcmp(p, x))
    865. 

  865. 			{
    866. 

  866. 				if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    867. 

  867. 					return 0;
    868. 

  868. 				report("callout failed", NiL, re, s, len, NiL, flags, test);
    869. 

  869. 				quote(p, -1, test);
    870. 

  870. 				printf(" expected, ");
    871. 

  871. 				quote(x, -1, test);
    872. 

  872. 				printf(" returned\n");
    873. 

  873. 			}
    874. 

  874. #endif
    875. 

  875. 			break;
    876. 

  876. 		}
    877. 

  877. 		if (*p++ != '(')
    878. 

  878. 			bad("improper answer\n", re, s, -1, test);
    879. 

  879. 		if (*p == '?')
    880. 

  880. 		{
    881. 

  881. 			m = -1;
    882. 

  882. 			p++;
    883. 

  883. 		}
    884. 

  884. 		else
    885. 

  885. 			m = strtol(p, &p, 10);
    886. 

  886. 		if (*p++ != ',')
    887. 

  887. 			bad("improper answer\n", re, s, -1, test);
    888. 

  888. 		if (*p == '?')
    889. 

  889. 		{
    890. 

  890. 			n = -1;
    891. 

  891. 			p++;
    892. 

  892. 		}
    893. 

  893. 		else
    894. 

  894. 			n = strtol(p, &p, 10);
    895. 

  895. 		if (*p++ != ')')
    896. 

  896. 			bad("improper answer\n", re, s, -1, test);
    897. 

  897. 		if (m!=match[i].rm_so || n!=match[i].rm_eo)
    898. 

  898. 		{
    899. 

  899. 			if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)))
    900. 

  900. 			{
    901. 

  901. 				report("failed: match was", NiL, re, s, len, NiL, flags, test);
    902. 

  902. 				matchprint(match, nmatch, nsub, ans, test);
    903. 

  903. 			}
    904. 

  904. 			return 0;
    905. 

  905. 		}
    906. 

  906. 	}
    907. 

  907. 	for (; i < nmatch; i++)
    908. 

  908. 	{
    909. 

  909. 		if (match[i].rm_so!=-1 || match[i].rm_eo!=-1)
    910. 

  910. 		{
    911. 

  911. 			if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_VERIFY)))
    912. 

  912. 			{
    913. 

  913. 				if ((test & TEST_IGNORE_POSITION) && (match[i].rm_so<0 || match[i].rm_eo<0))
    914. 

  914. 				{
    915. 

  915. 					state.ignored++;
    916. 

  916. 					return 0;
    917. 

  917. 				}
    918. 

  918. 				if (!(test & TEST_SUMMARY))
    919. 

  919. 				{
    920. 

  920. 					report("failed: match was", NiL, re, s, len, NiL, flags, test);
    921. 

  921. 					matchprint(match, nmatch, nsub, ans, test);
    922. 

  922. 				}
    923. 

  923. 			}
    924. 

  924. 			return 0;
    925. 

  925. 		}
    926. 

  926. 	}
    927. 

  927. 	if (!(test & TEST_IGNORE_OVER) && match[nmatch].rm_so != state.NOMATCH.rm_so)
    928. 

  928. 	{
    929. 

  929. 		if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY)))
    930. 

  930. 		{
    931. 

  931. 			report("failed: overran match array", NiL, re, s, len, NiL, flags, test);
    932. 

  932. 			matchprint(match, nmatch + 1, nsub, NiL, test);
    933. 

  933. 		}
    934. 

  934. 		return 0;
    935. 

  935. 	}
    936. 

  936. 	return 1;
    937. 

  937. }
    938. 

  938. 

  939. static void
    940. 

  940. sigunblock(int s)
    941. 

  941. {
    942. 

  942. #ifdef SIG_SETMASK
    943. 

  943. 	int		op;
    944. 

  944. 	sigset_t	mask;
    945. 

  945. 

  946. 	sigemptyset(&mask);
    947. 

  947. 	if (s)
    948. 

  948. 	{
    949. 

  949. 		sigaddset(&mask, s);
    950. 

  950. 		op = SIG_UNBLOCK;
    951. 

  951. 	}
    952. 

  952. 	else op = SIG_SETMASK;
    953. 

  953. 	sigprocmask(op, &mask, NiL);
    954. 

  954. #else
    955. 

  955. #ifdef sigmask
    956. 

  956. 	sigsetmask(s ? (sigsetmask(0L) & ~sigmask(s)) : 0L);
    957. 

  957. #endif
    958. 

  958. #endif
    959. 

  959. }
    960. 

  960. 

  961. static void
    962. 

  962. gotcha(int sig)
    963. 

  963. {
    964. 

  964. 	int	ret;
    965. 

  965. 

  966. 	signal(sig, gotcha);
    967. 

  967. 	alarm(0);
    968. 

  968. 	state.signals++;
    969. 

  969. 	switch (sig)
    970. 

  970. 	{
    971. 

  971. 	case SIGALRM:
    972. 

  972. 		ret = REG_EHUNG;
    973. 

  973. 		break;
    974. 

  974. 	case SIGBUS:
    975. 

  975. 		ret = REG_EBUS;
    976. 

  976. 		break;
    977. 

  977. 	default:
    978. 

  978. 		ret = REG_EFAULT;
    979. 

  979. 		break;
    980. 

  980. 	}
    981. 

  981. 	sigunblock(sig);
    982. 

  982. 	longjmp(state.gotcha, ret);
    983. 

  983. }
    984. 

  984. 

  985. static char*
    986. 

  986. my_getline(FILE* fp)
    987. 

  987. {
    988. 

  988. 	static char	buf[32 * 1024];
    989. 

  989. 

  990. 	register char*	s = buf;
    991. 

  991. 	register char*	e = &buf[sizeof(buf)];
    992. 

  992. 	register char*	b;
    993. 

  993. 

  994. 	for (;;)
    995. 

  995. 	{
    996. 

  996. 		if (!(b = fgets(s, e - s, fp)))
    997. 

  997. 			return 0;
    998. 

  998. 		state.lineno++;
    999. 

  999. 		s += strlen(s);
    1000. 

  1000. 		if (s == b || *--s != '\n' || s == b || *(s - 1) != '\\')
    1001. 

  1001. 		{
    1002. 

  1002. 			*s = 0;
    1003. 

  1003. 			break;
    1004. 

  1004. 		}
    1005. 

  1005. 		s--;
    1006. 

  1006. 	}
    1007. 

  1007. 	return buf;
    1008. 

  1008. }
    1009. 

  1009. 

  1010. static unsigned long
    1011. 

  1011. note(unsigned long level, char* msg, unsigned long skip, unsigned long test)
    1012. 

  1012. {
    1013. 

  1013. 	if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY)) && !skip)
    1014. 

  1014. 	{
    1015. 

  1015. 		printf("NOTE\t");
    1016. 

  1016. 		if (msg)
    1017. 

  1017. 			printf("%s: ", msg);
    1018. 

  1018. 		printf("skipping lines %d", state.lineno);
    1019. 

  1019. 	}
    1020. 

  1020. 	return skip | level;
    1021. 

  1021. }
    1022. 

  1022. 

  1023. #define TABS(n)		&ts[7-((n)&7)]
    1024. 

  1024. 

  1025. static char		ts[] = "\t\t\t\t\t\t\t";
    1026. 

  1026. 

  1027. static unsigned long
    1028. 

  1028. extract(int* tabs, char* spec, char* re, char* s, char* ans, char* msg, char* accept, regmatch_t* match, int nmatch, int nsub, unsigned long skip, unsigned long level, unsigned long test)
    1029. 

  1029. {
    1030. 

  1030. 	if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_OK|TEST_PASS|TEST_SUMMARY))
    1031. 

  1031. 	{
    1032. 

  1032. 		state.extracted = 1;
    1033. 

  1033. 		if (test & TEST_OK)
    1034. 

  1034. 		{
    1035. 

  1035. 			state.passed++;
    1036. 

  1036. 			if ((test & TEST_VERIFY) && !(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY)))
    1037. 

  1037. 			{
    1038. 

  1038. 				if (msg && strcmp(msg, "EXPECTED"))
    1039. 

  1039. 					printf("NOTE\t%s\n", msg);
    1040. 

  1040. 				return skip;
    1041. 

  1041. 			}
    1042. 

  1042. 			test &= ~(TEST_PASS|TEST_QUERY);
    1043. 

  1043. 		}
    1044. 

  1044. 		if (test & (TEST_QUERY|TEST_VERIFY))
    1045. 

  1045. 		{
    1046. 

  1046. 			if (test & TEST_BASELINE)
    1047. 

  1047. 				test &= ~(TEST_BASELINE|TEST_PASS);
    1048. 

  1048. 			else
    1049. 

  1049. 				test |= TEST_PASS;
    1050. 

  1050. 			skip |= level;
    1051. 

  1051. 		}
    1052. 

  1052. 		if (!(test & TEST_OK))
    1053. 

  1053. 		{
    1054. 

  1054. 			if (test & TEST_UNSPECIFIED)
    1055. 

  1055. 				state.unspecified++;
    1056. 

  1056. 			else
    1057. 

  1057. 				state.errors++;
    1058. 

  1058. 		}
    1059. 

  1059. 		if (test & (TEST_PASS|TEST_SUMMARY))
    1060. 

  1060. 			return skip;
    1061. 

  1061. 		test &= ~TEST_DELIMIT;
    1062. 

  1062. 		printf("%s%s", spec, TABS(*tabs++));
    1063. 

  1063. 		if ((test & (TEST_BASELINE|TEST_SAME)) == (TEST_BASELINE|TEST_SAME))
    1064. 

  1064. 			printf("SAME");
    1065. 

  1065. 		else
    1066. 

  1066. 			quote(re, -1, test);
    1067. 

  1067. 		printf("%s", TABS(*tabs++));
    1068. 

  1068. 		quote(s, -1, test);
    1069. 

  1069. 		printf("%s", TABS(*tabs++));
    1070. 

  1070. 		if (!(test & (TEST_ACTUAL|TEST_BASELINE)) || (!accept && !match))
    1071. 

  1071. 			printf("%s", ans);
    1072. 

  1072. 		else if (accept)
    1073. 

  1073. 			printf("%s", accept);
    1074. 

  1074. 		else
    1075. 

  1075. 			matchprint(match, nmatch, nsub, NiL, test);
    1076. 

  1076. 		if (msg)
    1077. 

  1077. 			printf("%s%s", TABS(*tabs++), msg);
    1078. 

  1078. 		putchar('\n');
    1079. 

  1079. 	}
    1080. 

  1080. 	else if (test & TEST_QUERY)
    1081. 

  1081. 		skip = note(level, msg, skip, test);
    1082. 

  1082. 	else if (test & TEST_VERIFY)
    1083. 

  1083. 		state.extracted = 1;
    1084. 

  1084. 	return skip;
    1085. 

  1085. }
    1086. 

  1086. 

  1087. static int
    1088. 

  1088. catchfree(regex_t* preg, int flags, int* tabs, char* spec, char* re, char* s, char* ans, char* msg, char* accept, regmatch_t* match, int nmatch, int nsub, unsigned long skip, unsigned long level, unsigned long test)
    1089. 

  1089. {
    1090. 

  1090. 	int	eret;
    1091. 

  1091. 

  1092. 	if (!(test & TEST_CATCH))
    1093. 

  1093. 	{
    1094. 

  1094. 		regfree(preg);
    1095. 

  1095. 		eret = 0;
    1096. 

  1096. 	}
    1097. 

  1097. 	else if (!(eret = setjmp(state.gotcha)))
    1098. 

  1098. 	{
    1099. 

  1099. 		alarm(HUNG);
    1100. 

  1100. 		regfree(preg);
    1101. 

  1101. 		alarm(0);
    1102. 

  1102. 	}
    1103. 

  1103. 	else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1104. 

  1104. 		extract(tabs, spec, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test);
    1105. 

  1105. 	else
    1106. 

  1106. 	{
    1107. 

  1107. 		report("failed", "regfree", re, NiL, -1, msg, flags, test);
    1108. 

  1108. 		error(preg, eret);
    1109. 

  1109. 	}
    1110. 

  1110. 	return eret;
    1111. 

  1111. }
    1112. 

  1112. 

  1113. int
    1114. 

  1114. main(int argc, char** argv)
    1115. 

  1115. {
    1116. 

  1116. 	int		flags;
    1117. 

  1117. 	int		cflags;
    1118. 

  1118. 	int		eflags;
    1119. 

  1119. 	int		nmatch;
    1120. 

  1120. 	int		nexec;
    1121. 

  1121. 	int		nstr;
    1122. 

  1122. 	int		cret;
    1123. 

  1123. 	int		eret;
    1124. 

  1124. 	int		nsub;
    1125. 

  1125. 	int		i;
    1126. 

  1126. 	int		j;
    1127. 

  1127. 	int		expected;
    1128. 

  1128. 	int		got;
    1129. 

  1129. 	int		locale;
    1130. 

  1130. 	int		subunitlen = 0;
    1131. 

  1131. 	int		testno;
    1132. 

  1132. 	unsigned long	level;
    1133. 

  1133. 	unsigned long	skip;
    1134. 

  1134. 	char*		p;
    1135. 

  1135. 	char*		line;
    1136. 

  1136. 	char*		spec;
    1137. 

  1137. 	char*		re;
    1138. 

  1138. 	char*		s;
    1139. 

  1139. 	char*		ans;
    1140. 

  1140. 	char*		msg;
    1141. 

  1141. 	char*		fun;
    1142. 

  1142. 	char*		ppat = NULL;
    1143. 

  1143. 	char*		subunit = NULL;
    1144. 

  1144. 	char*		version;
    1145. 

  1145. 	char*		field[6];
    1146. 

  1146. 	char*		delim[6];
    1147. 

  1147. 	FILE*		fp;
    1148. 

  1148. 	int		tabs[6];
    1149. 

  1149. 	char		unit[64];
    1150. 

  1150. 	regmatch_t	match[100];
    1151. 

  1151. 	regex_t		preg;
    1152. 

  1152. 

  1153. 	static char	pat[32 * 1024];
    1154. 

  1154. 

  1155. 	int		nonosub = REG_NOSUB == 0;
    1156. 

  1156. 	int		nonexec = 0;
    1157. 

  1157. 

  1158. 	unsigned long	test = 0;
    1159. 

  1159. 

  1160. 	static char*	filter[] = { "-", 0 };
    1161. 

  1161. 

  1162. 	state.NOMATCH.rm_so = state.NOMATCH.rm_eo = -2;
    1163. 

  1163. 	p = unit;
    1164. 

  1164. 	version = (char*)id + 10;
    1165. 

  1165. 	while (p < &unit[sizeof(unit)-1] && (*p = *version++) && !isspace(*p))
    1166. 

  1166. 		p++;
    1167. 

  1167. 	*p = 0;
    1168. 

  1168. 	while ((p = *++argv) && *p == '-')
    1169. 

  1169. 		for (;;)
    1170. 

  1170. 		{
    1171. 

  1171. 			switch (*++p)
    1172. 

  1172. 			{
    1173. 

  1173. 			case 0:
    1174. 

  1174. 				break;
    1175. 

  1175. 			case 'c':
    1176. 

  1176. 				test |= TEST_CATCH;
    1177. 

  1177. 				continue;
    1178. 

  1178. 			case 'e':
    1179. 

  1179. 				test |= TEST_IGNORE_ERROR;
    1180. 

  1180. 				continue;
    1181. 

  1181. 			case 'h':
    1182. 

  1182. 			case '?':
    1183. 

  1183. 				help(0);
    1184. 

  1184. 				return 2;
    1185. 

  1185. 			case '-':
    1186. 

  1186. 				help(p[1] == 'h');
    1187. 

  1187. 				return 2;
    1188. 

  1188. 			case 'n':
    1189. 

  1189. 				nonexec = 1;
    1190. 

  1190. 				continue;
    1191. 

  1191. 			case 'o':
    1192. 

  1192. 				test |= TEST_IGNORE_OVER;
    1193. 

  1193. 				continue;
    1194. 

  1194. 			case 'p':
    1195. 

  1195. 				test |= TEST_IGNORE_POSITION;
    1196. 

  1196. 				continue;
    1197. 

  1197. 			case 's':
    1198. 

  1198. #ifdef REG_DISCIPLINE
    1199. 

  1199. 				if (!(state.stack = stkalloc(stkstd, 0)))
    1200. 

  1200. 					fprintf(stderr, "%s: out of space [stack]", unit);
    1201. 

  1201. 				state.disc.disc.re_resizef = resizef;
    1202. 

  1202. 				state.disc.disc.re_resizehandle = (void*)stkstd;
    1203. 

  1203. #endif
    1204. 

  1204. 				continue;
    1205. 

  1205. 			case 'x':
    1206. 

  1206. 				nonosub = 1;
    1207. 

  1207. 				continue;
    1208. 

  1208. 			case 'v':
    1209. 

  1209. 				test |= TEST_VERBOSE;
    1210. 

  1210. 				continue;
    1211. 

  1211. 			case 'A':
    1212. 

  1212. 				test |= TEST_ACTUAL;
    1213. 

  1213. 				continue;
    1214. 

  1214. 			case 'B':
    1215. 

  1215. 				test |= TEST_BASELINE;
    1216. 

  1216. 				continue;
    1217. 

  1217. 			case 'F':
    1218. 

  1218. 				test |= TEST_FAIL;
    1219. 

  1219. 				continue;
    1220. 

  1220. 			case 'P':
    1221. 

  1221. 				test |= TEST_PASS;
    1222. 

  1222. 				continue;
    1223. 

  1223. 			case 'S':
    1224. 

  1224. 				test |= TEST_SUMMARY;
    1225. 

  1225. 				continue;
    1226. 

  1226. 			default:
    1227. 

  1227. 				fprintf(stderr, "%s: %c: invalid option\n", unit, *p);
    1228. 

  1228. 				return 2;
    1229. 

  1229. 			}
    1230. 

  1230. 			break;
    1231. 

  1231. 		}
    1232. 

  1232. 	if (!*argv)
    1233. 

  1233. 		argv = filter;
    1234. 

  1234. 	locale = 0;
    1235. 

  1235. 	while ((state.file = *argv++))
    1236. 

  1236. 	{
    1237. 

  1237. 		if (streq(state.file, "-") || streq(state.file, "/dev/stdin") || streq(state.file, "/dev/fd/0"))
    1238. 

  1238. 		{
    1239. 

  1239. 			state.file = 0;
    1240. 

  1240. 			fp = stdin;
    1241. 

  1241. 		}
    1242. 

  1242. 		else if (!(fp = fopen(state.file, "r")))
    1243. 

  1243. 		{
    1244. 

  1244. 			fprintf(stderr, "%s: %s: cannot read\n", unit, state.file);
    1245. 

  1245. 			return 2;
    1246. 

  1246. 		}
    1247. 

  1247. 		testno = state.errors = state.ignored = state.lineno = state.passed =
    1248. 

  1248. 		state.signals = state.unspecified = state.warnings = 0;
    1249. 

  1249. 		skip = 0;
    1250. 

  1250. 		level = 1;
    1251. 

  1251. 		if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY)))
    1252. 

  1252. 		{
    1253. 

  1253. 			printf("TEST\t%s ", unit);
    1254. 

  1254. 			if ((s = state.file))
    1255. 

  1255. 			{
    1256. 

  1256. 				subunit = p = 0;
    1257. 

  1257. 				for (;;)
    1258. 

  1258. 				{
    1259. 

  1259. 					switch (*s++)
    1260. 

  1260. 					{
    1261. 

  1261. 					case 0:
    1262. 

  1262. 						break;
    1263. 

  1263. 					case '/':
    1264. 

  1264. 						subunit = s;
    1265. 

  1265. 						continue;
    1266. 

  1266. 					case '.':
    1267. 

  1267. 						p = s - 1;
    1268. 

  1268. 						continue;
    1269. 

  1269. 					default:
    1270. 

  1270. 						continue;
    1271. 

  1271. 					}
    1272. 

  1272. 					break;
    1273. 

  1273. 				}
    1274. 

  1274. 				if (!subunit)
    1275. 

  1275. 					subunit = state.file;
    1276. 

  1276. 				if (p < subunit)
    1277. 

  1277. 					p = s - 1;
    1278. 

  1278. 				subunitlen = p - subunit;
    1279. 

  1279. 				printf("%-.*s ", subunitlen, subunit);
    1280. 

  1280. 			}
    1281. 

  1281. 			else
    1282. 

  1282. 				subunit = 0;
    1283. 

  1283. 			for (s = version; *s && (*s != ' ' || *(s + 1) != '$'); s++)
    1284. 

  1284. 				putchar(*s);
    1285. 

  1285. 			if (test & TEST_CATCH)
    1286. 

  1286. 				printf(", catch");
    1287. 

  1287. 			if (test & TEST_IGNORE_ERROR)
    1288. 

  1288. 				printf(", ignore error code mismatches");
    1289. 

  1289. 			if (test & TEST_IGNORE_POSITION)
    1290. 

  1290. 				printf(", ignore negative position mismatches");
    1291. 

  1291. #ifdef REG_DISCIPLINE
    1292. 

  1292. 			if (state.stack)
    1293. 

  1293. 				printf(", stack");
    1294. 

  1294. #endif
    1295. 

  1295. 			if (test & TEST_VERBOSE)
    1296. 

  1296. 				printf(", verbose");
    1297. 

  1297. 			printf("\n");
    1298. 

  1298. #ifdef REG_VERSIONID
    1299. 

  1299. 			if (regerror(REG_VERSIONID, NiL, pat, sizeof(pat)) > 0)
    1300. 

  1300. 				s = pat;
    1301. 

  1301. 			else
    1302. 

  1302. #endif
    1303. 

  1303. #ifdef REG_TEST_VERSION
    1304. 

  1304. 			s = REG_TEST_VERSION;
    1305. 

  1305. #else
    1306. 

  1306. 			s = "regex";
    1307. 

  1307. #endif
    1308. 

  1308. 			printf("NOTE\t%s\n", s);
    1309. 

  1309. 			if (elementsof(unsupported) > 1)
    1310. 

  1310. 			{
    1311. 

  1311. #if (REG_TEST_DEFAULT & (REG_AUGMENTED|REG_EXTENDED|REG_SHELL)) || !defined(REG_EXTENDED)
    1312. 

  1312. 				i = 0;
    1313. 

  1313. #else
    1314. 

  1314. 				i = REG_EXTENDED != 0;
    1315. 

  1315. #endif
    1316. 

  1316. 				for (got = 0; i < elementsof(unsupported) - 1; i++)
    1317. 

  1317. 				{
    1318. 

  1318. 					if (!got)
    1319. 

  1319. 					{
    1320. 

  1320. 						got = 1;
    1321. 

  1321. 						printf("NOTE\tunsupported: %s", unsupported[i]);
    1322. 

  1322. 					}
    1323. 

  1323. 					else
    1324. 

  1324. 						printf(",%s", unsupported[i]);
    1325. 

  1325. 				}
    1326. 

  1326. 				if (got)
    1327. 

  1327. 					printf("\n");
    1328. 

  1328. 			}
    1329. 

  1329. 		}
    1330. 

  1330. #ifdef REG_DISCIPLINE
    1331. 

  1331. 		state.disc.disc.re_version = REG_VERSION;
    1332. 

  1332. 		state.disc.disc.re_compf = compf;
    1333. 

  1333. 		state.disc.disc.re_execf = execf;
    1334. 

  1334. 		if (!(state.disc.sp = sfstropen()))
    1335. 

  1335. 			bad("out of space [discipline string stream]\n", NiL, NiL, 0, 0);
    1336. 

  1336. 		preg.re_disc = &state.disc.disc;
    1337. 

  1337. #endif
    1338. 

  1338. 		if (test & TEST_CATCH)
    1339. 

  1339. 		{
    1340. 

  1340. 			signal(SIGALRM, gotcha);
    1341. 

  1341. 			signal(SIGBUS, gotcha);
    1342. 

  1342. 			signal(SIGSEGV, gotcha);
    1343. 

  1343. 		}
    1344. 

  1344. 		while ((p = my_getline(fp)))
    1345. 

  1345. 		{
    1346. 

  1346. 

  1347. 		/* parse: */
    1348. 

  1348. 

  1349. 			line = p;
    1350. 

  1350. 			if (*p == ':' && !isspace(*(p + 1)))
    1351. 

  1351. 			{
    1352. 

  1352. 				while (*++p && *p != ':');
    1353. 

  1353. 				if (!*p++)
    1354. 

  1354. 				{
    1355. 

  1355. 					if (test & TEST_BASELINE)
    1356. 

  1356. 						printf("%s\n", line);
    1357. 

  1357. 					continue;
    1358. 

  1358. 				}
    1359. 

  1359. 			}
    1360. 

  1360. 			while (isspace(*p))
    1361. 

  1361. 				p++;
    1362. 

  1362. 			if (*p == 0 || *p == '#' || *p == 'T')
    1363. 

  1363. 			{
    1364. 

  1364. 				if (test & TEST_BASELINE)
    1365. 

  1365. 					printf("%s\n", line);
    1366. 

  1366. 				continue;
    1367. 

  1367. 			}
    1368. 

  1368. 			if (*p == ':' || *p == 'N')
    1369. 

  1369. 			{
    1370. 

  1370. 				if (test & TEST_BASELINE)
    1371. 

  1371. 					printf("%s\n", line);
    1372. 

  1372. 				else if (!(test & (TEST_ACTUAL|TEST_FAIL|TEST_PASS|TEST_SUMMARY)))
    1373. 

  1373. 				{
    1374. 

  1374. 					while (*++p && !isspace(*p));
    1375. 

  1375. 					while (isspace(*p))
    1376. 

  1376. 						p++;
    1377. 

  1377. 					printf("NOTE	%s\n", p);
    1378. 

  1378. 				}
    1379. 

  1379. 				continue;
    1380. 

  1380. 			}
    1381. 

  1381. 			j = 0;
    1382. 

  1382. 			i = 0;
    1383. 

  1383. 			field[i++] = p;
    1384. 

  1384. 			for (;;)
    1385. 

  1385. 			{
    1386. 

  1386. 				switch (*p++)
    1387. 

  1387. 				{
    1388. 

  1388. 				case 0:
    1389. 

  1389. 					p--;
    1390. 

  1390. 					j = 0;
    1391. 

  1391. 					goto checkfield;
    1392. 

  1392. 				case '\t':
    1393. 

  1393. 					*(delim[i] = p - 1) = 0;
    1394. 

  1394. 					j = 1;
    1395. 

  1395. 				checkfield:
    1396. 

  1396. 					s = field[i - 1];
    1397. 

  1397. 					if (streq(s, "NIL"))
    1398. 

  1398. 						field[i - 1] = 0;
    1399. 

  1399. 					else if (streq(s, "NULL"))
    1400. 

  1400. 						*s = 0;
    1401. 

  1401. 					while (*p == '\t')
    1402. 

  1402. 					{
    1403. 

  1403. 						p++;
    1404. 

  1404. 						j++;
    1405. 

  1405. 					}
    1406. 

  1406. 					tabs[i - 1] = j;
    1407. 

  1407. 					if (!*p)
    1408. 

  1408. 						break;
    1409. 

  1409. 					if (i >= elementsof(field))
    1410. 

  1410. 						bad("too many fields\n", NiL, NiL, 0, 0);
    1411. 

  1411. 					field[i++] = p;
    1412. 

  1412. 					/*FALLTHROUGH*/
    1413. 

  1413. 				default:
    1414. 

  1414. 					continue;
    1415. 

  1415. 				}
    1416. 

  1416. 				break;
    1417. 

  1417. 			}
    1418. 

  1418. 			if (!(spec = field[0]))
    1419. 

  1419. 				bad("NIL spec\n", NiL, NiL, 0, 0);
    1420. 

  1420. 

  1421. 		/* interpret: */
    1422. 

  1422. 

  1423. 			cflags = REG_TEST_DEFAULT;
    1424. 

  1424. 			eflags = REG_EXEC_DEFAULT;
    1425. 

  1425. 			test &= TEST_GLOBAL;
    1426. 

  1426. 			state.extracted = 0;
    1427. 

  1427. 			nmatch = 20;
    1428. 

  1428. 			nsub = -1;
    1429. 

  1429. 			for (p = spec; *p; p++)
    1430. 

  1430. 			{
    1431. 

  1431. 				if (isdigit(*p))
    1432. 

  1432. 				{
    1433. 

  1433. 					nmatch = strtol(p, &p, 10);
    1434. 

  1434. 					if (nmatch >= elementsof(match))
    1435. 

  1435. 						bad("nmatch must be < 100\n", NiL, NiL, 0, 0);
    1436. 

  1436. 					p--;
    1437. 

  1437. 					continue;
    1438. 

  1438. 				}
    1439. 

  1439. 				switch (*p)
    1440. 

  1440. 				{
    1441. 

  1441. 				case 'A':
    1442. 

  1442. 					test |= TEST_ARE;
    1443. 

  1443. 					continue;
    1444. 

  1444. 				case 'B':
    1445. 

  1445. 					test |= TEST_BRE;
    1446. 

  1446. 					continue;
    1447. 

  1447. 				case 'C':
    1448. 

  1448. 					if (!(test & TEST_QUERY) && !(skip & level))
    1449. 

  1449. 						bad("locale must be nested\n", NiL, NiL, 0, 0);
    1450. 

  1450. 					test &= ~TEST_QUERY;
    1451. 

  1451. 					if (locale)
    1452. 

  1452. 						bad("locale nesting not supported\n", NiL, NiL, 0, 0);
    1453. 

  1453. 					if (i != 2)
    1454. 

  1454. 						bad("locale field expected\n", NiL, NiL, 0, 0);
    1455. 

  1455. 					if (!(skip & level))
    1456. 

  1456. 					{
    1457. 

  1457. #if defined(LC_COLLATE) && defined(LC_CTYPE)
    1458. 

  1458. 						s = field[1];
    1459. 

  1459. 						if (!s || streq(s, "POSIX"))
    1460. 

  1460. 							s = "C";
    1461. 

  1461. 						if (!(ans = setlocale(LC_COLLATE, s)) || streq(ans, "C") || streq(ans, "POSIX") || !(ans = setlocale(LC_CTYPE, s)) || streq(ans, "C") || streq(ans, "POSIX"))
    1462. 

  1462. 							skip = note(level, s, skip, test);
    1463. 

  1463. 						else
    1464. 

  1464. 						{
    1465. 

  1465. 							if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY)))
    1466. 

  1466. 								printf("NOTE	\"%s\" locale\n", s);
    1467. 

  1467. 							locale = level;
    1468. 

  1468. 						}
    1469. 

  1469. #else
    1470. 

  1470. 						skip = note(level, skip, test, "locales not supported");
    1471. 

  1471. #endif
    1472. 

  1472. 					}
    1473. 

  1473. 					cflags = NOTEST;
    1474. 

  1474. 					continue;
    1475. 

  1475. 				case 'E':
    1476. 

  1476. 					test |= TEST_ERE;
    1477. 

  1477. 					continue;
    1478. 

  1478. 				case 'K':
    1479. 

  1479. 					test |= TEST_KRE;
    1480. 

  1480. 					continue;
    1481. 

  1481. 				case 'L':
    1482. 

  1482. 					test |= TEST_LRE;
    1483. 

  1483. 					continue;
    1484. 

  1484. 				case 'S':
    1485. 

  1485. 					test |= TEST_SRE;
    1486. 

  1486. 					continue;
    1487. 

  1487. 

  1488. 				case 'a':
    1489. 

  1489. 					cflags |= REG_LEFT|REG_RIGHT;
    1490. 

  1490. 					continue;
    1491. 

  1491. 				case 'b':
    1492. 

  1492. 					eflags |= REG_NOTBOL;
    1493. 

  1493. 					continue;
    1494. 

  1494. 				case 'c':
    1495. 

  1495. 					cflags |= REG_COMMENT;
    1496. 

  1496. 					continue;
    1497. 

  1497. 				case 'd':
    1498. 

  1498. 					cflags |= REG_SHELL_DOT;
    1499. 

  1499. 					continue;
    1500. 

  1500. 				case 'e':
    1501. 

  1501. 					eflags |= REG_NOTEOL;
    1502. 

  1502. 					continue;
    1503. 

  1503. 				case 'f':
    1504. 

  1504. 					cflags |= REG_MULTIPLE;
    1505. 

  1505. 					continue;
    1506. 

  1506. 				case 'g':
    1507. 

  1507. 					cflags |= NOTEST;
    1508. 

  1508. 					continue;
    1509. 

  1509. 				case 'h':
    1510. 

  1510. 					cflags |= REG_MULTIREF;
    1511. 

  1511. 					continue;
    1512. 

  1512. 				case 'i':
    1513. 

  1513. 					cflags |= REG_ICASE;
    1514. 

  1514. 					continue;
    1515. 

  1515. 				case 'j':
    1516. 

  1516. 					cflags |= REG_SPAN;
    1517. 

  1517. 					continue;
    1518. 

  1518. 				case 'k':
    1519. 

  1519. 					cflags |= REG_ESCAPE;
    1520. 

  1520. 					continue;
    1521. 

  1521. 				case 'l':
    1522. 

  1522. 					cflags |= REG_LEFT;
    1523. 

  1523. 					continue;
    1524. 

  1524. 				case 'm':
    1525. 

  1525. 					cflags |= REG_MINIMAL;
    1526. 

  1526. 					continue;
    1527. 

  1527. 				case 'n':
    1528. 

  1528. 					cflags |= REG_NEWLINE;
    1529. 

  1529. 					continue;
    1530. 

  1530. 				case 'o':
    1531. 

  1531. 					cflags |= REG_SHELL_GROUP;
    1532. 

  1532. 					continue;
    1533. 

  1533. 				case 'p':
    1534. 

  1534. 					cflags |= REG_SHELL_PATH;
    1535. 

  1535. 					continue;
    1536. 

  1536. 				case 'q':
    1537. 

  1537. 					cflags |= REG_DELIMITED;
    1538. 

  1538. 					continue;
    1539. 

  1539. 				case 'r':
    1540. 

  1540. 					cflags |= REG_RIGHT;
    1541. 

  1541. 					continue;
    1542. 

  1542. 				case 's':
    1543. 

  1543. 					cflags |= REG_SHELL_ESCAPED;
    1544. 

  1544. 					continue;
    1545. 

  1545. 				case 't':
    1546. 

  1546. 					cflags |= REG_MUSTDELIM;
    1547. 

  1547. 					continue;
    1548. 

  1548. 				case 'u':
    1549. 

  1549. 					test |= TEST_UNSPECIFIED;
    1550. 

  1550. 					continue;
    1551. 

  1551. 				case 'w':
    1552. 

  1552. 					cflags |= REG_NOSUB;
    1553. 

  1553. 					continue;
    1554. 

  1554. 				case 'x':
    1555. 

  1555. 					if (REG_LENIENT)
    1556. 

  1556. 						cflags |= REG_LENIENT;
    1557. 

  1557. 					else
    1558. 

  1558. 						test |= TEST_LENIENT;
    1559. 

  1559. 					continue;
    1560. 

  1560. 				case 'y':
    1561. 

  1561. 					eflags |= REG_LEFT;
    1562. 

  1562. 					continue;
    1563. 

  1563. 				case 'z':
    1564. 

  1564. 					cflags |= REG_NULL;
    1565. 

  1565. 					continue;
    1566. 

  1566. 

  1567. 				case '$':
    1568. 

  1568. 					test |= TEST_EXPAND;
    1569. 

  1569. 					continue;
    1570. 

  1570. 

  1571. 				case '/':
    1572. 

  1572. 					test |= TEST_SUB;
    1573. 

  1573. 					continue;
    1574. 

  1574. 

  1575. 				case '?':
    1576. 

  1576. 					test |= TEST_VERIFY;
    1577. 

  1577. 					test &= ~(TEST_AND|TEST_OR);
    1578. 

  1578. 					state.verify = state.passed;
    1579. 

  1579. 					continue;
    1580. 

  1580. 				case '&':
    1581. 

  1581. 					test |= TEST_VERIFY|TEST_AND;
    1582. 

  1582. 					test &= ~TEST_OR;
    1583. 

  1583. 					continue;
    1584. 

  1584. 				case '|':
    1585. 

  1585. 					test |= TEST_VERIFY|TEST_OR;
    1586. 

  1586. 					test &= ~TEST_AND;
    1587. 

  1587. 					continue;
    1588. 

  1588. 				case ';':
    1589. 

  1589. 					test |= TEST_OR;
    1590. 

  1590. 					test &= ~TEST_AND;
    1591. 

  1591. 					continue;
    1592. 

  1592. 

  1593. 				case '{':
    1594. 

  1594. 					level <<= 1;
    1595. 

  1595. 					if (skip & (level >> 1))
    1596. 

  1596. 					{
    1597. 

  1597. 						skip |= level;
    1598. 

  1598. 						cflags = NOTEST;
    1599. 

  1599. 					}
    1600. 

  1600. 					else
    1601. 

  1601. 					{
    1602. 

  1602. 						skip &= ~level;
    1603. 

  1603. 						test |= TEST_QUERY;
    1604. 

  1604. 					}
    1605. 

  1605. 					continue;
    1606. 

  1606. 				case '}':
    1607. 

  1607. 					if (level == 1)
    1608. 

  1608. 						bad("invalid {...} nesting\n", NiL, NiL, 0, 0);
    1609. 

  1609. 					if ((skip & level) && !(skip & (level>>1)))
    1610. 

  1610. 					{
    1611. 

  1611. 						if (!(test & (TEST_BASELINE|TEST_SUMMARY)))
    1612. 

  1612. 						{
    1613. 

  1613. 							if (test & (TEST_ACTUAL|TEST_FAIL))
    1614. 

  1614. 								printf("}\n");
    1615. 

  1615. 							else if (!(test & TEST_PASS))
    1616. 

  1616. 								printf("-%d\n", state.lineno);
    1617. 

  1617. 						}
    1618. 

  1618. 					}
    1619. 

  1619. #if defined(LC_COLLATE) && defined(LC_CTYPE)
    1620. 

  1620. 					else if (locale & level)
    1621. 

  1621. 					{
    1622. 

  1622. 						locale = 0;
    1623. 

  1623. 						if (!(skip & level))
    1624. 

  1624. 						{
    1625. 

  1625. 							s = "C";
    1626. 

  1626. 							setlocale(LC_COLLATE, s);
    1627. 

  1627. 							setlocale(LC_CTYPE, s);
    1628. 

  1628. 							if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_SUMMARY)))
    1629. 

  1629. 								printf("NOTE	\"%s\" locale\n", s);
    1630. 

  1630. 							else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_PASS))
    1631. 

  1631. 								printf("}\n");
    1632. 

  1632. 						}
    1633. 

  1633. 						else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL))
    1634. 

  1634. 							printf("}\n");
    1635. 

  1635. 					}
    1636. 

  1636. #endif
    1637. 

  1637. 					level >>= 1;
    1638. 

  1638. 					cflags = NOTEST;
    1639. 

  1639. 					continue;
    1640. 

  1640. 

  1641. 				default:
    1642. 

  1642. 					bad("bad spec\n", spec, NiL, 0, test);
    1643. 

  1643. 					break;
    1644. 

  1644. 

  1645. 				}
    1646. 

  1646. 				break;
    1647. 

  1647. 			}
    1648. 

  1648. 			if ((cflags|eflags) == NOTEST || ((skip & level) && (test & TEST_BASELINE)))
    1649. 

  1649. 			{
    1650. 

  1650. 				if (test & TEST_BASELINE)
    1651. 

  1651. 				{
    1652. 

  1652. 					while (i > 1)
    1653. 

  1653. 						*delim[--i] = '\t';
    1654. 

  1654. 					printf("%s\n", line);
    1655. 

  1655. 				}
    1656. 

  1656. 				continue;
    1657. 

  1657. 			}
    1658. 

  1658. 			if (test & TEST_OR)
    1659. 

  1659. 			{
    1660. 

  1660. 				if (!(test & TEST_VERIFY))
    1661. 

  1661. 				{
    1662. 

  1662. 					test &= ~TEST_OR;
    1663. 

  1663. 					if (state.passed == state.verify && i > 1)
    1664. 

  1664. 						printf("NOTE\t%s\n", field[1]);
    1665. 

  1665. 					continue;
    1666. 

  1666. 				}
    1667. 

  1667. 				else if (state.passed > state.verify)
    1668. 

  1668. 					continue;
    1669. 

  1669. 			}
    1670. 

  1670. 			else if (test & TEST_AND)
    1671. 

  1671. 			{
    1672. 

  1672. 				if (state.passed == state.verify)
    1673. 

  1673. 					continue;
    1674. 

  1674. 				state.passed = state.verify;
    1675. 

  1675. 			}
    1676. 

  1676. 			if (i < 4)
    1677. 

  1677. 				bad("too few fields\n", NiL, NiL, 0, test);
    1678. 

  1678. 			while (i < elementsof(field))
    1679. 

  1679. 				field[i++] = 0;
    1680. 

  1680. 			if ((re = field[1]))
    1681. 

  1681. 			{
    1682. 

  1682. 				if (streq(re, "SAME"))
    1683. 

  1683. 				{
    1684. 

  1684. 					re = ppat;
    1685. 

  1685. 					test |= TEST_SAME;
    1686. 

  1686. 				}
    1687. 

  1687. 				else
    1688. 

  1688. 				{
    1689. 

  1689. 					if (test & TEST_EXPAND)
    1690. 

  1690. 						escape(re);
    1691. 

  1691. 					strcpy(ppat = pat, re);
    1692. 

  1692. 				}
    1693. 

  1693. 			}
    1694. 

  1694. 			else
    1695. 

  1695. 				ppat = 0;
    1696. 

  1696. 			nstr = -1;
    1697. 

  1697. 			if ((s = field[2]) && (test & TEST_EXPAND))
    1698. 

  1698. 			{
    1699. 

  1699. 				nstr = escape(s);
    1700. 

  1700. #if _REG_nexec
    1701. 

  1701. 				if (nstr != strlen(s))
    1702. 

  1702. 					nexec = nstr;
    1703. 

  1703. #endif
    1704. 

  1704. 			}
    1705. 

  1705. 			if (!(ans = field[3]))
    1706. 

  1706. 				bad("NIL answer\n", NiL, NiL, 0, test);
    1707. 

  1707. 			msg = field[4];
    1708. 

  1708. 			fflush(stdout);
    1709. 

  1709. 			if (test & TEST_SUB)
    1710. 

  1710. #if _REG_subcomp
    1711. 

  1711. 				cflags |= REG_DELIMITED;
    1712. 

  1712. #else
    1713. 

  1713. 				continue;
    1714. 

  1714. #endif
    1715. 

  1715. 

  1716. 		compile:
    1717. 

  1717. 

  1718. 			if (state.extracted || (skip & level))
    1719. 

  1719. 				continue;
    1720. 

  1720. #if !(REG_TEST_DEFAULT & (REG_AUGMENTED|REG_EXTENDED|REG_SHELL))
    1721. 

  1721. #ifdef REG_EXTENDED
    1722. 

  1722. 			if (REG_EXTENDED != 0 && (test & TEST_BRE))
    1723. 

  1723. #else
    1724. 

  1724. 			if (test & TEST_BRE)
    1725. 

  1725. #endif
    1726. 

  1726. 			{
    1727. 

  1727. 				test &= ~TEST_BRE;
    1728. 

  1728. 				flags = cflags;
    1729. 

  1729. 				state.which = "BRE";
    1730. 

  1730. 			}
    1731. 

  1731. 			else
    1732. 

  1732. #endif
    1733. 

  1733. #ifdef REG_EXTENDED
    1734. 

  1734. 			if (test & TEST_ERE)
    1735. 

  1735. 			{
    1736. 

  1736. 				test &= ~TEST_ERE;
    1737. 

  1737. 				flags = cflags | REG_EXTENDED;
    1738. 

  1738. 				state.which = "ERE";
    1739. 

  1739. 			}
    1740. 

  1740. 			else
    1741. 

  1741. #endif
    1742. 

  1742. #ifdef REG_AUGMENTED
    1743. 

  1743. 			if (test & TEST_ARE)
    1744. 

  1744. 			{
    1745. 

  1745. 				test &= ~TEST_ARE;
    1746. 

  1746. 				flags = cflags | REG_AUGMENTED;
    1747. 

  1747. 				state.which = "ARE";
    1748. 

  1748. 			}
    1749. 

  1749. 			else
    1750. 

  1750. #endif
    1751. 

  1751. #ifdef REG_LITERAL
    1752. 

  1752. 			if (test & TEST_LRE)
    1753. 

  1753. 			{
    1754. 

  1754. 				test &= ~TEST_LRE;
    1755. 

  1755. 				flags = cflags | REG_LITERAL;
    1756. 

  1756. 				state.which = "LRE";
    1757. 

  1757. 			}
    1758. 

  1758. 			else
    1759. 

  1759. #endif
    1760. 

  1760. #ifdef REG_SHELL
    1761. 

  1761. 			if (test & TEST_SRE)
    1762. 

  1762. 			{
    1763. 

  1763. 				test &= ~TEST_SRE;
    1764. 

  1764. 				flags = cflags | REG_SHELL;
    1765. 

  1765. 				state.which = "SRE";
    1766. 

  1766. 			}
    1767. 

  1767. 			else
    1768. 

  1768. #ifdef REG_AUGMENTED
    1769. 

  1769. 			if (test & TEST_KRE)
    1770. 

  1770. 			{
    1771. 

  1771. 				test &= ~TEST_KRE;
    1772. 

  1772. 				flags = cflags | REG_SHELL | REG_AUGMENTED;
    1773. 

  1773. 				state.which = "KRE";
    1774. 

  1774. 			}
    1775. 

  1775. 			else
    1776. 

  1776. #endif
    1777. 

  1777. #endif
    1778. 

  1778. 			{
    1779. 

  1779. 				if (test & (TEST_BASELINE|TEST_PASS|TEST_VERIFY))
    1780. 

  1780. 					extract(tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test|TEST_OK);
    1781. 

  1781. 				continue;
    1782. 

  1782. 			}
    1783. 

  1783. 			if ((test & (TEST_QUERY|TEST_VERBOSE|TEST_VERIFY)) == TEST_VERBOSE)
    1784. 

  1784. 			{
    1785. 

  1785. 				printf("test %-3d %s ", state.lineno, state.which);
    1786. 

  1786. 				quote(re, -1, test|TEST_DELIMIT);
    1787. 

  1787. 				printf(" ");
    1788. 

  1788. 				quote(s, nstr, test|TEST_DELIMIT);
    1789. 

  1789. 				printf("\n");
    1790. 

  1790. 			}
    1791. 

  1791. 

  1792. 		nosub:
    1793. 

  1793. 			fun = "regcomp";
    1794. 

  1794. #if _REG_nexec
    1795. 

  1795. 			if (nstr >= 0 && nstr != strlen(s))
    1796. 

  1796. 				nexec = nstr;
    1797. 

  1797. 

  1798. 			else
    1799. 

  1799. #endif
    1800. 

  1800. 				nexec = -1;
    1801. 

  1801. 			if (state.extracted || (skip & level))
    1802. 

  1802. 				continue;
    1803. 

  1803. 			if (!(test & TEST_QUERY))
    1804. 

  1804. 				testno++;
    1805. 

  1805. #ifdef REG_DISCIPLINE
    1806. 

  1806. 			if (state.stack)
    1807. 

  1807. 				stkset(stkstd, state.stack, 0);
    1808. 

  1808. 			flags |= REG_DISCIPLINE;
    1809. 

  1809. 			state.disc.ordinal = 0;
    1810. 

  1810. 			sfstrseek(state.disc.sp, 0, SEEK_SET);
    1811. 

  1811. #endif
    1812. 

  1812. 			if (!(test & TEST_CATCH))
    1813. 

  1813. 				cret = regcomp(&preg, re, flags);
    1814. 

  1814. 			else if (!(cret = setjmp(state.gotcha)))
    1815. 

  1815. 			{
    1816. 

  1816. 				alarm(HUNG);
    1817. 

  1817. 				cret = regcomp(&preg, re, flags);
    1818. 

  1818. 				alarm(0);
    1819. 

  1819. 			}
    1820. 

  1820. #if _REG_subcomp
    1821. 

  1821. 			if (!cret && (test & TEST_SUB))
    1822. 

  1822. 			{
    1823. 

  1823. 				fun = "regsubcomp";
    1824. 

  1824. 				p = re + preg.re_npat;
    1825. 

  1825. 				if (!(test & TEST_CATCH))
    1826. 

  1826. 					cret = regsubcomp(&preg, p, NiL, 0, 0);
    1827. 

  1827. 				else if (!(cret = setjmp(state.gotcha)))
    1828. 

  1828. 				{
    1829. 

  1829. 					alarm(HUNG);
    1830. 

  1830. 					cret = regsubcomp(&preg, p, NiL, 0, 0);
    1831. 

  1831. 					alarm(0);
    1832. 

  1832. 				}
    1833. 

  1833. 				if (!cret && *(p += preg.re_npat) && !(preg.re_sub->re_flags & REG_SUB_LAST))
    1834. 

  1834. 				{
    1835. 

  1835. 					if (catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test))
    1836. 

  1836. 						continue;
    1837. 

  1837. 					cret = REG_EFLAGS;
    1838. 

  1838. 				}
    1839. 

  1839. 			}
    1840. 

  1840. #endif
    1841. 

  1841. 			if (!cret)
    1842. 

  1842. 			{
    1843. 

  1843. 				if (!(flags & REG_NOSUB) && nsub < 0 && *ans == '(')
    1844. 

  1844. 				{
    1845. 

  1845. 					for (p = ans; *p; p++)
    1846. 

  1846. 						if (*p == '(')
    1847. 

  1847. 							nsub++;
    1848. 

  1848. 						else if (*p == '{')
    1849. 

  1849. 							nsub--;
    1850. 

  1850. 					if (nsub >= 0)
    1851. 

  1851. 					{
    1852. 

  1852. 						if (test & TEST_IGNORE_OVER)
    1853. 

  1853. 						{
    1854. 

  1854. 							if (nmatch > nsub)
    1855. 

  1855. 								nmatch = nsub + 1;
    1856. 

  1856. 						}
    1857. 

  1857. 						else if (nsub != preg.re_nsub)
    1858. 

  1858. 						{
    1859. 

  1859. 							if (nsub > preg.re_nsub)
    1860. 

  1860. 							{
    1861. 

  1861. 								if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1862. 

  1862. 									skip = extract(tabs, line, re, s, ans, msg, "OK", NiL, 0, 0, skip, level, test|TEST_DELIMIT);
    1863. 

  1863. 								else
    1864. 

  1864. 								{
    1865. 

  1865. 									report("re_nsub incorrect", fun, re, NiL, -1, msg, flags, test);
    1866. 

  1866. 									printf("at least %d expected, %zd returned\n", nsub, preg.re_nsub);
    1867. 

  1867. 									state.errors++;
    1868. 

  1868. 								}
    1869. 

  1869. 							}
    1870. 

  1870. 							else
    1871. 

  1871. 								nsub = preg.re_nsub;
    1872. 

  1872. 						}
    1873. 

  1873. 					}
    1874. 

  1874. 				}
    1875. 

  1875. 				if (!(test & TEST_SUB) && *ans && *ans != '(' && !streq(ans, "OK") && !streq(ans, "NOMATCH"))
    1876. 

  1876. 				{
    1877. 

  1877. 					if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1878. 

  1878. 						skip = extract(tabs, line, re, s, ans, msg, "OK", NiL, 0, 0, skip, level, test|TEST_DELIMIT);
    1879. 

  1879. 					else if (!(test & TEST_LENIENT))
    1880. 

  1880. 					{
    1881. 

  1881. 						report("failed", fun, re, NiL, -1, msg, flags, test);
    1882. 

  1882. 						printf("%s expected, OK returned\n", ans);
    1883. 

  1883. 					}
    1884. 

  1884. 					catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test);
    1885. 

  1885. 					continue;
    1886. 

  1886. 				}
    1887. 

  1887. 			}
    1888. 

  1888. 			else
    1889. 

  1889. 			{
    1890. 

  1890. 				if (test & TEST_LENIENT)
    1891. 

  1891. 					/* we'll let it go this time */;
    1892. 

  1892. 				else if (!*ans || ans[0]=='(' || (cret == REG_BADPAT && streq(ans, "NOMATCH")))
    1893. 

  1893. 				{
    1894. 

  1894. 					got = 0;
    1895. 

  1895. 					for (i = 1; i < elementsof(codes); i++)
    1896. 

  1896. 						if (cret==codes[i].code)
    1897. 

  1897. 							got = i;
    1898. 

  1898. 					if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1899. 

  1899. 						skip = extract(tabs, line, re, s, ans, msg, codes[got].name, NiL, 0, 0, skip, level, test|TEST_DELIMIT);
    1900. 

  1900. 					else
    1901. 

  1901. 					{
    1902. 

  1902. 						report("failed", fun, re, NiL, -1, msg, flags, test);
    1903. 

  1903. 						printf("%s returned: ", codes[got].name);
    1904. 

  1904. 						error(&preg, cret);
    1905. 

  1905. 					}
    1906. 

  1906. 				}
    1907. 

  1907. 				else
    1908. 

  1908. 				{
    1909. 

  1909. 					expected = got = 0;
    1910. 

  1910. 					for (i = 1; i < elementsof(codes); i++)
    1911. 

  1911. 					{
    1912. 

  1912. 						if (streq(ans, codes[i].name))
    1913. 

  1913. 							expected = i;
    1914. 

  1914. 						if (cret==codes[i].code)
    1915. 

  1915. 							got = i;
    1916. 

  1916. 					}
    1917. 

  1917. 					if (!expected)
    1918. 

  1918. 					{
    1919. 

  1919. 						if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1920. 

  1920. 							skip = extract(tabs, line, re, s, ans, msg, codes[got].name, NiL, 0, 0, skip, level, test|TEST_DELIMIT);
    1921. 

  1921. 						else
    1922. 

  1922. 						{
    1923. 

  1923. 							report("failed: invalid error code", NiL, re, NiL, -1, msg, flags, test);
    1924. 

  1924. 							printf("%s expected, %s returned\n", ans, codes[got].name);
    1925. 

  1925. 						}
    1926. 

  1926. 					}
    1927. 

  1927. 					else if (cret != codes[expected].code && cret != REG_BADPAT)
    1928. 

  1928. 					{
    1929. 

  1929. 						if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1930. 

  1930. 							skip = extract(tabs, line, re, s, ans, msg, codes[got].name, NiL, 0, 0, skip, level, test|TEST_DELIMIT);
    1931. 

  1931. 						else if (test & TEST_IGNORE_ERROR)
    1932. 

  1932. 							state.ignored++;
    1933. 

  1933. 						else
    1934. 

  1934. 						{
    1935. 

  1935. 							report("should fail and did", fun, re, NiL, -1, msg, flags, test);
    1936. 

  1936. 							printf("%s expected, %s returned: ", ans, codes[got].name);
    1937. 

  1937. 							state.errors--;
    1938. 

  1938. 							state.warnings++;
    1939. 

  1939. 							error(&preg, cret);
    1940. 

  1940. 						}
    1941. 

  1941. 					}
    1942. 

  1942. 				}
    1943. 

  1943. 				goto compile;
    1944. 

  1944. 			}
    1945. 

  1945. 

  1946. #if _REG_nexec
    1947. 

  1947. 		execute:
    1948. 

  1948. 			if (nexec >= 0)
    1949. 

  1949. 				fun = "regnexec";
    1950. 

  1950. 			else
    1951. 

  1951. #endif
    1952. 

  1952. 				fun = "regexec";
    1953. 

  1953. 

  1954. 			for (i = 0; i < elementsof(match); i++)
    1955. 

  1955. 				match[i] = state.NOMATCH;
    1956. 

  1956. 

  1957. #if _REG_nexec
    1958. 

  1958. 			if (nexec >= 0)
    1959. 

  1959. 			{
    1960. 

  1960. 				eret = regnexec(&preg, s, nexec, nmatch, match, eflags);
    1961. 

  1961. 				s[nexec] = 0;
    1962. 

  1962. 			}
    1963. 

  1963. 			else
    1964. 

  1964. #endif
    1965. 

  1965. 			{
    1966. 

  1966. 				if (!(test & TEST_CATCH))
    1967. 

  1967. 					eret = regexec(&preg, s, nmatch, match, eflags);
    1968. 

  1968. 				else if (!(eret = setjmp(state.gotcha)))
    1969. 

  1969. 				{
    1970. 

  1970. 					alarm(HUNG);
    1971. 

  1971. 					eret = regexec(&preg, s, nmatch, match, eflags);
    1972. 

  1972. 					alarm(0);
    1973. 

  1973. 				}
    1974. 

  1974. 			}
    1975. 

  1975. #if _REG_subcomp
    1976. 

  1976. 			if ((test & TEST_SUB) && !eret)
    1977. 

  1977. 			{
    1978. 

  1978. 				fun = "regsubexec";
    1979. 

  1979. 				if (!(test & TEST_CATCH))
    1980. 

  1980. 					eret = regsubexec(&preg, s, nmatch, match);
    1981. 

  1981. 				else if (!(eret = setjmp(state.gotcha)))
    1982. 

  1982. 				{
    1983. 

  1983. 					alarm(HUNG);
    1984. 

  1984. 					eret = regsubexec(&preg, s, nmatch, match);
    1985. 

  1985. 					alarm(0);
    1986. 

  1986. 				}
    1987. 

  1987. 			}
    1988. 

  1988. #endif
    1989. 

  1989. 			if (flags & REG_NOSUB)
    1990. 

  1990. 			{
    1991. 

  1991. 				if (eret)
    1992. 

  1992. 				{
    1993. 

  1993. 					if (eret != REG_NOMATCH || !streq(ans, "NOMATCH"))
    1994. 

  1994. 					{
    1995. 

  1995. 						if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    1996. 

  1996. 							skip = extract(tabs, line, re, s, ans, msg, "NOMATCH", NiL, 0, 0, skip, level, test|TEST_DELIMIT);
    1997. 

  1997. 						else
    1998. 

  1998. 						{
    1999. 

  1999. 							report("REG_NOSUB failed", fun, re, s, nstr, msg, flags, test);
    2000. 

  2000. 							error(&preg, eret);
    2001. 

  2001. 						}
    2002. 

  2002. 					}
    2003. 

  2003. 				}
    2004. 

  2004. 				else if (streq(ans, "NOMATCH"))
    2005. 

  2005. 				{
    2006. 

  2006. 					if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    2007. 

  2007. 						skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_DELIMIT);
    2008. 

  2008. 					else
    2009. 

  2009. 					{
    2010. 

  2010. 						report("should fail and didn't", fun, re, s, nstr, msg, flags, test);
    2011. 

  2011. 						error(&preg, eret);
    2012. 

  2012. 					}
    2013. 

  2013. 				}
    2014. 

  2014. 			}
    2015. 

  2015. 			else if (eret)
    2016. 

  2016. 			{
    2017. 

  2017. 				if (eret != REG_NOMATCH || !streq(ans, "NOMATCH"))
    2018. 

  2018. 				{
    2019. 

  2019. 					if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    2020. 

  2020. 						skip = extract(tabs, line, re, s, ans, msg, "NOMATCH", NiL, 0, nsub, skip, level, test|TEST_DELIMIT);
    2021. 

  2021. 					else
    2022. 

  2022. 					{
    2023. 

  2023. 						report("failed", fun, re, s, nstr, msg, flags, test);
    2024. 

  2024. 						if (eret != REG_NOMATCH)
    2025. 

  2025. 							error(&preg, eret);
    2026. 

  2026. 						else if (*ans)
    2027. 

  2027. 							printf("expected: %s\n", ans);
    2028. 

  2028. 						else
    2029. 

  2029. 							printf("\n");
    2030. 

  2030. 					}
    2031. 

  2031. 				}
    2032. 

  2032. 			}
    2033. 

  2033. 			else if (streq(ans, "NOMATCH"))
    2034. 

  2034. 			{
    2035. 

  2035. 				if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    2036. 

  2036. 					skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_DELIMIT);
    2037. 

  2037. 				else
    2038. 

  2038. 				{
    2039. 

  2039. 					report("should fail and didn't", fun, re, s, nstr, msg, flags, test);
    2040. 

  2040. 					matchprint(match, nmatch, nsub, NiL, test);
    2041. 

  2041. 				}
    2042. 

  2042. 			}
    2043. 

  2043. #if _REG_subcomp
    2044. 

  2044. 			else if (test & TEST_SUB)
    2045. 

  2045. 			{
    2046. 

  2046. 				p = preg.re_sub->re_buf;
    2047. 

  2047. 				if (strcmp(p, ans))
    2048. 

  2048. 				{
    2049. 

  2049. 					report("failed", fun, re, s, nstr, msg, flags, test);
    2050. 

  2050. 					quote(ans, -1, test|TEST_DELIMIT);
    2051. 

  2051. 					printf(" expected, ");
    2052. 

  2052. 					quote(p, -1, test|TEST_DELIMIT);
    2053. 

  2053. 					printf(" returned\n");
    2054. 

  2054. 				}
    2055. 

  2055. 			}
    2056. 

  2056. #endif
    2057. 

  2057. 			else if (!*ans)
    2058. 

  2058. 			{
    2059. 

  2059. 				if (match[0].rm_so != state.NOMATCH.rm_so)
    2060. 

  2060. 				{
    2061. 

  2061. 					if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    2062. 

  2062. 						skip = extract(tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test);
    2063. 

  2063. 					else
    2064. 

  2064. 					{
    2065. 

  2065. 						report("failed: no match but match array assigned", NiL, re, s, nstr, msg, flags, test);
    2066. 

  2066. 						matchprint(match, nmatch, nsub, NiL, test);
    2067. 

  2067. 					}
    2068. 

  2068. 				}
    2069. 

  2069. 			}
    2070. 

  2070. 			else if (matchcheck(match, nmatch, nsub, ans, re, s, nstr, flags, test))
    2071. 

  2071. 			{
    2072. 

  2072. #if _REG_nexec
    2073. 

  2073. 				if (nexec < 0 && !nonexec)
    2074. 

  2074. 				{
    2075. 

  2075. 					nexec = nstr >= 0 ? nstr : strlen(s);
    2076. 

  2076. 					s[nexec] = '\n';
    2077. 

  2077. 					testno++;
    2078. 

  2078. 					goto execute;
    2079. 

  2079. 				}
    2080. 

  2080. #endif
    2081. 

  2081. 				if (!(test & (TEST_SUB|TEST_VERIFY)) && !nonosub)
    2082. 

  2082. 				{
    2083. 

  2083. 					if (catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test))
    2084. 

  2084. 						continue;
    2085. 

  2085. 					flags |= REG_NOSUB;
    2086. 

  2086. 					goto nosub;
    2087. 

  2087. 				}
    2088. 

  2088. 				if (test & (TEST_BASELINE|TEST_PASS|TEST_VERIFY))
    2089. 

  2089. 					skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_OK);
    2090. 

  2090. 			}
    2091. 

  2091. 			else if (test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS|TEST_QUERY|TEST_SUMMARY|TEST_VERIFY))
    2092. 

  2092. 				skip = extract(tabs, line, re, s, ans, msg, NiL, match, nmatch, nsub, skip, level, test|TEST_DELIMIT);
    2093. 

  2093. 			if (catchfree(&preg, flags, tabs, line, re, s, ans, msg, NiL, NiL, 0, 0, skip, level, test))
    2094. 

  2094. 				continue;
    2095. 

  2095. 			goto compile;
    2096. 

  2096. 		}
    2097. 

  2097. 		if (test & TEST_SUMMARY)
    2098. 

  2098. 			printf("tests=%-4d errors=%-4d warnings=%-2d ignored=%-2d unspecified=%-2d signals=%d\n", testno, state.errors, state.warnings, state.ignored, state.unspecified, state.signals);
    2099. 

  2099. 		else if (!(test & (TEST_ACTUAL|TEST_BASELINE|TEST_FAIL|TEST_PASS)))
    2100. 

  2100. 		{
    2101. 

  2101. 			printf("TEST\t%s", unit);
    2102. 

  2102. 			if (subunit)
    2103. 

  2103. 				printf(" %-.*s", subunitlen, subunit);
    2104. 

  2104. 			printf(", %d test%s", testno, testno == 1 ? "" : "s");
    2105. 

  2105. 			if (state.ignored)
    2106. 

  2106. 				printf(", %d ignored mismatche%s", state.ignored, state.ignored == 1 ? "" : "s");
    2107. 

  2107. 			if (state.warnings)
    2108. 

  2108. 				printf(", %d warning%s", state.warnings, state.warnings == 1 ? "" : "s");
    2109. 

  2109. 			if (state.unspecified)
    2110. 

  2110. 				printf(", %d unspecified difference%s", state.unspecified, state.unspecified == 1 ? "" : "s");
    2111. 

  2111. 			if (state.signals)
    2112. 

  2112. 				printf(", %d signal%s", state.signals, state.signals == 1 ? "" : "s");
    2113. 

  2113. 			printf(", %d error%s\n", state.errors, state.errors == 1 ? "" : "s");
    2114. 

  2114. 		}
    2115. 

  2115. 		if (fp != stdin)
    2116. 

  2116. 			fclose(fp);
    2117. 

  2117. 	}
    2118. 

  2118. 	return 0;
    2119. 

  2119. }
    2120.