[grub2.git] / grub-core / script / yylex.l

%{
/* yylex.l  The scripting lexer.  */
/*
 *  GRUB  --  GRand Unified Bootloader
 *  Copyright (C) 2009,2010  Free Software Foundation, Inc.
 *
 *  GRUB is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  GRUB is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <grub/parser.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/script_sh.h>
#include <grub/i18n.h>
#include "grub_script.tab.h"

#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wmissing-prototypes"
#pragma GCC diagnostic ignored "-Wmissing-declarations"
#pragma GCC diagnostic ignored "-Wunused-function"
#pragma GCC diagnostic ignored "-Wsign-compare"

#define yyalloc(size, scanner)   (grub_malloc((size)))
#define yyfree(ptr, scanner)   (grub_free((ptr)))
#define yyrealloc(ptr, size, scanner) (grub_realloc((ptr), (size)))

/* 
 * As we don't have access to yyscanner, we cannot do much except to
 * print the fatal error.
 */
#define YY_FATAL_ERROR(msg)                     \
  do {                                          \
    grub_printf (_("fatal error: %s\n"), _(msg));     \
  } while (0)

#define COPY(str, hint)                         \
  do {                                          \
    copy_string (yyextra, str, hint);           \
  } while (0)


#define RECORD                                  \
  do {                                          \
    grub_script_lexer_record (yyextra, yytext); \
  } while (0)

#define ARG(t)                        \
  do {                                \
    yyextra->lexerstate->type = t;    \
    return GRUB_PARSER_TOKEN_WORD;    \
  } while (0)

/* We don't need YY_INPUT, as we rely on yy_scan_strings */
#define YY_INPUT(buf,res,max) do { res = 0; } while (0)

/* forward declarations */
static int grub_lexer_unput (const char *input, yyscan_t yyscanner);
static int grub_lexer_resplit (const char *input, yyscan_t yyscanner);

static void  copy_string (struct grub_parser_param *, const char *,
                          unsigned hint);

%}

%top{

#include <config.h>

#include <sys/types.h>

typedef size_t yy_size_t;
#define YY_TYPEDEF_YY_SIZE_T 1

/* 
 * Some flex hacks for -nostdinc; XXX We need to fix these when libc
 * support becomes availble in GRUB.
 */

#ifndef GRUB_UTIL
#define stdin  0
#define stdout 0

#define fprintf(...) 0
#define exit(...) grub_fatal("fatal error in lexer")
#endif

}

%option ecs
%option meta-ecs

%option warn
%option array
%option stack
%option reentrant
%option bison-bridge
%option never-interactive

%option noyyfree noyyalloc noyyrealloc
%option nounistd nostdinit nodefault noyylineno

/* Reduce lexer size, by not defining these.  */
%option noyy_top_state
%option noinput nounput
%option noyyget_in noyyset_in
%option noyyget_out noyyset_out
%option noyyget_debug noyyset_debug
%option noyyget_lineno noyyset_lineno

%option extra-type="struct grub_parser_param*"

BLANK           [ \t]
COMMENT         #.*$

