%{
#include <stdio.h>
#include <string.h>
#include "y.tab.h"
#include "element_path.h"

/*<XML_ATTLIST_DECLARATION>":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]*/
/* FIXME more */

/* TODO
  NotationDecl := '<!NOTATION' S  Name  S (ExternalID | PublicID) S? '>'; */

/* FIXME where to use INCLUDE and IGNORE? */
/* FIXME namechar in  ENTITY_REFERENCE */
/* FIXME elementdecl '*' '(' ')' */

/*<XML_BODY>[^< \t\015\012]* {
	yylval.text = strdup(yytext);
	return BLURB;
}*/

void lex_init () {
#warning workaround
#define XML_UNDECIDED 17
	BEGIN XML_UNDECIDED;
}

/*stop*/    /*printf("Stop command received\n")*/;
/*start   {}*/

static int decode_character_reference(const char* format, const char* str) {
	int result;
	/* FIXME */
	if(sscanf(str, format, &result) != 1 || yylval.symbol < 0) {
		return -1;
	}
	return result;
}

%}
%Start XML_HEADER XML_ATTLIST_DECLARATION XML_ELEMENT_DECLARATION XML_ATTRIBUTE XML_DOCTYPE XML_NOTATION_DECLARATION XML_GE_ENTITY_DECLARATION XML_INCLUDE XML_IGNORE XML_ATTRIBUTE_VALUE XML_ATTRIBUTE_VALUE_S XML_ENDTAG XML_PI XML_CDATA XML_BODY XML_ATTRIBUTE_VALUE_HTML3 XML_UNDECIDED XML_COMMENT XML_PI_ATTRIBUTE_VALUE
%%

<XML_UNDECIDED>"<" {
		BEGIN XML_ATTRIBUTE;
		return '<';
/* TODO XML comment which is ignored? */
	}

<XML_UNDECIDED>"<?xml"[ \t\015\12]+	{ /* FIXME immediate "?>"? */
		BEGIN XML_HEADER;
		return BEGIN_XML;

	}
<XML_UNDECIDED>"<?" {
	BEGIN XML_PI;
	return TPI;
}
<XML_UNDECIDED>"<!DOCTYPE"	{
			BEGIN XML_DOCTYPE;
			return DOCTYPE_KEYWORD;
		}

	
