/* Copyright (c) 2013 Yoran Heling

  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:

  The above copyright notice and this permission notice shall be included
  in all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include <yxml.h>
#include <string.h>

typedef enum {
	YXMLS_string,
/*=STATES=*/
} yxml_state_t;


#define yxml_isChar(c) 1
/* 0xd should be part of SP, too, but yxml_parse() already normalizes that into 0xa */
#define yxml_isSP(c) (c == 0x20 || c == 0x09 || c == 0x0a)
#define yxml_isAlpha(c) ((c|32)-'a' < 26)
#define yxml_isNum(c) (c-'0' < 10)
#define yxml_isHex(c) (yxml_isNum(c) || (c|32)-'a' < 6)
#define yxml_isEncName(c) (yxml_isAlpha(c) || yxml_isNum(c) || c == '.' || c == '_' || c == '-')
#define yxml_isNameStart(c) (yxml_isAlpha(c) || c == ':' || c == '_' || c >= 128)
#define yxml_isName(c) (yxml_isNameStart(c) || yxml_isNum(c) || c == '-' || c == '.')
/* XXX: The valid characters are dependent on the quote char, hence the access to x->quote */
#define yxml_isAttValue(c) (yxml_isChar(c) && c != x->quote && c != '<' && c != '&')
/* Anything between '&' and ';', the yxml_ref* functions will do further
 * validation. Strictly speaking, this is "yxml_isName(c) || c == '#'", but
 * this parser doesn't understand entities with '.', ':', etc, anwyay.  */
#define yxml_isRef(c) (yxml_isNum(c) || yxml_isAlpha(c) || c == '#')

#define INTFROM5CHARS(a, b, c, d, e) ((((uint64_t)(a))<<32) | (((uint64_t)(b))<<24) | (((uint64_t)(c))<<16) | (((uint64_t)(d))<<8) | (uint64_t)(e))


/* Set the given char value to ch (0<=ch<=255).
 * This can't be done with simple assignment because char may be signed, and
 * unsigned-to-signed overflow is implementation defined in C. This function
 * /looks/ inefficient, but gcc compiles it down to a single movb instruction
 * on x86, even with -O0. */
static inline void yxml_setchar(char *dest, unsigned ch) {
	unsigned char _ch = ch;
	memcpy(dest, &_ch, 1);
}


/* Similar to yxml_setchar(), but will convert ch (any valid unicode point) to
 * UTF-8 and appends a '\0'. dest must have room for at least 5 bytes. */
static void yxml_setutf8(char *dest, unsigned ch) {
	if(ch <= 0x007F)
		yxml_setchar(dest++, ch);
	else if(ch <= 0x07FF) {
		yxml_setchar(dest++, 0xC0 | (ch>>6));
		yxml_setchar(dest++, 0x80 | (ch & 0x3F));
	} else if(ch <= 0xFFFF) {
		yxml_setchar(dest++, 0xE0 | (ch>>12));
		yxml_setchar(dest++, 0x80 | ((ch>>6) & 0x3F));
		yxml_setchar(dest++, 0x80 | (ch & 0x3F));
	} else {
		yxml_setchar(dest++, 0xF0 | (ch>>18));
		yxml_setchar(dest++, 0x80 | ((ch>>12) & 0x3F));
		yxml_setchar(dest++, 0x80 | ((ch>>6) & 0x3F));
		yxml_setchar(dest++, 0x80 | (ch & 0x3F));
	}
	*dest = 0;
}


static inline int yxml_datacontent(yxml_t *x, unsigned ch) {
	yxml_setchar(x->data, ch);
	x->data[1] = 0;
	return YXML_CONTENT;
}


static inline int yxml_datapi1(yxml_t *x, unsigned ch) {
	yxml_setchar(x->data, ch);
	x->data[1] = 0;
	return YXML_PICONTENT;
}


static inline int yxml_datapi2(yxml_t *x, unsigned ch) {
	x->data[0] = '?';
	yxml_setchar(x->data+1, ch);
	x->data[2] = 0;
	return YXML_PICONTENT;
}