CHAR            [^{}|&$;<> \t\n\'\"\\]
DIGITS          [[:digit:]]+
NAME            [[:alpha:]_][[:alnum:]_]*

ESC             \\(.|\n)
SQCHR           [^\']
DQCHR           {ESC}|[^\\\"]
DQSTR           \"{DQCHR}*\"
I18NSTR         \$\"{DQCHR}*\"
SQSTR           \'{SQCHR}*\'
SPECIAL         \?|\#|\*|\@
VARIABLE        ${NAME}|$\{{NAME}\}|${DIGITS}|$\{{DIGITS}\}|${SPECIAL}|$\{{SPECIAL}\}
WORD            ({CHAR}|{DQSTR}|{SQSTR}|{ESC}|{VARIABLE}|{I18NSTR})+

MULTILINE       {WORD}?((\"{DQCHR}*)|(\$\"{DQCHR}*)|(\'{SQCHR}*))
POS_MULTILINE   {WORD}?\\\n

%x              SPLIT
%x              DQUOTE
%x              I18NQUOTE
%x              SQUOTE
%x              VAR

%%

 /* White spaces */
{BLANK}+        { RECORD; }
{COMMENT}       { RECORD; }

 /* Special symbols */
"\n"            { RECORD; return GRUB_PARSER_TOKEN_NEWLINE; }
"||"            { RECORD; return GRUB_PARSER_TOKEN_OR;      }
"&&"            { RECORD; return GRUB_PARSER_TOKEN_AND;     }
";;"            { RECORD; return GRUB_PARSER_TOKEN_SEMI2;   }
"|"             { RECORD; return GRUB_PARSER_TOKEN_PIPE;    }
"&"             { RECORD; return GRUB_PARSER_TOKEN_AMP;     }
";"             { RECORD; return GRUB_PARSER_TOKEN_SEMI;    }
"<"             { RECORD; return GRUB_PARSER_TOKEN_LT;      }
">"             { RECORD; return GRUB_PARSER_TOKEN_GT;      }

 /* Reserved words */
"{"             { RECORD; return GRUB_PARSER_TOKEN_LBR;       }
"}"             { RECORD; return GRUB_PARSER_TOKEN_RBR;       }
"[["            { RECORD; return GRUB_PARSER_TOKEN_LSQBR2;    }
"]]"            { RECORD; return GRUB_PARSER_TOKEN_RSQBR2;    }
"case"          { RECORD; return GRUB_PARSER_TOKEN_CASE;      }
"do"            { RECORD; return GRUB_PARSER_TOKEN_DO;        }
"done"          { RECORD; return GRUB_PARSER_TOKEN_DONE;      }
"elif"          { RECORD; return GRUB_PARSER_TOKEN_ELIF;      }
"else"          { RECORD; return GRUB_PARSER_TOKEN_ELSE;      }
"esac"          { RECORD; return GRUB_PARSER_TOKEN_ESAC;      }
"fi"            { RECORD; return GRUB_PARSER_TOKEN_FI;        }
"for"           { RECORD; return GRUB_PARSER_TOKEN_FOR;       }
"if"            { RECORD; return GRUB_PARSER_TOKEN_IF;        }
"in"            { RECORD; return GRUB_PARSER_TOKEN_IN;        }
"select"        { RECORD; return GRUB_PARSER_TOKEN_SELECT;    }
"then"          { RECORD; return GRUB_PARSER_TOKEN_THEN;      }
"until"         { RECORD; return GRUB_PARSER_TOKEN_UNTIL;     }
"while"         { RECORD; return GRUB_PARSER_TOKEN_WHILE;     }
"function"      { RECORD; return GRUB_PARSER_TOKEN_FUNCTION;  }

{MULTILINE}     {
                  if (grub_lexer_unput (yytext, yyscanner))
		    return GRUB_PARSER_TOKEN_BAD;
		}

{POS_MULTILINE} {
                  if (yyg->yy_c_buf_p + 1 == &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
		    {
		      if (grub_lexer_unput (yytext, yyscanner))
			return GRUB_PARSER_TOKEN_BAD;
		    }
		  else
		    {
		      RECORD;
		      yypush_buffer_state (YY_CURRENT_BUFFER, yyscanner);
		      if (grub_lexer_resplit (yytext, yyscanner))
			{
			  yypop_buffer_state (yyscanner);
			  return GRUB_PARSER_TOKEN_WORD;
			}
		      yyextra->lexerstate->resplit = 1;
		    }
		}


{NAME}          { RECORD; return GRUB_PARSER_TOKEN_NAME; }
{WORD}          {
                  RECORD;
		  yypush_buffer_state (YY_CURRENT_BUFFER, yyscanner);
		  if (grub_lexer_resplit (yytext, yyscanner))
		    {
		      yypop_buffer_state (yyscanner);
		      return GRUB_PARSER_TOKEN_WORD;
		    }
		  yyextra->lexerstate->resplit = 1;
                }
.               {
                  grub_script_yyerror (yyextra, yytext);
		  return GRUB_PARSER_TOKEN_BAD;
                }

 /* Split word into multiple args */

<SPLIT>{
  \\.           { COPY (yytext, yyleng); }
  \\\n          { /* ignore */ }
  \"            {
                  yy_push_state (DQUOTE, yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
                }
  \'            {
                  yy_push_state (SQUOTE, yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
                }
  "\$\""        {
                  yy_push_state (I18NQUOTE, yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_GETTEXT);
                }
  \$            {
                  yy_push_state (VAR, yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
                }
  \\            |
  [^\"\'\$\\]+  { COPY (yytext, yyleng); }
  <<EOF>>       {
                  yy_pop_state (yyscanner);
                  yypop_buffer_state (yyscanner);
		  yyextra->lexerstate->resplit = 0;
                  yyextra->lexerstate->merge_end = 1;
                  ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
                }
}

<VAR>{
  {SPECIAL}     |
  {DIGITS}      |
  {NAME}        {
                  COPY (yytext, yyleng);
                  yy_pop_state (yyscanner);
                  if (YY_START == SPLIT)
                    ARG (GRUB_SCRIPT_ARG_TYPE_VAR);
                  else
                    ARG (GRUB_SCRIPT_ARG_TYPE_DQVAR);
                }
  \{{SPECIAL}\} |
  \{{DIGITS}\}  |
  \{{NAME}\}    {
                  yytext[yyleng - 1] = '\0';
                  COPY (yytext + 1, yyleng - 2);
                  yy_pop_state (yyscanner);
                  if (YY_START == SPLIT)
                    ARG (GRUB_SCRIPT_ARG_TYPE_VAR);
                  else
                    ARG (GRUB_SCRIPT_ARG_TYPE_DQVAR);
                }
  .|\n          { return GRUB_PARSER_TOKEN_BAD; }
}

<SQUOTE>{
  \'            {
                  yy_pop_state (yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_SQSTR);
                }
  [^\']+        { COPY (yytext, yyleng); }
}

<DQUOTE>{
  \\\$          { COPY ("$", 1); }
  \\\\          { COPY ("\\", 1); }
  \\\"          { COPY ("\"", 1); }
  \\\n          { /* ignore */ }
  [^\"\$\\\n]+  { COPY (yytext, yyleng); }
  \"            {
                  yy_pop_state (yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_DQSTR);
                }
  \$            {
                  yy_push_state (VAR, yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_DQSTR);
                }
  (.|\n)        { COPY (yytext, yyleng); }
}

<I18NQUOTE>{
  \\\\          { COPY ("\\\\", 2); }
  \\\"          { COPY ("\"", 1); }
  \\\n          { /* ignore */ }
  [^\"\\\n]+    { COPY (yytext, yyleng); }
  \"            {
                  yy_pop_state (yyscanner);
                  ARG (GRUB_SCRIPT_ARG_TYPE_GETTEXT);
                }
  \\            { COPY ("\\", 1); }
  (.|\n)        { COPY (yytext, yyleng); }
}

<<EOF>>         {
                  yypop_buffer_state (yyscanner);
		  yyextra->lexerstate->eof = 1;
		  return GRUB_PARSER_TOKEN_EOF;
                }
%%

int
yywrap (yyscan_t yyscanner)
{
  if (yyget_extra (yyscanner)->lexerstate->resplit)
    return 1;

  return grub_script_lexer_yywrap (yyget_extra (yyscanner), 0);
}

static void copy_string (struct grub_parser_param *parser, const char *str, unsigned hint)
{
  grub_size_t size;
  char *ptr;
  unsigned len;

  len = hint ? hint : grub_strlen (str);
  if (parser->lexerstate->used + len >= parser->lexerstate->size)
    {
      size = len * 2;
      if (size < parser->lexerstate->size * 2)
        size = parser->lexerstate->size * 2;
      ptr = grub_realloc (parser->lexerstate->text, size);
      if (!ptr)
        {
          grub_script_yyerror (parser, 0);
          return;
        }

      parser->lexerstate->text = ptr;
      parser->lexerstate->size = size;
    }
  grub_strcpy (parser->lexerstate->text + parser->lexerstate->used - 1, str);
  parser->lexerstate->used += len;
}

static int
grub_lexer_resplit (const char *text, yyscan_t yyscanner)
{
  /* resplit text */
  if (yy_scan_string (text, yyscanner))
    {
      yyget_extra (yyscanner)->lexerstate->merge_start = 1;
      yy_push_state (SPLIT, yyscanner);
      return 0;
    }
  grub_script_yyerror (yyget_extra (yyscanner), 0);
  return 1;
}

static int
grub_lexer_unput (const char *text, yyscan_t yyscanner)
{
  struct grub_lexer_param *lexerstate = yyget_extra (yyscanner)->lexerstate;

  grub_free (lexerstate->prefix);

  lexerstate->prefix = grub_strdup (text);
  if (! lexerstate->prefix)
    {
      grub_script_yyerror (yyget_extra (yyscanner), N_("out of memory"));
      return 1;
    }
  return 0;
}
Commit	Line	Data
4d8d554a CW	1	%{
	2	/* yylex.l The scripting lexer. */
	3	/*
	4	* GRUB -- GRand Unified Bootloader
	5	* Copyright (C) 2009,2010 Free Software Foundation, Inc.
	6	*
	7	* GRUB is free software: you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation, either version 3 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* GRUB is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include <grub/parser.h>
	22	#include <grub/misc.h>
	23	#include <grub/mm.h>
	24	#include <grub/script_sh.h>
	25	#include <grub/i18n.h>
	26	#include "grub_script.tab.h"
	27
	28	#pragma GCC diagnostic ignored "-Wunused-parameter"
	29	#pragma GCC diagnostic ignored "-Wmissing-prototypes"
	30	#pragma GCC diagnostic ignored "-Wmissing-declarations"
	31	#pragma GCC diagnostic ignored "-Wunused-function"
	32	#pragma GCC diagnostic ignored "-Wsign-compare"
	33
	34	#define yyalloc(size, scanner) (grub_malloc((size)))
	35	#define yyfree(ptr, scanner) (grub_free((ptr)))
	36	#define yyrealloc(ptr, size, scanner) (grub_realloc((ptr), (size)))
	37
	38	/*
	39	* As we don't have access to yyscanner, we cannot do much except to
	40	* print the fatal error.
	41	*/
	42	#define YY_FATAL_ERROR(msg) \
	43	do { \
	44	grub_printf (_("fatal error: %s\n"), _(msg)); \
	45	} while (0)
	46
	47	#define COPY(str, hint) \
	48	do { \
	49	copy_string (yyextra, str, hint); \
	50	} while (0)
	51
	52
	53	#define RECORD \
	54	do { \
	55	grub_script_lexer_record (yyextra, yytext); \
	56	} while (0)
	57
	58	#define ARG(t) \
	59	do { \
	60	yyextra->lexerstate->type = t; \
	61	return GRUB_PARSER_TOKEN_WORD; \
	62	} while (0)
	63
	64	/* We don't need YY_INPUT, as we rely on yy_scan_strings */
65	#define YY_INPUT(buf,res,max) do { res = 0; } while (0)
66
67	/* forward declarations */
68	static int grub_lexer_unput (const char *input, yyscan_t yyscanner);
69	static int grub_lexer_resplit (const char *input, yyscan_t yyscanner);
70
71	static void copy_string (struct grub_parser_param , const char ,
72	unsigned hint);
73
74	%}
75
76	%top{
77
78	#include <config.h>
79
80	#include <sys/types.h>
81
82	typedef size_t yy_size_t;
83	#define YY_TYPEDEF_YY_SIZE_T 1
84
85	/*
86	* Some flex hacks for -nostdinc; XXX We need to fix these when libc
87	* support becomes availble in GRUB.
88	*/
89
90	#ifndef GRUB_UTIL
91	#define stdin 0
92	#define stdout 0
93
94	#define fprintf(...) 0
95	#define exit(...) grub_fatal("fatal error in lexer")
96	#endif
97
98	}
99
100	%option ecs
101	%option meta-ecs
102
103	%option warn
104	%option array
105	%option stack
106	%option reentrant
107	%option bison-bridge
108	%option never-interactive
109
110	%option noyyfree noyyalloc noyyrealloc
111	%option nounistd nostdinit nodefault noyylineno
112
113	/* Reduce lexer size, by not defining these. */
114	%option noyy_top_state
115	%option noinput nounput
116	%option noyyget_in noyyset_in
117	%option noyyget_out noyyset_out
118	%option noyyget_debug noyyset_debug
119	%option noyyget_lineno noyyset_lineno
120
121	%option extra-type="struct grub_parser_param*"
122
123	BLANK [ \t]
124	COMMENT #.*$
125
126	CHAR [^{}\|&$;<> \t\n\'\"\\]
127	DIGITS [[:digit:]]+
128	NAME [[:alpha:]_][[:alnum:]_]*
129
130	ESC \\(.\|\n)
131	SQCHR [^\']
132	DQCHR {ESC}\|[^\\\"]
133	DQSTR \"{DQCHR}*\"
134	I18NSTR \$\"{DQCHR}*\"
135	SQSTR \'{SQCHR}*\'
136	SPECIAL \?\|\#\|\*\|\@
137	VARIABLE ${NAME}\|$\{{NAME}\}\|${DIGITS}\|$\{{DIGITS}\}\|${SPECIAL}\|$\{{SPECIAL}\}
138	WORD ({CHAR}\|{DQSTR}\|{SQSTR}\|{ESC}\|{VARIABLE}\|{I18NSTR})+
139
140	MULTILINE {WORD}?((\"{DQCHR})\|(\$\"{DQCHR})\|(\'{SQCHR}*))
141	POS_MULTILINE {WORD}?\\\n
142
143	%x SPLIT
144	%x DQUOTE
145	%x I18NQUOTE
146	%x SQUOTE
147	%x VAR
148
149	%%
150
151	/* White spaces */
152	{BLANK}+ { RECORD; }
153	{COMMENT} { RECORD; }
154
155	/* Special symbols */
156	"\n" { RECORD; return GRUB_PARSER_TOKEN_NEWLINE; }
157	"\|\|" { RECORD; return GRUB_PARSER_TOKEN_OR; }
158	"&&" { RECORD; return GRUB_PARSER_TOKEN_AND; }
159	";;" { RECORD; return GRUB_PARSER_TOKEN_SEMI2; }
160	"\|" { RECORD; return GRUB_PARSER_TOKEN_PIPE; }
161	"&" { RECORD; return GRUB_PARSER_TOKEN_AMP; }
162	";" { RECORD; return GRUB_PARSER_TOKEN_SEMI; }
163	"<" { RECORD; return GRUB_PARSER_TOKEN_LT; }
164	">" { RECORD; return GRUB_PARSER_TOKEN_GT; }
165
166	/* Reserved words */
167	"{" { RECORD; return GRUB_PARSER_TOKEN_LBR; }
168	"}" { RECORD; return GRUB_PARSER_TOKEN_RBR; }
169	"[[" { RECORD; return GRUB_PARSER_TOKEN_LSQBR2; }
170	"]]" { RECORD; return GRUB_PARSER_TOKEN_RSQBR2; }
171	"case" { RECORD; return GRUB_PARSER_TOKEN_CASE; }
172	"do" { RECORD; return GRUB_PARSER_TOKEN_DO; }
173	"done" { RECORD; return GRUB_PARSER_TOKEN_DONE; }
174	"elif" { RECORD; return GRUB_PARSER_TOKEN_ELIF; }
175	"else" { RECORD; return GRUB_PARSER_TOKEN_ELSE; }
176	"esac" { RECORD; return GRUB_PARSER_TOKEN_ESAC; }
177	"fi" { RECORD; return GRUB_PARSER_TOKEN_FI; }
178	"for" { RECORD; return GRUB_PARSER_TOKEN_FOR; }
179	"if" { RECORD; return GRUB_PARSER_TOKEN_IF; }
180	"in" { RECORD; return GRUB_PARSER_TOKEN_IN; }
181	"select" { RECORD; return GRUB_PARSER_TOKEN_SELECT; }
182	"then" { RECORD; return GRUB_PARSER_TOKEN_THEN; }
183	"until" { RECORD; return GRUB_PARSER_TOKEN_UNTIL; }
184	"while" { RECORD; return GRUB_PARSER_TOKEN_WHILE; }
185	"function" { RECORD; return GRUB_PARSER_TOKEN_FUNCTION; }
186
187	{MULTILINE} {
188	if (grub_lexer_unput (yytext, yyscanner))
189	return GRUB_PARSER_TOKEN_BAD;
190	}
191
192	{POS_MULTILINE} {
193	if (yyg->yy_c_buf_p + 1 == &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
194	{
195	if (grub_lexer_unput (yytext, yyscanner))
196	return GRUB_PARSER_TOKEN_BAD;
197	}
198	else
199	{
200	RECORD;
201	yypush_buffer_state (YY_CURRENT_BUFFER, yyscanner);
202	if (grub_lexer_resplit (yytext, yyscanner))
203	{
204	yypop_buffer_state (yyscanner);
205	return GRUB_PARSER_TOKEN_WORD;
206	}
207	yyextra->lexerstate->resplit = 1;
208	}
209	}
210
211
212	{NAME} { RECORD; return GRUB_PARSER_TOKEN_NAME; }
213	{WORD} {
214	RECORD;
215	yypush_buffer_state (YY_CURRENT_BUFFER, yyscanner);
216	if (grub_lexer_resplit (yytext, yyscanner))
217	{
218	yypop_buffer_state (yyscanner);
219	return GRUB_PARSER_TOKEN_WORD;
220	}
221	yyextra->lexerstate->resplit = 1;
222	}
223	. {
224	grub_script_yyerror (yyextra, yytext);
225	return GRUB_PARSER_TOKEN_BAD;
226	}
227
228	/* Split word into multiple args */
229
230	<SPLIT>{
231	\\. { COPY (yytext, yyleng); }
232	\\\n { /* ignore */ }
233	\" {
234	yy_push_state (DQUOTE, yyscanner);
235	ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
236	}
237	\' {
238	yy_push_state (SQUOTE, yyscanner);
239	ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
240	}
241	"\$\"" {
242	yy_push_state (I18NQUOTE, yyscanner);
243	ARG (GRUB_SCRIPT_ARG_TYPE_GETTEXT);
244	}
245	\$ {
246	yy_push_state (VAR, yyscanner);
247	ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
248	}
249	\\ \|
250	[^\"\'\$\\]+ { COPY (yytext, yyleng); }
251	<<EOF>> {
252	yy_pop_state (yyscanner);
253	yypop_buffer_state (yyscanner);
254	yyextra->lexerstate->resplit = 0;
255	yyextra->lexerstate->merge_end = 1;
256	ARG (GRUB_SCRIPT_ARG_TYPE_TEXT);
257	}
258	}
259
260	<VAR>{
261	{SPECIAL} \|
262	{DIGITS} \|
263	{NAME} {
264	COPY (yytext, yyleng);
265	yy_pop_state (yyscanner);
266	if (YY_START == SPLIT)
267	ARG (GRUB_SCRIPT_ARG_TYPE_VAR);
268	else
269	ARG (GRUB_SCRIPT_ARG_TYPE_DQVAR);
270	}
271	\{{SPECIAL}\} \|
272	\{{DIGITS}\} \|
273	\{{NAME}\} {
274	yytext[yyleng - 1] = '\0';
275	COPY (yytext + 1, yyleng - 2);
276	yy_pop_state (yyscanner);
277	if (YY_START == SPLIT)
278	ARG (GRUB_SCRIPT_ARG_TYPE_VAR);
279	else
280	ARG (GRUB_SCRIPT_ARG_TYPE_DQVAR);
281	}
282	.\|\n { return GRUB_PARSER_TOKEN_BAD; }
283	}
284
285	<SQUOTE>{
286	\' {
287	yy_pop_state (yyscanner);
288	ARG (GRUB_SCRIPT_ARG_TYPE_SQSTR);
289	}
290	[^\']+ { COPY (yytext, yyleng); }
291	}
292
293	<DQUOTE>{
294	\\\$ { COPY ("$", 1); }
295	\\\\ { COPY ("\\", 1); }
296	\\\" { COPY ("\"", 1); }
297	\\\n { /* ignore */ }
298	[^\"\$\\\n]+ { COPY (yytext, yyleng); }
299	\" {
300	yy_pop_state (yyscanner);
301	ARG (GRUB_SCRIPT_ARG_TYPE_DQSTR);
302	}
303	\$ {
304	yy_push_state (VAR, yyscanner);
305	ARG (GRUB_SCRIPT_ARG_TYPE_DQSTR);
306	}
307	(.\|\n) { COPY (yytext, yyleng); }
308	}
309
310	<I18NQUOTE>{
311	\\\\ { COPY ("\\\\", 2); }
312	\\\" { COPY ("\"", 1); }
313	\\\n { /* ignore */ }
314	[^\"\\\n]+ { COPY (yytext, yyleng); }
315	\" {
316	yy_pop_state (yyscanner);
317	ARG (GRUB_SCRIPT_ARG_TYPE_GETTEXT);
318	}
319	\\ { COPY ("\\", 1); }
320	(.\|\n) { COPY (yytext, yyleng); }
321	}
322
323	<<EOF>> {
324	yypop_buffer_state (yyscanner);
325	yyextra->lexerstate->eof = 1;
326	return GRUB_PARSER_TOKEN_EOF;
327	}
328	%%
329
330	int
331	yywrap (yyscan_t yyscanner)
332	{
333	if (yyget_extra (yyscanner)->lexerstate->resplit)
334	return 1;
335
336	return grub_script_lexer_yywrap (yyget_extra (yyscanner), 0);
337	}
338
339	static void copy_string (struct grub_parser_param parser, const char str, unsigned hint)
340	{
341	grub_size_t size;
342	char *ptr;
343	unsigned len;
344
345	len = hint ? hint : grub_strlen (str);
346	if (parser->lexerstate->used + len >= parser->lexerstate->size)
347	{
348	size = len * 2;
349	if (size < parser->lexerstate->size * 2)
350	size = parser->lexerstate->size * 2;
351	ptr = grub_realloc (parser->lexerstate->text, size);
352	if (!ptr)
353	{
354	grub_script_yyerror (parser, 0);
355	return;
356	}
357
358	parser->lexerstate->text = ptr;
359	parser->lexerstate->size = size;
360	}
361	grub_strcpy (parser->lexerstate->text + parser->lexerstate->used - 1, str);
362	parser->lexerstate->used += len;
363	}
364
365	static int
366	grub_lexer_resplit (const char *text, yyscan_t yyscanner)
367	{
368	/* resplit text */
369	if (yy_scan_string (text, yyscanner))
370	{
371	yyget_extra (yyscanner)->lexerstate->merge_start = 1;
372	yy_push_state (SPLIT, yyscanner);
373	return 0;
374	}
375	grub_script_yyerror (yyget_extra (yyscanner), 0);
376	return 1;
377	}
378
379	static int
380	grub_lexer_unput (const char *text, yyscan_t yyscanner)
381	{
382	struct grub_lexer_param *lexerstate = yyget_extra (yyscanner)->lexerstate;
383
384	grub_free (lexerstate->prefix);
385
386	lexerstate->prefix = grub_strdup (text);
387	if (! lexerstate->prefix)
388	{
389	grub_script_yyerror (yyget_extra (yyscanner), N_("out of memory"));
390	return 1;
391	}
392	return 0;
393	}