<XML_HEADER>"version"	return VERSION;
<XML_HEADER>"="	return '=';
<XML_HEADER>"encoding"	return ENCODING;
<XML_HEADER>"\""[^\"]*"\""	{
	/*assert(yytext[0]);*/
	yylval.text = strdup(&yytext[1]);
	yylval.text[strlen(yylval.text) - 1] = 0;
	return QUOTED_STRING;
}
<XML_HEADER>"standalone" return STANDALONE;
<XML_HEADER>[ \t\015\012]* {
	/* TODO: move that to attribute and element definitions? */
	return S;
}

<XML_HEADER>"?>"	{
	BEGIN XML_UNDECIDED;
	return END_PI;
}

<XML_PI>[^?]* {
/*[#a-zA-Z:_-][a-zA-Z:_0-9-]* {*/
	yylval.text = strdup(yytext);
	return NAME;
	/*
<XML_PI>"=" {
	BEGIN XML_PI_ATTRIBUTE_VALUE;
	return '=';
}
	
	*/
}

<XML_PI>"?>" {
	BEGIN XML_UNDECIDED;
	return END_PI;
}

<XML_PI_ATTRIBUTE_VALUE>[^<&\"]* {
	yylval.text = strdup(yytext);
	return ATTRIBUTE_VALUE;
}

<XML_PI_ATTRIBUTE_VALUE>"\"" {
	BEGIN XML_PI;
	return '"';
}


<XML_BODY>[^<&]* {
	/* FIXME what about PIs? */
	/* modified for whitespacelessness. */
	/* pattern contains workaround for people who do "<script>...if(a>3) foo;...</script> */
	yylval.text = strdup(yytext);
	return BLURB;
}
	
"<!ELEMENT"	{
			BEGIN XML_ELEMENT_DECLARATION;
			return ELEMENT_KEYWORD;
		}
<XML_ELEMENT_DECLARATION>"?" {
	return '?';
}

<XML_ELEMENT_DECLARATION>"*" {
	return '*';
}

<XML_ELEMENT_DECLARATION>'+' {
	return '+';
}

<XML_ELEMENT_DECLARATION>"(" {
	return '(';
}

<XML_ELEMENT_DECLARATION>")" {
	return ')';
}

<XML_ELEMENT_DECLARATION>"|" {
	return '|';
}

<XML_ELEMENT_DECLARATION>"," {
	return ',';
}

<XML_ELEMENT_DECLARATION>"#PCDATA" {
	return PCDATA;
}

<XML_ELEMENT_DECLARATION>"EMPTY" {
	return EMPTY;
}

<XML_ELEMENT_DECLARATION>"ANY" {
	return ANY;
}

<XML_ELEMENT_DECLARATION>">"	{
		BEGIN INITIAL;
		return '>';
}

"<!ATTLIST" {
	BEGIN XML_ATTLIST_DECLARATION;
	return ATTLIST_KEYWORD;
}

<XML_ATTLIST_DECLARATION>"NOTATION" {
	return NOTATION;
}
<XML_ATTLIST_DECLARATION>"(" {
	return '(';
}

<XML_ATTLIST_DECLARATION>"ID" {
	return ID;
}

<XML_ATTLIST_DECLARATION>"IDREF" {
	return IDREF;
}

<XML_ATTLIST_DECLARATION>"IDREFS" {
	return IDREFS;
}

<XML_ATTLIST_DECLARATION>"ENTITY" {
	return ENTITY;
}

<XML_ATTLIST_DECLARATION>"ENTITIES" {
	return ENTITIES;
}

<XML_ATTLIST_DECLARATION>"NMTOKEN" {
	return NMTOKEN;
}
<XML_ATTLIST_DECLARATION>"NMTOKENS" {
	return NMTOKENS;
}
<XML_ATTLIST_DECLARATION>"CDATA" {
	return CDATA;
}
<XML_ATTLIST_DECLARATION>")" {
	return ')';
}
<XML_ATTLIST_DECLARATION>"|" {
	return '|';
}
<XML_ATTLIST_DECLARATION>"ordered" {
	return ORDERED;
}

<XML_ATTLIST_DECLARATION>'=' {
	return '=';
}
<XML_ATTLIST_DECLARATION>[:_A-Za-z.0-9]+ {
	yylval.text = strdup(yytext);
	return NAME; /* FIXME MORE CHARACTERS (NameChar|NameStartChar) */
}

<XML_ATTLIST_DECLARATION>"#REQUIRED" {
	return REQUIRED;
}

<XML_ATTLIST_DECLARATION>"#IMPLIED" {
	return IMPLIED;
}

<XML_ATTLIST_DECLARATION>"#FIXED" {  /* FIXME and then the attribute value. */
	return FIXED; 
}

<XML_ATTRIBUTE_VALUE>[^<&\"]* {
	yylval.text = strdup(yytext);
	return ATTRIBUTE_VALUE;
}


"&&" {
	/* technically, this is wrong. But everyone does it. */
	yylval.text = strdup("&&");
	return ENTITY_REFERENCE;
}

"&"[a-zA-Z_:][a-zA-Z_:0-9]*";" {
	yylval.text = strdup(yytext);
	return ENTITY_REFERENCE;
}


<XML_ATTRIBUTE_VALUE>"\"" {
	BEGIN XML_ATTRIBUTE;
	return '"';
}

<XML_ATTRIBUTE_VALUE_S>[^&<\']* {
	yylval.text = strdup(yytext);
	return ATTRIBUTE_VALUE;
}

<XML_ATTRIBUTE_VALUE_S>"&"[a-zA-Z_][a-zA-Z_0-9]*";" {
	yylval.text = strdup(yytext);
	return ENTITY_REFERENCE;
}

<XML_ATTRIBUTE_VALUE_S>"\'" {
	BEGIN XML_ATTRIBUTE;
	return '"';
}

<XML_ATTRIBUTE>">" {
	BEGIN XML_BODY;
	return '>';
}
<XML_ATTRIBUTE>"/" {
	return '/';
}

<XML_ATTRIBUTE>[#a-zA-Z:_0-9-][a-zA-Z:_0-9-]* {
	yylval.text = strdup(yytext); /* moooore chars */
	return NAME; /* FIXME more chars */
}

<XML_ATTRIBUTE>"=" {
	BEGIN XML_ATTRIBUTE_VALUE_HTML3;
	return '=';
}

<XML_ATTRIBUTE_VALUE_HTML3>[#a-zA-Z:_/?0-9=().%-][a-zA-Z:_/?0-9=().%-]* {
	/* this is also used for HTML-style <x a=b> attribute values. */
	yylval.text = strdup(yytext);
	BEGIN XML_ATTRIBUTE;
	return NAME; /*ATTRIBUTE_VALUE;*/ /* FIXME more chars */
}

<XML_ATTRIBUTE_VALUE_HTML3>"\"" {
	BEGIN XML_ATTRIBUTE_VALUE;
	return '"';
}
<XML_ATTRIBUTE_VALUE_HTML3>"\'" {
	BEGIN XML_ATTRIBUTE_VALUE_S;
	return '"';
}

<XML_DOCTYPE>"\""[^\"]*"\"" {
	yylval.text = strdup(&yytext[1]);
	yylval.text[strlen(yylval.text) - 1] = 0;
	return QUOTED_STRING;
}

<XML_DOCTYPE>"'"[^\']*"'" {
	yylval.text = strdup(&yytext[1]);
	yylval.text[strlen(yylval.text) - 1] = 0;
	return QUOTED_STRING;
}



<XML_COMMENT>"-->" {
	BEGIN XML_BODY;
	return END_COMMENT;
}

<XML_COMMENT>[^-]* {
	yylval.text = strdup(yytext);
	return BLURB;
}

<XML_COMMENT>"-" {
	yylval.text = strdup(".");
	return BLURB;
}

<XML_BODY>"<!--" {
	BEGIN XML_COMMENT;
	return COMMENT;
	/* TODO limited set of valid characters in comment. */
	/* TODO "--"[^>] invalid */
	/* TODO "-" valid */
	/* TODO nested comments */
}

<XML_BODY>"</" {
	BEGIN XML_ENDTAG;
	return ENDTAG;
}

<XML_BODY>"<" {
	/* workaround for people who do "<script>...if(a<3) foo;...</script> */
	if(!element_path_name_equals(element_path_last, "script")) {
		BEGIN XML_ATTRIBUTE;
		return '<';
	} else {
		yymore(); /* and now? */
		/*exit(1);*/
/*		yylval.text = strdup("<");
		return NAME;*/
	}
}

<XML_BODY>"%%%%%%%%%%%"[a-zA-Z_0-9]+";" {
	/* FIXME move PIs to where they are actually allowed (XML_PI? XML_DOCTYPE?)
	/* FIXME allow more valid characters */
	yylval.text = strdup(yytext);
	return '%';
}

<XML_BODY>"<!["[ \t\015\012]*"INCLUDE" {
	/* FIXME */
	BEGIN XML_INCLUDE;
	return INCLUDE_KEYWORD;
}
<XML_BODY>"<?" { /* TODO only allow these at the beginning? */
	BEGIN XML_PI;
	return TPI;
}

<XML_BODY>"<![CDATA[" {
	BEGIN XML_CDATA;
	return CDATA;
}
<XML_BODY>"<!["[ \t\015\012]*"IGNORE" {
	BEGIN XML_IGNORE; /* FIXME */
	return IGNORE_KEYWORD;
}

<XML_BODY>"<!NOTATION" {
	BEGIN XML_NOTATION_DECLARATION; /* FIXME */
	return NOTATION_KEYWORD;
}
<XML_NOTATION_DECLARATION>">" {
	return '>';
}

"<!ENTITY"[ \t\015\012]"%" {
	/* FIXME BEGIN XML_PE_ENTITY_DECLARATION ? */
	return PE_ENTITY_KEYWORD;
}

"<!ENTITY"[ \t\015\012] { /* [^%] */
	BEGIN XML_GE_ENTITY_DECLARATION;
	return GE_ENTITY_KEYWORD;
}

<XML_ENDTAG>">" {
	if(element_paths && element_paths->next) {
		BEGIN XML_BODY;
	} else { /* </HTML>, make sure whitespace is detected as whitespace after it. */
		BEGIN XML_UNDECIDED;
	}
	return END_ENDTAG;
}
<XML_ENDTAG>[ \t\015\012] {
	return S;
}
<XML_ENDTAG>[#a-zA-Z_:0-9]+ {
	yylval.text = strdup(yytext);
	return NAME;
}


<XML_DOCTYPE>"SYSTEM" {
	return SYSTEM;
}
<XML_DOCTYPE>"PUBLIC" {
	return PUBLIC;
}
<XML_DOCTYPE>[#a-zA-Z:_-][a-zA-Z:_0-9-]* {
	yylval.text = strdup(yytext);
	return NAME; /* FIXME more valid characters */
}

<XML_DOCTYPE>"[" {
	return '[';
}
<XML_DOCTYPE>"]" {
	return ']';
}
<XML_DOCTYPE>">"[ \t\015\012]* {
	BEGIN XML_BODY;
	return '>';
}

<XML_NOTATION_DECLARATION>"SYSTEM" {
	return SYSTEM;
}
<XML_NOTATION_DECLARATION>"PUBLIC" {
	return PUBLIC;
}

<XML_GE_ENTITY_DECLARATION>"NDATA" {
	return NDATA;
}

<XML_GE_ENTITY_DECLARATION>"SYSTEM" {
	return SYSTEM;
}
<XML_GE_ENTITY_DECLARATION>"PUBLIC" {
	return PUBLIC;
}


<XML_INCLUDE>"[" {
	return '[';
}
<XML_INCLUDE>"]]>" {
	BEGIN XML_BODY;
	return END_BBBLOCK;
}

<XML_IGNORE>"<![" {
	return SECTION_BBLOCK;
}
<XML_IGNORE>"[" {
	return '[';
}
<XML_IGNORE>"]]>" {
	BEGIN XML_BODY;
	return END_BBBLOCK;
}
<XML_IGNORE>.* {
	return BLURB; /* FIXME limit to definition of XML'Char*' */
}


<XML_CDATA>[^]]* {
	/* FIXME */
	return BLURB;
}

<XML_CDATA>"]]>" {
	BEGIN XML_BODY;
	return END_BBBLOCK;
}

[ \t\015\012]* {
	/* TODO: move that to attribute and element definitions? */
	return S;
}


"&"[^#] { /* fallback if the entity reference is WRONG (i. e. no ";") */
	/* technically, this is wrong. But everyone does it. */
	yylval.text = strdup(yytext); /*"&X");*/
	return ENTITY_REFERENCE;
}

"&#x"[0-9a-fA-F]+";" {
	yylval.symbol = decode_character_reference("%X", &yytext[3]);
	return CHARACTER_REFERENCE;
}

"&#"[0-9]+";" {
	yylval.symbol = decode_character_reference("%d", &yytext[2]);
	return CHARACTER_REFERENCE;
}

%%