static inline int yxml_datacd1(yxml_t *x, unsigned ch) {
	x->data[0] = ']';
	yxml_setchar(x->data+1, ch);
	x->data[2] = 0;
	return YXML_CONTENT;
}


static inline int yxml_datacd2(yxml_t *x, unsigned ch) {
	x->data[0] = ']';
	x->data[1] = ']';
	yxml_setchar(x->data+2, ch);
	x->data[3] = 0;
	return YXML_CONTENT;
}


static inline int yxml_dataattr(yxml_t *x, unsigned ch) {
	/* Normalize attribute values according to the XML spec section 3.3.3. */
	yxml_setchar(x->data, ch == 0x9 || ch == 0xa ? 0x20 : ch);
	x->data[1] = 0;
	return YXML_ATTRVAL;
}


static int yxml_pushstack(yxml_t *x, char **res, unsigned ch) {
	if(x->stacklen+2 >= x->stacksize)
		return YXML_ESTACK;
	x->stacklen++;
	*res = (char *)x->stack+x->stacklen;
	x->stack[x->stacklen] = ch;
	x->stacklen++;
	x->stack[x->stacklen] = 0;
	return YXML_OK;
}


static int yxml_pushstackc(yxml_t *x, unsigned ch) {
	if(x->stacklen+1 >= x->stacksize)
		return YXML_ESTACK;
	x->stack[x->stacklen] = ch;
	x->stacklen++;
	x->stack[x->stacklen] = 0;
	return YXML_OK;
}


static void yxml_popstack(yxml_t *x) {
	do
		x->stacklen--;
	while(x->stack[x->stacklen]);
}


static inline int yxml_elemstart  (yxml_t *x, unsigned ch) { return yxml_pushstack(x, &x->elem, ch); }
static inline int yxml_elemname   (yxml_t *x, unsigned ch) { return yxml_pushstackc(x, ch); }
static inline int yxml_elemnameend(yxml_t *x, unsigned ch) { return YXML_ELEMSTART; }


/* Also used in yxml_elemcloseend(), since this function just removes the last
 * element from the stack and returns ELEMEND. */
static int yxml_selfclose(yxml_t *x, unsigned ch) {
	yxml_popstack(x);
	if(x->stacklen) {
		x->elem = (char *)x->stack+x->stacklen-1;
		while(*(x->elem-1))
			x->elem--;
		return YXML_ELEMEND;
	}
	x->elem = (char *)x->stack;
	x->state = YXMLS_misc3;
	return YXML_ELEMEND;
}


static inline int yxml_elemclose(yxml_t *x, unsigned ch) {
	if(*((unsigned char *)x->elem) != ch)
		return YXML_ECLOSE;
	x->elem++;
	return YXML_OK;
}


static inline int yxml_elemcloseend(yxml_t *x, unsigned ch) {
	if(*x->elem)
		return YXML_ECLOSE;
	return yxml_selfclose(x, ch);
}


static inline int yxml_attrstart  (yxml_t *x, unsigned ch) { return yxml_pushstack(x, &x->attr, ch); }
static inline int yxml_attrname   (yxml_t *x, unsigned ch) { return yxml_pushstackc(x, ch); }
static inline int yxml_attrnameend(yxml_t *x, unsigned ch) { return YXML_ATTRSTART; }
static inline int yxml_attrvalend (yxml_t *x, unsigned ch) { yxml_popstack(x); return YXML_ATTREND; }


static inline int yxml_pistart  (yxml_t *x, unsigned ch) { return yxml_pushstack(x, &x->pi, ch); }
static inline int yxml_piname   (yxml_t *x, unsigned ch) { return yxml_pushstackc(x, ch); }
static inline int yxml_pinameend(yxml_t *x, unsigned ch) {
	return (x->pi[0]|32) == 'x' && (x->pi[1]|32) == 'm' && (x->pi[2]|32) == 'l' && !x->pi[3] ? YXML_ESYN : YXML_PISTART;
}
static inline int yxml_pivalend (yxml_t *x, unsigned ch) { yxml_popstack(x); x->pi = (char *)x->stack; return YXML_PIEND; }


