logo

live-bootstrap

Mirror of <https://github.com/fosslinux/live-bootstrap>

scan.lex.l (18887B)

    

  1. /* SPDX-FileCopyrightText: 2021 Andrius Štikonas <andrius@stikonas.eu> */
  2. /* SPDX-FileCopyrightText: 2019-2020 Giovanni Mascellani <gio@debian.org> */
  4. /* SPDX-License-Identifier: BSD-2-Clause */
  6. /* scan.l - scanner for flex input -*-C-*- */
  8. %{
  9. /*  Copyright (c) 1990 The Regents of the University of California. */
  10. /*  All rights reserved. */
  12. /*  This code is derived from software contributed to Berkeley by */
  13. /*  Vern Paxson. */
  15. /*  The United States Government has rights in this work pursuant */
  16. /*  to contract no. DE-AC03-76SF00098 between the United States */
  17. /*  Department of Energy and the University of California. */
  19. /*  This file is part of flex. */
  21. /*  Redistribution and use in source and binary forms, with or without */
  22. /*  modification, are permitted provided that the following conditions */
  23. /*  are met: */
  25. /*  1. Redistributions of source code must retain the above copyright */
  26. /*     notice, this list of conditions and the following disclaimer. */
  27. /*  2. Redistributions in binary form must reproduce the above copyright */
  28. /*     notice, this list of conditions and the following disclaimer in the */
  29. /*     documentation and/or other materials provided with the distribution. */
  31. /*  Neither the name of the University nor the names of its contributors */
  32. /*  may be used to endorse or promote products derived from this software */
  33. /*  without specific prior written permission. */
  35. /*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
  36. /*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
  37. /*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
  38. /*  PURPOSE. */
  40. #define yyin_defined
  41. #include "flexdef.h"
  42. #include "parse.h"
  44. #define ACTION_ECHO add_action( yytext )
  45. #define ACTION_IFDEF(def, should_define) \
  46. 	{ \
  47. 	if ( should_define ) \
  48. 		action_define( def, 1 ); \
  49. 	}
  51. #define MARK_END_OF_PROLOG mark_prolog();
  53. #define YY_DECL \
  54. 	int flexscan()
  56. #define RETURNCHAR \
  57. 	yylval = (unsigned char) yytext[0]; \
  58. 	return CHAR;
  60. #define RETURNNAME \
  61. 	strcpy( nmstr, yytext ); \
  62. 	return NAME;
  64. #define PUT_BACK_STRING(str, start) \
  65. 	for ( i = strlen( str ) - 1; i >= start; --i ) \
  66. 		unput((str)[i])
  68. #define CHECK_REJECT(str) \
  69. 	if ( all_upper( str ) ) \
  70. 		reject = true;
  72. #define CHECK_YYMORE(str) \
  73. 	if ( all_lower( str ) ) \
  74. 		yymore_used = true;
  76. #define YY_USER_INIT \
  77. 	if ( getenv("POSIXLY_CORRECT") ) \
  78. 		posix_compat = true;
  80. #ifndef yy_set_bol
  81. #define yy_set_bol(x) (x ? NLSTATE : 0)
  82. #endif
  84. #define YY_NULL 0
  85. #define yyterminate() return YY_NULL
  87. %}
  89. %e 5000
  90. %p 10000
  91. %a 100000
  92. %n 5000
  94. %x SECT2 SECT2PROLOG SECT3 CODEBLOCK PICKUPDEF SC CARETISBOL NUM QUOTE
  95. %x FIRSTCCL CCL ACTION RECOVER COMMENT ACTION_STRING
  96. %x OPTION LINEDIR
  98. WS		[ \t]+
  99. OPTWS		[ \t]*
  100. NOT_WS		[^ \t\r\n]
  102. NL		\r?\n
  104. NAME		([a-zA-Z_][a-zA-Z0-9_-]*)
  105. NOT_NAME	[^a-zA-Z_*\n]+
  107. SCNAME		{NAME}
  109. ESCSEQ		(\\([^\n]|[0-7]{1,3}|x[0-9a-fA-F]{1,2}))
  111. FIRST_CCL_CHAR	([^\\\n]|{ESCSEQ})
  112. CCL_CHAR	([^\\\n\]]|{ESCSEQ})
  113. CCL_EXPR	("[:"[a-zA-Z]+":]")
  115. LEXOPT		[aceknopr]
  117. %%
  118. 	static int bracelevel, didadef, indented_code;
  119. 	static int doing_rule_action = false;
  120. 	static int option_sense;
  122. 	int doing_codeblock = false;
  123. 	int i;
  124. 	Char nmdef[MAXLINE];
  127. <INITIAL>^{WS}		{ indented_code = true; BEGIN(CODEBLOCK); }
  128. <INITIAL>^"/*"		{ ACTION_ECHO; BEGIN( COMMENT ); }
  129. <INITIAL>^#{OPTWS}line{WS}	{ BEGIN( LINEDIR ); }
  130. <INITIAL>^"%s"{NAME}?	{ return SCDECL; }
  131. <INITIAL>^"%x"{NAME}?	{ return XSCDECL; }
  132. <INITIAL>^"%{".*{NL}	{
  133. 			++linenum;
  134. 			line_directive_out( (FILE *) 0, 1 );
  135. 			indented_code = false;
  136. 			BEGIN(CODEBLOCK);
  137. 			}
  139. <INITIAL>{WS}		{ /* discard */ }
  141. <INITIAL>^"%%".*		{
  142. 			sectnum = 2;
  143. 			bracelevel = 0;
  144. 			mark_defs1();
  145. 			line_directive_out( (FILE *) 0, 1 );
  146. 			BEGIN(SECT2PROLOG);
  147. 			return SECTEND;
  148. 			}
  150. <INITIAL>^"%pointer".*{NL}	{ yytext_is_array = false; ++linenum; }
  151. <INITIAL>^"%array".*{NL}		{ yytext_is_array = true; ++linenum; }
  153. <INITIAL>^"%option"	{ BEGIN(OPTION); return OPTION_OP; }
  155. <INITIAL>^"%"{LEXOPT}{OPTWS}[0-9]*{OPTWS}{NL}	{ ++linenum; /* ignore */ }
  156. <INITIAL>^"%"{LEXOPT}{WS}.*{NL}	{ ++linenum;	/* ignore */ }
  158. <INITIAL>^"%"[^sxaceknopr{}].*	{ synerr( _( "unrecognized '%' directive" ) ); }
  160. <INITIAL>^{NAME}		{
  161. 			strcpy( nmstr, yytext );
  162. 			didadef = false;
  163. 			BEGIN(PICKUPDEF);
  164. 			}
  166. <INITIAL>{SCNAME}	{ RETURNNAME; }
  167. <INITIAL>^{OPTWS}{NL}	{ ++linenum; /* allows blank lines in section 1 */ }
  168. <INITIAL>{OPTWS}{NL}	{ ACTION_ECHO; ++linenum; /* maybe end of comment line */ }
  171. <COMMENT>"*/"		{ ACTION_ECHO; BEGIN(INITIAL); }
  172. <COMMENT>"*"		{ ACTION_ECHO; }
  173. <COMMENT>[^*\n]+		{ ACTION_ECHO; }
  174. <COMMENT>[^*\n]*{NL}	{ ++linenum; ACTION_ECHO; }
  176. <LINEDIR>\n		{ BEGIN(INITIAL); }
  177. <LINEDIR>[0-9]+	{ linenum = myctoi( yytext ); }
  179. <LINEDIR>\"[^"\n]*\"	{
  180. 			flex_free( (void *) infilename );
  181. 			infilename = copy_string( yytext + 1 );
  182. 			infilename[strlen( infilename ) - 1] = '\0';
  183. 			}
  185. <CODEBLOCK>^"%}".*{NL}	{ ++linenum; BEGIN(INITIAL); }
  187. <CODEBLOCK>{NAME}|{NOT_NAME}|.	{ ACTION_ECHO; }
  189. <CODEBLOCK>{NL}		{
  190. 			++linenum;
  191. 			ACTION_ECHO;
  192. 			if ( indented_code )
  193. 				BEGIN(INITIAL);
  194. 			}
  197. <PICKUPDEF>{WS}		{ /* separates name and definition */ }
  199. <PICKUPDEF>{NOT_WS}[^\r\n]*	{
  200. 			strcpy( (char *) nmdef, yytext );
  202. 			/* Skip trailing whitespace. */
  203. 			for ( i = strlen( (char *) nmdef ) - 1;
  204. 			      i >= 0 && (nmdef[i] == ' ' || nmdef[i] == '\t');
  205. 			      --i )
  206. 				;
  208. 			nmdef[i + 1] = '\0';
  210. 			ndinstal( nmstr, nmdef );
  211. 			didadef = true;
  212. 			}
  214. <PICKUPDEF>{NL}		{
  215. 			if ( ! didadef )
  216. 				synerr( _( "incomplete name definition" ) );
  217. 			BEGIN(INITIAL);
  218. 			++linenum;
  219. 			}
  222. <OPTION>{NL}		{ ++linenum; BEGIN(INITIAL); }
  223. <OPTION>{WS}		{ option_sense = true; }
  225. <OPTION>"="		{ return '='; }
  227. <OPTION>no		{ option_sense = ! option_sense; }
  229. <OPTION>7bit		{ csize = option_sense ? 128 : 256; }
  230. <OPTION>8bit		{ csize = option_sense ? 256 : 128; }
  232. <OPTION>align		{ long_align = option_sense; }
  233. <OPTION>always-interactive	{
  234. 			action_define( "YY_ALWAYS_INTERACTIVE", option_sense );
  235. 			}
  236. <OPTION>array		{ yytext_is_array = option_sense; }
  237. <OPTION>backup		{ backing_up_report = option_sense; }
  238. <OPTION>batch		{ interactive = ! option_sense; }
  239. <OPTION>"c++"		{ C_plus_plus = option_sense; }
  240. <OPTION>caseful|case-sensitive		{ caseins = ! option_sense; }
  241. <OPTION>caseless|case-insensitive	{ caseins = option_sense; }
  242. <OPTION>debug		{ ddebug = option_sense; }
  243. <OPTION>default		{ spprdflt = ! option_sense; }
  244. <OPTION>ecs		{ useecs = option_sense; }
  245. <OPTION>fast		{
  246. 			useecs = usemecs = false;
  247. 			use_read = fullspd = true;
  248. 			}
  249. <OPTION>full		{
  250. 			useecs = usemecs = false;
  251. 			use_read = fulltbl = true;
  252. 			}
  253. <OPTION>input		{ ACTION_IFDEF("YY_NO_INPUT", ! option_sense); }
  254. <OPTION>interactive	{ interactive = option_sense; }
  255. <OPTION>lex-compat	{ lex_compat = option_sense; }
  256. <OPTION>posix-compat	{ posix_compat = option_sense; }
  257. <OPTION>main		{
  258. 			action_define( "YY_MAIN", option_sense );
  259.             /* Override yywrap */
  260.             if( option_sense == true )
  261.                 do_yywrap = false;
  262. 			}
  263. <OPTION>meta-ecs	{ usemecs = option_sense; }
  264. <OPTION>never-interactive	{
  265. 			action_define( "YY_NEVER_INTERACTIVE", option_sense );
  266. 			}
  267. <OPTION>perf-report	{ performance_report += option_sense ? 1 : -1; }
  268. <OPTION>pointer		{ yytext_is_array = ! option_sense; }
  269. <OPTION>read		{ use_read = option_sense; }
  270. <OPTION>reentrant   { reentrant = option_sense; }
  271. <OPTION>reentrant-bison {
  272.                 /* reentrant-bison implies reentrant. */
  273.                 if ((reentrant_bison_pure = option_sense) != 0)
  274.                     reentrant = 1;
  275.             }    
  276. <OPTION>reject		{ reject_really_used = option_sense; }
  277. <OPTION>stack		{ action_define( "YY_STACK_USED", option_sense ); }
  278. <OPTION>stdinit		{ do_stdinit = option_sense; }
  279. <OPTION>stdout		{ use_stdout = option_sense; }
  280. <OPTION>unistd      { ACTION_IFDEF("YY_NO_UNISTD_H", ! option_sense); }
  281. <OPTION>unput		{ ACTION_IFDEF("YY_NO_UNPUT", ! option_sense); }
  282. <OPTION>verbose		{ printstats = option_sense; }
  283. <OPTION>warn		{ nowarn = ! option_sense; }
  284. <OPTION>yylineno	{ do_yylineno = option_sense; ACTION_IFDEF("YY_USE_LINENO", option_sense); }
  285. <OPTION>yymore		{ yymore_really_used = option_sense; }
  286. <OPTION>yywrap      { do_yywrap = option_sense; }
  288. <OPTION>yy_push_state	{ ACTION_IFDEF("YY_NO_PUSH_STATE", ! option_sense); }
  289. <OPTION>yy_pop_state	{ ACTION_IFDEF("YY_NO_POP_STATE", ! option_sense); }
  290. <OPTION>yy_top_state	{ ACTION_IFDEF("YY_NO_TOP_STATE", ! option_sense); }
  292. <OPTION>yy_scan_buffer	{ ACTION_IFDEF("YY_NO_SCAN_BUFFER", ! option_sense); }
  293. <OPTION>yy_scan_bytes	{ ACTION_IFDEF("YY_NO_SCAN_BYTES", ! option_sense); }
  294. <OPTION>yy_scan_string	{ ACTION_IFDEF("YY_NO_SCAN_STRING", ! option_sense); }
  296. <OPTION>yyalloc         { ACTION_IFDEF("YY_NO_FLEX_ALLOC", ! option_sense); }
  297. <OPTION>yyrealloc       { ACTION_IFDEF("YY_NO_FLEX_REALLOC", ! option_sense); }
  298. <OPTION>yyfree          { ACTION_IFDEF("YY_NO_FLEX_FREE", ! option_sense); }
  300. <OPTION>yyget_debug     { ACTION_IFDEF("YY_NO_GET_DEBUG", ! option_sense); }
  301. <OPTION>yyset_debug     { ACTION_IFDEF("YY_NO_SET_DEBUG", ! option_sense); }
  302. <OPTION>yyget_extra     { ACTION_IFDEF("YY_NO_GET_EXTRA", ! option_sense); }
  303. <OPTION>yyset_extra     { ACTION_IFDEF("YY_NO_SET_EXTRA", ! option_sense); }
  304. <OPTION>yyget_leng      { ACTION_IFDEF("YY_NO_GET_LENG", ! option_sense); }
  305. <OPTION>yyget_text      { ACTION_IFDEF("YY_NO_GET_TEXT", ! option_sense); }
  306. <OPTION>yyget_lineno    { ACTION_IFDEF("YY_NO_GET_LINENO", ! option_sense); }
  307. <OPTION>yyset_lineno    { ACTION_IFDEF("YY_NO_SET_LINENO", ! option_sense); }
  308. <OPTION>yyget_in        { ACTION_IFDEF("YY_NO_GET_IN", ! option_sense); }
  309. <OPTION>yyset_in        { ACTION_IFDEF("YY_NO_SET_IN", ! option_sense); }
  310. <OPTION>yyget_out       { ACTION_IFDEF("YY_NO_GET_OUT", ! option_sense); }
  311. <OPTION>yyset_out       { ACTION_IFDEF("YY_NO_SET_OUT", ! option_sense); }
  312. <OPTION>yyget_lval      { ACTION_IFDEF("YY_NO_GET_LVAL", ! option_sense); }
  313. <OPTION>yyset_lval      { ACTION_IFDEF("YY_NO_SET_LVAL", ! option_sense); }
  314. <OPTION>yyget_lloc      { ACTION_IFDEF("YY_NO_GET_LLOC", ! option_sense); }
  315. <OPTION>yyset_lloc      { ACTION_IFDEF("YY_NO_SET_LLOC", ! option_sense); }
  317. <OPTION>outfile		{ return OPT_OUTFILE; }
  318. <OPTION>prefix		{ return OPT_PREFIX; }
  319. <OPTION>yyclass		{ return OPT_YYCLASS; }
  320. <OPTION>header      { return OPT_HEADER; }
  322. <OPTION>\"[^"\n]*\"	{
  323. 			strcpy( nmstr, yytext + 1 );
  324. 			nmstr[strlen( nmstr ) - 1] = '\0';
  325. 			return NAME;
  326. 			}
  328. <OPTION>(([a-mo-z]|n[a-np-z])[a-zA-Z\-+]*)|.	{
  329. 			format_synerr( _( "unrecognized %%option: %s" ),
  330. 				yytext );
  331. 			BEGIN(RECOVER);
  332. 			}
  334. <RECOVER>.*{NL}		{ ++linenum; BEGIN(INITIAL); }
  337. <SECT2PROLOG>^"%{".*	{ ++bracelevel; yyless( 2 ); }
  338. <SECT2PROLOG>^"%}".*	{ --bracelevel; yyless( 2 ); }
  340. <SECT2PROLOG>^{WS}.*	{ ACTION_ECHO;	/* indented code in prolog */ }
  342. <SECT2PROLOG>^{NOT_WS}.*	{	/* non-indented code */
  343. 			if ( bracelevel <= 0 )
  344. 				{ /* not in %{ ... %} */
  345. 				yyless( 0 );	/* put it all back */
  346. 				yy_set_bol( 1 );
  347. 				mark_prolog();
  348. 				BEGIN(SECT2);
  349. 				}
  350. 			else
  351. 				ACTION_ECHO;
  352. 			}
  354. <SECT2PROLOG>.*		{ ACTION_ECHO; }
  355. <SECT2PROLOG>{NL}	{ ++linenum; ACTION_ECHO; }
  357. <SECT2PROLOG><<EOF>>		{
  358. 			mark_prolog();
  359. 			sectnum = 0;
  360. 			yyterminate(); /* to stop the parser */
  361. 			}
  363. <SECT2>^{OPTWS}{NL}	{ ++linenum; /* allow blank lines in section 2 */ }
  365. <SECT2>^{OPTWS}"%{"	{
  366. 			indented_code = false;
  367. 			doing_codeblock = true;
  368. 			bracelevel = 1;
  369.                         synerr(_("percent brace action unsupported"));
  370. 			}
  372. <SECT2>^{OPTWS}"<"	{ BEGIN(SC); return '<'; }
  373. <SECT2>^{OPTWS}"^"	{ return '^'; }
  374. <SECT2>\"		{ BEGIN(QUOTE); return '"'; }
  375. <SECT2>"{"/[0-9]	{
  376. 			BEGIN(NUM);
  377. 			if ( lex_compat || posix_compat )
  378. 				return BEGIN_REPEAT_POSIX;
  379. 			else
  380. 				return BEGIN_REPEAT_FLEX;
  381. 			}
  382. <SECT2>"$"/([ \t]|{NL})	{ return '$'; }
  384. <SECT2>{WS}"%{"		{
  385. 			bracelevel = 1;
  386.                         synerr(_("percent brace unsupported"));
  388. 			if ( in_rule )
  389. 				{
  390. 				doing_rule_action = true;
  391. 				in_rule = false;
  392. 				return '\n';
  393. 				}
  394. 			}
  395. <SECT2>{WS}"|".*{NL}	{ continued_action = true; ++linenum; return '\n'; }
  397. <SECT2>^{WS}"/*"	{
  398. 			yyless( yyleng - 2 );	/* put back '/', '*' */
  399. 			bracelevel = 0;
  400. 			continued_action = false;
  401. 			BEGIN(ACTION);
  402. 			}
  404. <SECT2>^{WS}		{ /* allow indented rules */ }
  406. <SECT2>{WS}		{
  407. 			/* This rule is separate from the one below because
  408. 			 * otherwise we get variable trailing context, so
  409. 			 * we can't build the scanner using -{f,F}.
  410. 			 */
  411. 			bracelevel = 0;
  412. 			continued_action = false;
  413. 			BEGIN(ACTION);
  415. 			if ( in_rule )
  416. 				{
  417. 				doing_rule_action = true;
  418. 				in_rule = false;
  419. 				return '\n';
  420. 				}
  421. 			}
  423. <SECT2>{OPTWS}{NL}	{
  424. 			bracelevel = 0;
  425. 			continued_action = false;
  426. 			BEGIN(ACTION);
  427. 			unput( '\n' );	/* so <ACTION> sees it */
  429. 			if ( in_rule )
  430. 				{
  431. 				doing_rule_action = true;
  432. 				in_rule = false;
  433. 				return '\n';
  434. 				}
  435. 			}
  437. <SECT2>^{OPTWS}"<<EOF>>"	|
  438. <SECT2>"<<EOF>>"	{ return EOF_OP; }
  440. <SECT2>^"%%".*		{
  441. 			sectnum = 3;
  442. 			BEGIN(SECT3);
  443. 			outn("/* Begin user sect3 */");
  444. 			yyterminate(); /* to stop the parser */
  445. 			}
  447. <SECT2>"["({FIRST_CCL_CHAR}|{CCL_EXPR})({CCL_CHAR}|{CCL_EXPR})*	{
  448. 			int cclval;
  450. 			strcpy( nmstr, yytext );
  452. 			/* Check to see if we've already encountered this
  453. 			 * ccl.
  454. 			 */
  455. 			if ( (cclval = ccllookup( (Char *) nmstr )) != 0 )
  456. 				{
  457. 				if ( input() != ']' )
  458. 					synerr( _( "bad character class" ) );
  460. 				yylval = cclval;
  461. 				++cclreuse;
  462. 				return PREVCCL;
  463. 				}
  464. 			else
  465. 				{
  466. 				/* We fudge a bit.  We know that this ccl will
  467. 				 * soon be numbered as lastccl + 1 by cclinit.
  468. 				 */
  469. 				cclinstal( (Char *) nmstr, lastccl + 1 );
  471. 				/* Push back everything but the leading bracket
  472. 				 * so the ccl can be rescanned.
  473. 				 */
  474. 				yyless( 1 );
  476. 				BEGIN(FIRSTCCL);
  477. 				return '[';
  478. 				}
  479. 			}
  481. <SECT2>"{"{NAME}"}"[ \t\n\f\r\v]?	 {
  482. 			register Char *nmdefptr;
  483.             int end_is_ws, end_ch;
  484.             
  485.             end_ch = yytext[yyleng-1];
  486.             end_is_ws = end_ch != '}' ? 1 : 0;
  488. 			strcpy( nmstr, yytext + 1 );
  489. 			nmstr[yyleng - 2 - end_is_ws] = '\0';  /* chop trailing brace */
  491. 			if ( (nmdefptr = ndlookup( nmstr )) == 0 )
  492. 				format_synerr(
  493. 					_( "undefined definition {%s}" ),
  494. 						nmstr );
  496. 			else
  497. 				{ /* push back name surrounded by ()'s */
  498. 				int len = strlen( (char *) nmdefptr );
  499.                 if (end_is_ws)
  500.                     unput(end_ch);
  502. 				if ( lex_compat || nmdefptr[0] == '^' ||
  503. 				     (len > 0 && nmdefptr[len - 1] == '$')
  504.                      || end_is_ws)
  505. 					{ /* don't use ()'s after all */
  506. 					PUT_BACK_STRING((char *) nmdefptr, 0);
  508. 					if ( nmdefptr[0] == '^' )
  509. 						BEGIN(CARETISBOL);
  510. 					}
  512. 				else
  513. 					{
  514. 					unput(')');
  515. 					PUT_BACK_STRING((char *) nmdefptr, 0);
  516. 					unput('(');
  517. 					}
  518. 				}
  519. 			}
  521. <SECT2>[/|*+?.(){}]	{ return (unsigned char) yytext[0]; }
  522. <SECT2>.		{ RETURNCHAR; }
  525. <SC>{OPTWS}{NL}{OPTWS}	{ ++linenum;	/* Allow blank lines & continuations */ }
  526. <SC>[,*]		{ return (unsigned char) yytext[0]; }
  527. <SC>">"		{ BEGIN(SECT2); return '>'; }
  528. <SC>">"/^		{ BEGIN(CARETISBOL); return '>'; }
  529. <SC>{SCNAME}	{ RETURNNAME; }
  530. <SC>.		{
  531. 			format_synerr( _( "bad <start condition>: %s" ),
  532. 				yytext );
  533. 			}
  535. <CARETISBOL>"^"		{ BEGIN(SECT2); return '^'; }
  538. <QUOTE>[^"\n]		{ RETURNCHAR; }
  539. <QUOTE>\"		{ BEGIN(SECT2); return '"'; }
  541. <QUOTE>{NL}		{
  542. 			synerr( _( "missing quote" ) );
  543. 			BEGIN(SECT2);
  544. 			++linenum;
  545. 			return '"';
  546. 			}
  549. <FIRSTCCL>"^"/[^\]\n-]	{ BEGIN(CCL); return '^'; }
  550. <FIRSTCCL>"^"/("-"|"]")	{ return '^'; }
  551. <FIRSTCCL>.		{ BEGIN(CCL); RETURNCHAR; }
  553. <CCL>-/[^\]\n]	{ return '-'; }
  554. <CCL>[^\]\n]		{ RETURNCHAR; }
  555. <CCL>"]"		{ BEGIN(SECT2); return ']'; }
  556. <CCL>.|{NL}		{
  557. 			synerr( _( "bad character class" ) );
  558. 			BEGIN(SECT2);
  559. 			return ']';
  560. 			}
  562. <FIRSTCCL,CCL>"[:alnum:]"	{ BEGIN(CCL); return CCE_ALNUM; }
  563. <FIRSTCCL,CCL>"[:alpha:]"	{ BEGIN(CCL); return CCE_ALPHA; }
  564. <FIRSTCCL,CCL>"[:blank:]"	{ BEGIN(CCL); return CCE_BLANK; }
  565. <FIRSTCCL,CCL>"[:cntrl:]"	{ BEGIN(CCL); return CCE_CNTRL; }
  566. <FIRSTCCL,CCL>"[:digit:]"	{ BEGIN(CCL); return CCE_DIGIT; }
  567. <FIRSTCCL,CCL>"[:graph:]"	{ BEGIN(CCL); return CCE_GRAPH; }
  568. <FIRSTCCL,CCL>"[:lower:]"	{ BEGIN(CCL); return CCE_LOWER; }
  569. <FIRSTCCL,CCL>"[:print:]"	{ BEGIN(CCL); return CCE_PRINT; }
  570. <FIRSTCCL,CCL>"[:punct:]"	{ BEGIN(CCL); return CCE_PUNCT; }
  571. <FIRSTCCL,CCL>"[:space:]"	{ BEGIN(CCL); return CCE_SPACE; }
  572. <FIRSTCCL,CCL>"[:upper:]"	{ BEGIN(CCL); return CCE_UPPER; }
  573. <FIRSTCCL,CCL>"[:xdigit:]"	{ BEGIN(CCL); return CCE_XDIGIT; }
  574. <FIRSTCCL,CCL>{CCL_EXPR}	{
  575. 			format_synerr(
  576. 				_( "bad character class expression: %s" ),
  577. 					yytext );
  578. 			BEGIN(CCL); return CCE_ALNUM;
  579. 			}
  581. <NUM>[0-9]+	{
  582. 			yylval = myctoi( yytext );
  583. 			return NUMBER;
  584. 			}
  586. <NUM>","		{ return ','; }
  587. <NUM>"}"		{
  588. 			BEGIN(SECT2);
  589. 			if ( lex_compat || posix_compat )
  590. 				return END_REPEAT_POSIX;
  591. 			else
  592. 				return END_REPEAT_FLEX;
  593. 			}
  595. <NUM>.		{
  596. 			synerr( _( "bad character inside {}'s" ) );
  597. 			BEGIN(SECT2);
  598. 			return '}';
  599. 			}
  601. <NUM>{NL}		{
  602. 			synerr( _( "missing }" ) );
  603. 			BEGIN(SECT2);
  604. 			++linenum;
  605. 			return '}';
  606. 			}
  610. <ACTION>"{"		{ ACTION_ECHO; ++bracelevel; }
  611. <ACTION>"}"		{ ACTION_ECHO; --bracelevel; }
  612. <ACTION>[^a-zA-Z_\{\}\"'/\n]+	{ ACTION_ECHO; }
  613. <ACTION>{NAME}		{ ACTION_ECHO; }
  614. <ACTION>"'"([^'\\\n]|\\.)*"'"	{ ACTION_ECHO; /* character constant */ }
  615. <ACTION>\"		{ ACTION_ECHO; BEGIN(ACTION_STRING); }
  616. <ACTION>{NL}		{
  617. 			++linenum;
  618. 			ACTION_ECHO;
  619. 			if ( bracelevel == 0 )
  620. 				{
  621. 				if ( doing_rule_action )
  622. 					add_action( "\tYY_BREAK\n" );
  624. 				doing_rule_action = false;
  625. 				BEGIN(SECT2);
  626. 				}
  627. 			}
  628. <ACTION>.		{ ACTION_ECHO; }
  630. <ACTION_STRING>[^"\\\n]+	{ ACTION_ECHO; }
  631. <ACTION_STRING>\\.		{ ACTION_ECHO; }
  632. <ACTION_STRING>{NL}		{ ++linenum; ACTION_ECHO; BEGIN(ACTION); }
  633. <ACTION_STRING>\"		{ ACTION_ECHO; BEGIN(ACTION); }
  634. <ACTION_STRING>.		{ ACTION_ECHO; }
  636. <COMMENT,ACTION,ACTION_STRING><<EOF>>	{
  637. 			synerr( _( "EOF encountered inside an action" ) );
  638. 			yyterminate();
  639. 			}
  642. <SECT2,QUOTE,FIRSTCCL,CCL>{ESCSEQ}	{
  643. 			yylval = myesc( (Char *) yytext );
  645. 			if ( YYSTATE == FIRSTCCL )
  646. 				BEGIN(CCL);
  648. 			return CHAR;
  649. 			}
  652. <SECT3>.*(\n?)		{ ECHO; }
  653. <SECT3><<EOF>>		{ sectnum = 0; yyterminate(); }
  655. .|\n                        { format_synerr( _( "bad character: %s" ), yytext ); }
  657. %%
  660. int yywrap()
  661. 	{
  662. 	if ( --num_input_files > 0 )
  663. 		{
  664. 		set_input_file( *++input_files );
  665. 		return 0;
  666. 		}
  668. 	else
  669. 		return 1;
  670. 	}
  673. /* set_input_file - open the given file (if NULL, stdin) for scanning */
  675. void set_input_file( file )
  676. char *file;
  677. 	{
  678. 	if ( file && strcmp( file, "-" ) )
  679. 		{
  680. 		infilename = copy_string( file );
  681. 		yyin = fopen( infilename, "r" );
  683. 		if ( yyin == NULL )
  684. 			lerrsf( _( "can't open %s" ), file );
  685. 		}
  687. 	else
  688. 		{
  689. 		yyin = stdin;
  690. 		infilename = copy_string( "<stdin>" );
  691. 		}
  693. 	linenum = 1;
  694. 	}
  697. /* Wrapper routines for accessing the scanner's malloc routines. */
  699. void *flex_alloc( size )
  700. size_t size;
  701. 	{
  702. 	return (void *) malloc( size );
  703. 	}
  705. void *flex_realloc( ptr, size )
  706. void *ptr;
  707. size_t size;
  708. 	{
  709. 	return (void *) realloc( ptr, size );
  710. 	}
  712. void flex_free( ptr )
  713. void *ptr;
  714. 	{
  715. 	if ( ptr )
  716. 		free( ptr );
  717. 	}