%option nostdinit noyywrap never-interactive full ecs
  %option 8bit nodefault perf-report perf-report

  %option noinput

  %x COMMAND HELP STRING PARAM
  %{
  /*
   * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
   * Released under the terms of the GNU GPL v2.0.
   */
  
  #include <limits.h>
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>

  #include "lkc.h"
  
  #define START_STRSIZE	16

  static struct {
  	struct file *file;
  	int lineno;
  } current_pos;

  static char *text;

  static int text_size, text_asize;
  
  struct buffer {
          struct buffer *parent;
          YY_BUFFER_STATE state;
  };
  
  struct buffer *current_buf;
  
  static int last_ts, first_ts;
  
  static void zconf_endhelp(void);

  static void zconf_endfile(void);

  static void new_string(void)

  {
  	text = malloc(START_STRSIZE);
  	text_asize = START_STRSIZE;

  	text_size = 0;

  	*text = 0;

  }

  static void append_string(const char *str, int size)

  {
  	int new_size = text_size + size + 1;
  	if (new_size > text_asize) {

  		new_size += START_STRSIZE - 1;
  		new_size &= -START_STRSIZE;

  		text = realloc(text, new_size);
  		text_asize = new_size;

  	}

  	memcpy(text + text_size, str, size);

  	text_size += size;

  	text[text_size] = 0;

  }

  static void alloc_string(const char *str, int size)

  {
  	text = malloc(size + 1);
  	memcpy(text, str, size);
  	text[size] = 0;
  }
  %}
  
  ws	[ 
  \t]
  n	[A-Za-z0-9_]
  
  %%
  	int str = 0;
  	int ts, i;

  [ \t]*#.*
  	|
  [ \t]*
  	{
  	current_file->lineno++;
  	return T_EOL;
  }

  [ \t]*#.*

  
  [ \t]+	{
  	BEGIN(COMMAND);
  }
  
  .	{
  	unput(yytext[0]);
  	BEGIN(COMMAND);
  }
  
  
  <COMMAND>{

  	{n}+	{

  		const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);

  		BEGIN(PARAM);
  		current_pos.file = current_file;
  		current_pos.lineno = current_file->lineno;

  		if (id && id->flags & TF_COMMAND) {

  			zconflval.id = id;

  			return id->token;
  		}

  		alloc_string(yytext, yyleng);
  		zconflval.string = text;
  		return T_WORD;
  	}
  	.

  	
  	{
  		BEGIN(INITIAL);
  		current_file->lineno++;
  		return T_EOL;
  	}

  }
  
  <PARAM>{
  	"&&"	return T_AND;
  	"||"	return T_OR;
  	"("	return T_OPEN_PAREN;
  	")"	return T_CLOSE_PAREN;
  	"!"	return T_NOT;
  	"="	return T_EQUAL;
  	"!="	return T_UNEQUAL;

  	\"|\'	{
  		str = yytext[0];
  		new_string();
  		BEGIN(STRING);
  	}
  	
  	BEGIN(INITIAL); current_file->lineno++; return T_EOL;
  	---	/* ignore */
  	({n}|[-/.])+	{

  		const struct kconf_id *id = kconf_id_lookup(yytext, yyleng);

  		if (id && id->flags & TF_PARAM) {
  			zconflval.id = id;

  			return id->token;

  		}

  		alloc_string(yytext, yyleng);
  		zconflval.string = text;
  		return T_WORD;
  	}
  	#.*	/* comment */
  	\\
  	current_file->lineno++;
  	.
  	<<EOF>> {
  		BEGIN(INITIAL);
  	}
  }
  
  <STRING>{
  	[^'"\\
  ]+/
  	{
  		append_string(yytext, yyleng);
  		zconflval.string = text;
  		return T_WORD_QUOTE;
  	}
  	[^'"\\
  ]+	{
  		append_string(yytext, yyleng);
  	}
  	\\.?/
  	{
  		append_string(yytext + 1, yyleng - 1);
  		zconflval.string = text;
  		return T_WORD_QUOTE;
  	}
  	\\.?	{
  		append_string(yytext + 1, yyleng - 1);
  	}
  	\'|\"	{
  		if (str == yytext[0]) {
  			BEGIN(PARAM);
  			zconflval.string = text;
  			return T_WORD_QUOTE;
  		} else
  			append_string(yytext, 1);
  	}
  	
  	{
  		printf("%s:%d:warning: multi-line strings not supported
  ", zconf_curname(), zconf_lineno());
  		current_file->lineno++;
  		BEGIN(INITIAL);
  		return T_EOL;
  	}
  	<<EOF>>	{
  		BEGIN(INITIAL);
  	}
  }
  
  <HELP>{
  	[ \t]+	{
  		ts = 0;
  		for (i = 0; i < yyleng; i++) {
  			if (yytext[i] == '\t')
  				ts = (ts & ~7) + 8;
  			else
  				ts++;
  		}
  		last_ts = ts;
  		if (first_ts) {
  			if (ts < first_ts) {
  				zconf_endhelp();
  				return T_HELPTEXT;
  			}
  			ts -= first_ts;
  			while (ts > 8) {
  				append_string("        ", 8);
  				ts -= 8;
  			}
  			append_string("        ", ts);
  		}
  	}
  	[ \t]*
  /[^ \t
  ] {
  		current_file->lineno++;
  		zconf_endhelp();
  		return T_HELPTEXT;
  	}
  	[ \t]*
  	{
  		current_file->lineno++;
  		append_string("
  ", 1);
  	}
  	[^ \t
  ].* {

  		while (yyleng) {
  			if ((yytext[yyleng-1] != ' ') && (yytext[yyleng-1] != '\t'))
  				break;
  			yyleng--;
  		}

  		append_string(yytext, yyleng);
  		if (!first_ts)
  			first_ts = last_ts;
  	}
  	<<EOF>>	{
  		zconf_endhelp();
  		return T_HELPTEXT;
  	}
  }
  
  <<EOF>>	{

  	if (current_file) {

  		zconf_endfile();

  		return T_EOL;

  	}
  	fclose(yyin);
  	yyterminate();
  }
  
  %%
  void zconf_starthelp(void)
  {
  	new_string();
  	last_ts = first_ts = 0;
  	BEGIN(HELP);
  }
  
  static void zconf_endhelp(void)
  {
  	zconflval.string = text;
  	BEGIN(INITIAL);
  }
  
  
  /*
   * Try to open specified file with following names:
   * ./name
   * $(srctree)/name
   * The latter is used when srctree is separate from objtree
   * when compiling the kernel.
   * Return NULL if file is not found.
   */
  FILE *zconf_fopen(const char *name)
  {
  	char *env, fullname[PATH_MAX+1];
  	FILE *f;
  
  	f = fopen(name, "r");

  	if (!f && name != NULL && name[0] != '/') {

  		env = getenv(SRCTREE);
  		if (env) {
  			sprintf(fullname, "%s/%s", env, name);
  			f = fopen(fullname, "r");
  		}
  	}
  	return f;
  }
  
  void zconf_initscan(const char *name)
  {
  	yyin = zconf_fopen(name);
  	if (!yyin) {
  		printf("can't find file %s
  ", name);
  		exit(1);
  	}
  
  	current_buf = malloc(sizeof(*current_buf));
  	memset(current_buf, 0, sizeof(*current_buf));
  
  	current_file = file_lookup(name);
  	current_file->lineno = 1;

  }
  
  void zconf_nextfile(const char *name)
  {

  	struct file *iter;

  	struct file *file = file_lookup(name);
  	struct buffer *buf = malloc(sizeof(*buf));
  	memset(buf, 0, sizeof(*buf));
  
  	current_buf->state = YY_CURRENT_BUFFER;

  	yyin = zconf_fopen(file->name);

  	if (!yyin) {

  		printf("%s:%d: can't open file \"%s\"
  ",
  		    zconf_curname(), zconf_lineno(), file->name);

  		exit(1);
  	}
  	yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE));
  	buf->parent = current_buf;
  	current_buf = buf;

  	for (iter = current_file->parent; iter; iter = iter->parent ) {
  		if (!strcmp(current_file->name,iter->name) ) {
  			printf("%s:%d: recursive inclusion detected. "
  			       "Inclusion path:
    current file : '%s'
  ",
  			       zconf_curname(), zconf_lineno(),
  			       zconf_curname());
  			iter = current_file->parent;
  			while (iter && \
  			       strcmp(iter->name,current_file->name)) {
  				printf("  included from: '%s:%d'
  ",
  				       iter->name, iter->lineno-1);
  				iter = iter->parent;
  			}
  			if (iter)
  				printf("  included from: '%s:%d'
  ",
  				       iter->name, iter->lineno+1);
  			exit(1);
  		}

  	}

  	file->lineno = 1;
  	file->parent = current_file;
  	current_file = file;
  }

  static void zconf_endfile(void)

  {
  	struct buffer *parent;

  	current_file = current_file->parent;
  
  	parent = current_buf->parent;
  	if (parent) {
  		fclose(yyin);
  		yy_delete_buffer(YY_CURRENT_BUFFER);
  		yy_switch_to_buffer(parent->state);
  	}
  	free(current_buf);
  	current_buf = parent;

  }
  
  int zconf_lineno(void)
  {

  	return current_pos.lineno;

  }

  const char *zconf_curname(void)

  {

  	return current_pos.file ? current_pos.file->name : "<none>";

  }