static inline int yxml_refstart(yxml_t *x, unsigned ch) {
	memset(x->data, 0, sizeof(x->data));
	x->reflen = 0;
	return YXML_OK;
}


static int yxml_ref(yxml_t *x, unsigned ch) {
	if(x->reflen >= sizeof(x->data)-1)
		return YXML_EREF;
	yxml_setchar(x->data+x->reflen, ch);
	x->reflen++;
	return YXML_OK;
}


static int yxml_refend(yxml_t *x, int ret) {
	unsigned char *r = (unsigned char *)x->data;
	unsigned ch = 0;
	if(*r == '#') {
		if(r[1] == 'x')
			for(r += 2; yxml_isHex((unsigned)*r); r++)
				ch = (ch<<4) + (*r <= '9' ? *r-'0' : (*r|32)-'a' + 10);
		else
			for(r++; yxml_isNum((unsigned)*r); r++)
				ch = (ch*10) + (*r-'0');
		if(*r)
			ch = 0;
	} else {
		uint64_t i = INTFROM5CHARS(r[0], r[1], r[2], r[3], r[4]);
		ch =
			i == INTFROM5CHARS('l','t', 0,  0, 0) ? '<' :
			i == INTFROM5CHARS('g','t', 0,  0, 0) ? '>' :
			i == INTFROM5CHARS('a','m','p', 0, 0) ? '&' :
			i == INTFROM5CHARS('a','p','o','s',0) ? '\'':
			i == INTFROM5CHARS('q','u','o','t',0) ? '"' : 0;
	}

	/* Codepoints not allowed in the XML 1.1 definition of a Char */
	if(!ch || ch > 0x10FFFF || ch == 0xFFFE || ch == 0xFFFF || (ch-0xDFFF) < 0x7FF)
		return YXML_EREF;
	yxml_setutf8(x->data, ch);
	return ret;
}


static inline int yxml_refcontent(yxml_t *x, unsigned ch) { return yxml_refend(x, YXML_CONTENT); }
static inline int yxml_refattrval(yxml_t *x, unsigned ch) { return yxml_refend(x, YXML_ATTRVAL); }


void yxml_init(yxml_t *x, void *stack, size_t stacksize) {
	memset(x, 0, sizeof(*x));
	x->line = 1;
	x->stack = stack;
	x->stacksize = stacksize;
	*x->stack = 0;
	x->elem = x->pi = x->attr = (char *)x->stack;
	x->state = YXMLS_init;
}


yxml_ret_t yxml_parse(yxml_t *x, int _ch) {
	/* Ensure that characters are in the range of 0..255 rather than -126..125.
	 * All character comparisons are done with positive integers. */
	unsigned ch = (unsigned)(_ch+256) & 0xff;
	if(!ch)
		return YXML_ESYN;
	x->total++;

	/* End-of-Line normalization, "\rX", "\r\n" and "\n" are recognized and
	 * normalized to a single '\n' as per XML 1.0 section 2.11. XML 1.1 adds
	 * some non-ASCII character sequences to this list, but we can only handle
	 * ASCII here without making assumptions about the input encoding. */
	if(x->ignore == ch) {
		x->ignore = 0;
		return YXML_OK;
	}
	x->ignore = (ch == 0xd) * 0xa;
	if(ch == 0xa || ch == 0xd) {
		ch = 0xa;
		x->line++;
		x->byte = 0;
	}
	x->byte++;

	switch((yxml_state_t)x->state) {
	case YXMLS_string:
		if(ch == *x->string) {
			x->string++;
			if(!*x->string)
				x->state = x->nextstate;
			return YXML_OK;
		}
		break;
/*=SWITCH=*/
	}
	return YXML_ESYN;
}


yxml_ret_t yxml_eof(yxml_t *x) {
	if(x->state != YXMLS_misc3)
		return YXML_EEOF;
	return YXML_OK;
}


/* vim: set noet sw=4 ts=4: */