Context Navigation

← Previous Revision
Next Revision →
Normal
Revision Log

xmlrole.c

Visit:

Last change on this file was 98, checked in by umoeller, 24 years ago
Misc updates.
Property svn:eol-style set to `CRLF` Property svn:keywords set to `Author Date Id Revision`
File size: 30.5 KB

Rev	Line
[36]	1	/*
[97]	2	Copyright (c) 1998, 1999 Thai Open Source Software Center Ltd
	3	See the file COPYING for copying permission.
	4	*/
[36]	5
[97]	6	/* #ifdef COMPILED_FROM_DSP
	7	# include "winconfig.h"
	8	#else
	9	# include <config.h>
	10	#endif
	11	*/
[36]	12
	13	#include "expat\expat_setup.h" // V0.9.9 (2001-02-10) [umoeller]
	14
	15	#pragma info(norea, nogen)
	16	// disable "statement unreachable" and "missing break statement"
	17	// this code generates those options HEAVILY
	18
	19	#include "expat\xmlrole.h"
	20	#include "expat\ascii.h"
	21
	22	/* Doesn't check:
	23
[97]	24	that ,\| are not mixed in a model group
	25	content of literals
[36]	26
[97]	27	*/
	28
	29	static const char KW_ANY[] = { ASCII_A, ASCII_N, ASCII_Y, '\0' };
	30	static const char KW_ATTLIST[] = { ASCII_A, ASCII_T, ASCII_T, ASCII_L, ASCII_I, ASCII_S, ASCII_T, '\0' };
	31	static const char KW_CDATA[] = { ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
	32	static const char KW_DOCTYPE[] = { ASCII_D, ASCII_O, ASCII_C, ASCII_T, ASCII_Y, ASCII_P, ASCII_E, '\0' };
	33	static const char KW_ELEMENT[] = { ASCII_E, ASCII_L, ASCII_E, ASCII_M, ASCII_E, ASCII_N, ASCII_T, '\0' };
	34	static const char KW_EMPTY[] = { ASCII_E, ASCII_M, ASCII_P, ASCII_T, ASCII_Y, '\0' };
	35	static const char KW_ENTITIES[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_I, ASCII_E, ASCII_S, '\0' };
	36	static const char KW_ENTITY[] = { ASCII_E, ASCII_N, ASCII_T, ASCII_I, ASCII_T, ASCII_Y, '\0' };
	37	static const char KW_FIXED[] = { ASCII_F, ASCII_I, ASCII_X, ASCII_E, ASCII_D, '\0' };
	38	static const char KW_ID[] = { ASCII_I, ASCII_D, '\0' };
	39	static const char KW_IDREF[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, '\0' };
	40	static const char KW_IDREFS[] = { ASCII_I, ASCII_D, ASCII_R, ASCII_E, ASCII_F, ASCII_S, '\0' };
	41	static const char KW_IGNORE[] = { ASCII_I, ASCII_G, ASCII_N, ASCII_O, ASCII_R, ASCII_E, '\0' };
	42	static const char KW_IMPLIED[] = { ASCII_I, ASCII_M, ASCII_P, ASCII_L, ASCII_I, ASCII_E, ASCII_D, '\0' };
	43	static const char KW_INCLUDE[] = { ASCII_I, ASCII_N, ASCII_C, ASCII_L, ASCII_U, ASCII_D, ASCII_E, '\0' };
	44	static const char KW_NDATA[] = { ASCII_N, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
	45	static const char KW_NMTOKEN[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, '\0' };
	46	static const char KW_NMTOKENS[] = { ASCII_N, ASCII_M, ASCII_T, ASCII_O, ASCII_K, ASCII_E, ASCII_N, ASCII_S, '\0' };
	47	static const char KW_NOTATION[] = { ASCII_N, ASCII_O, ASCII_T, ASCII_A, ASCII_T, ASCII_I, ASCII_O, ASCII_N, '\0' };
	48	static const char KW_PCDATA[] = { ASCII_P, ASCII_C, ASCII_D, ASCII_A, ASCII_T, ASCII_A, '\0' };
	49	static const char KW_PUBLIC[] = { ASCII_P, ASCII_U, ASCII_B, ASCII_L, ASCII_I, ASCII_C, '\0' };
	50	static const char KW_REQUIRED[] = { ASCII_R, ASCII_E, ASCII_Q, ASCII_U, ASCII_I, ASCII_R, ASCII_E, ASCII_D, '\0' };
	51	static const char KW_SYSTEM[] = { ASCII_S, ASCII_Y, ASCII_S, ASCII_T, ASCII_E, ASCII_M, '\0' };
	52
[36]	53	#ifndef MIN_BYTES_PER_CHAR
	54	#define MIN_BYTES_PER_CHAR(enc) ((enc)->minBytesPerChar)
	55	#endif
	56
	57	#ifdef XML_DTD
	58	#define setTopLevel(state) \
	59	((state)->handler = ((state)->documentEntity \
	60	? internalSubset \
	61	: externalSubset1))
	62	#else /* not XML_DTD */
	63	#define setTopLevel(state) ((state)->handler = internalSubset)
	64	#endif /* not XML_DTD */
	65
[98]	66	typedef int EXPATENTRY PROLOG_HANDLER(PROLOG_STATE *state,
	67	int tok,
	68	const char *ptr,
	69	const char *end,
	70	const ENCODING *enc);
[36]	71
[97]	72	static PROLOG_HANDLER
	73	prolog0, prolog1, prolog2,
	74	doctype0, doctype1, doctype2, doctype3, doctype4, doctype5,
	75	internalSubset,
	76	entity0, entity1, entity2, entity3, entity4, entity5, entity6,
	77	entity7, entity8, entity9,
	78	notation0, notation1, notation2, notation3, notation4,
	79	attlist0, attlist1, attlist2, attlist3, attlist4, attlist5, attlist6,
	80	attlist7, attlist8, attlist9,
	81	element0, element1, element2, element3, element4, element5, element6,
	82	element7,
[36]	83	#ifdef XML_DTD
[97]	84	externalSubset0, externalSubset1,
	85	condSect0, condSect1, condSect2,
	86	#endif /* XML_DTD */
	87	declClose,
	88	error;
[36]	89
[97]	90	static
	91	int common(PROLOG_STATE *state, int tok);
[36]	92
[97]	93	static
[98]	94	int EXPATENTRY prolog0(PROLOG_STATE *state,
[97]	95	int tok,
	96	const char *ptr,
	97	const char *end,
	98	const ENCODING *enc)
[36]	99	{
[97]	100	switch (tok) {
	101	case XML_TOK_PROLOG_S:
	102	state->handler = prolog1;
	103	return XML_ROLE_NONE;
	104	case XML_TOK_XML_DECL:
	105	state->handler = prolog1;
	106	return XML_ROLE_XML_DECL;
	107	case XML_TOK_PI:
	108	state->handler = prolog1;
	109	return XML_ROLE_NONE;
	110	case XML_TOK_COMMENT:
	111	state->handler = prolog1;
	112	case XML_TOK_BOM:
	113	return XML_ROLE_NONE;
	114	case XML_TOK_DECL_OPEN:
	115	if (!XmlNameMatchesAscii(enc,
	116	ptr + 2 * MIN_BYTES_PER_CHAR(enc),
	117	end,
	118	KW_DOCTYPE))
	119	break;
	120	state->handler = doctype0;
	121	return XML_ROLE_NONE;
	122	case XML_TOK_INSTANCE_START:
	123	state->handler = error;
	124	return XML_ROLE_INSTANCE_START;
	125	}
	126	return common(state, tok);
[36]	127	}
	128
[97]	129	static
	130	int prolog1(PROLOG_STATE *state,
	131	int tok,
	132	const char *ptr,
	133	const char *end,
	134	const ENCODING *enc)
[36]	135	{
[97]	136	switch (tok) {
	137	case XML_TOK_PROLOG_S:
	138	return XML_ROLE_NONE;
	139	case XML_TOK_PI:
	140	case XML_TOK_COMMENT:
	141	case XML_TOK_BOM:
	142	return XML_ROLE_NONE;
	143	case XML_TOK_DECL_OPEN:
	144	if (!XmlNameMatchesAscii(enc,
	145	ptr + 2 * MIN_BYTES_PER_CHAR(enc),
	146	end,
	147	KW_DOCTYPE))
	148	break;
	149	state->handler = doctype0;
	150	return XML_ROLE_NONE;
	151	case XML_TOK_INSTANCE_START:
	152	state->handler = error;
	153	return XML_ROLE_INSTANCE_START;
	154	}
	155	return common(state, tok);
[36]	156	}
	157
[97]	158	static
	159	int prolog2(PROLOG_STATE *state,
	160	int tok,
	161	const char *ptr,
	162	const char *end,
	163	const ENCODING *enc)
[36]	164	{
[97]	165	switch (tok) {
	166	case XML_TOK_PROLOG_S:
	167	return XML_ROLE_NONE;
	168	case XML_TOK_PI:
	169	case XML_TOK_COMMENT:
	170	return XML_ROLE_NONE;
	171	case XML_TOK_INSTANCE_START:
	172	state->handler = error;
	173	return XML_ROLE_INSTANCE_START;
	174	}
	175	return common(state, tok);
[36]	176	}
	177
[97]	178	static
	179	int doctype0(PROLOG_STATE *state,
	180	int tok,
	181	const char *ptr,
	182	const char *end,
	183	const ENCODING *enc)
[36]	184	{
[97]	185	switch (tok) {
	186	case XML_TOK_PROLOG_S:
	187	return XML_ROLE_NONE;
	188	case XML_TOK_NAME:
	189	case XML_TOK_PREFIXED_NAME:
	190	state->handler = doctype1;
	191	return XML_ROLE_DOCTYPE_NAME;
	192	}
	193	return common(state, tok);
[36]	194	}
	195
[97]	196	static
	197	int doctype1(PROLOG_STATE *state,
	198	int tok,
	199	const char *ptr,
	200	const char *end,
	201	const ENCODING *enc)
[36]	202	{
[97]	203	switch (tok) {
	204	case XML_TOK_PROLOG_S:
	205	return XML_ROLE_NONE;
	206	case XML_TOK_OPEN_BRACKET:
	207	state->handler = internalSubset;
	208	return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
	209	case XML_TOK_DECL_CLOSE:
	210	state->handler = prolog2;
	211	return XML_ROLE_DOCTYPE_CLOSE;
	212	case XML_TOK_NAME:
	213	if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
	214	state->handler = doctype3;
	215	return XML_ROLE_NONE;
[36]	216	}
[97]	217	if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
	218	state->handler = doctype2;
	219	return XML_ROLE_NONE;
	220	}
	221	break;
	222	}
	223	return common(state, tok);
[36]	224	}
	225
[97]	226	static
	227	int doctype2(PROLOG_STATE *state,
	228	int tok,
	229	const char *ptr,
	230	const char *end,
	231	const ENCODING *enc)
[36]	232	{
[97]	233	switch (tok) {
	234	case XML_TOK_PROLOG_S:
	235	return XML_ROLE_NONE;
	236	case XML_TOK_LITERAL:
	237	state->handler = doctype3;
	238	return XML_ROLE_DOCTYPE_PUBLIC_ID;
	239	}
	240	return common(state, tok);
[36]	241	}
	242
[97]	243	static
	244	int doctype3(PROLOG_STATE *state,
	245	int tok,
	246	const char *ptr,
	247	const char *end,
	248	const ENCODING *enc)
[36]	249	{
[97]	250	switch (tok) {
	251	case XML_TOK_PROLOG_S:
	252	return XML_ROLE_NONE;
	253	case XML_TOK_LITERAL:
	254	state->handler = doctype4;
	255	return XML_ROLE_DOCTYPE_SYSTEM_ID;
	256	}
	257	return common(state, tok);
[36]	258	}
	259
[97]	260	static
	261	int doctype4(PROLOG_STATE *state,
	262	int tok,
	263	const char *ptr,
	264	const char *end,
	265	const ENCODING *enc)
[36]	266	{
[97]	267	switch (tok) {
	268	case XML_TOK_PROLOG_S:
	269	return XML_ROLE_NONE;
	270	case XML_TOK_OPEN_BRACKET:
	271	state->handler = internalSubset;
	272	return XML_ROLE_DOCTYPE_INTERNAL_SUBSET;
	273	case XML_TOK_DECL_CLOSE:
	274	state->handler = prolog2;
	275	return XML_ROLE_DOCTYPE_CLOSE;
	276	}
	277	return common(state, tok);
[36]	278	}
	279
[97]	280	static
	281	int doctype5(PROLOG_STATE *state,
	282	int tok,
	283	const char *ptr,
	284	const char *end,
	285	const ENCODING *enc)
[36]	286	{
[97]	287	switch (tok) {
	288	case XML_TOK_PROLOG_S:
	289	return XML_ROLE_NONE;
	290	case XML_TOK_DECL_CLOSE:
	291	state->handler = prolog2;
	292	return XML_ROLE_DOCTYPE_CLOSE;
	293	}
	294	return common(state, tok);
[36]	295	}
	296
[97]	297	static
	298	int internalSubset(PROLOG_STATE *state,
	299	int tok,
	300	const char *ptr,
	301	const char *end,
	302	const ENCODING *enc)
[36]	303	{
[97]	304	switch (tok) {
	305	case XML_TOK_PROLOG_S:
	306	return XML_ROLE_NONE;
	307	case XML_TOK_DECL_OPEN:
	308	if (XmlNameMatchesAscii(enc,
	309	ptr + 2 * MIN_BYTES_PER_CHAR(enc),
	310	end,
	311	KW_ENTITY)) {
	312	state->handler = entity0;
	313	return XML_ROLE_NONE;
[36]	314	}
[97]	315	if (XmlNameMatchesAscii(enc,
	316	ptr + 2 * MIN_BYTES_PER_CHAR(enc),
	317	end,
	318	KW_ATTLIST)) {
	319	state->handler = attlist0;
	320	return XML_ROLE_NONE;
	321	}
	322	if (XmlNameMatchesAscii(enc,
	323	ptr + 2 * MIN_BYTES_PER_CHAR(enc),
	324	end,
	325	KW_ELEMENT)) {
	326	state->handler = element0;
	327	return XML_ROLE_NONE;
	328	}
	329	if (XmlNameMatchesAscii(enc,
	330	ptr + 2 * MIN_BYTES_PER_CHAR(enc),
	331	end,
	332	KW_NOTATION)) {
	333	state->handler = notation0;
	334	return XML_ROLE_NONE;
	335	}
	336	break;
	337	case XML_TOK_PI:
	338	case XML_TOK_COMMENT:
	339	return XML_ROLE_NONE;
	340	case XML_TOK_PARAM_ENTITY_REF:
	341	return XML_ROLE_PARAM_ENTITY_REF;
	342	case XML_TOK_CLOSE_BRACKET:
	343	state->handler = doctype5;
	344	return XML_ROLE_NONE;
	345	}
	346	return common(state, tok);
[36]	347	}
	348
	349	#ifdef XML_DTD
	350
[97]	351	static
	352	int externalSubset0(PROLOG_STATE *state,
	353	int tok,
	354	const char *ptr,
	355	const char *end,
	356	const ENCODING *enc)
[36]	357	{
[97]	358	state->handler = externalSubset1;
	359	if (tok == XML_TOK_XML_DECL)
	360	return XML_ROLE_TEXT_DECL;
	361	return externalSubset1(state, tok, ptr, end, enc);
[36]	362	}
	363
	364	static
[97]	365	int externalSubset1(PROLOG_STATE *state,
	366	int tok,
	367	const char *ptr,
	368	const char *end,
	369	const ENCODING *enc)
[36]	370	{
[97]	371	switch (tok) {
	372	case XML_TOK_COND_SECT_OPEN:
	373	state->handler = condSect0;
	374	return XML_ROLE_NONE;
	375	case XML_TOK_COND_SECT_CLOSE:
	376	if (state->includeLevel == 0)
	377	break;
	378	state->includeLevel -= 1;
	379	return XML_ROLE_NONE;
	380	case XML_TOK_PROLOG_S:
	381	return XML_ROLE_NONE;
	382	case XML_TOK_CLOSE_BRACKET:
	383	break;
	384	case XML_TOK_NONE:
	385	if (state->includeLevel)
	386	break;
	387	return XML_ROLE_NONE;
	388	default:
	389	return internalSubset(state, tok, ptr, end, enc);
	390	}
	391	return common(state, tok);
[36]	392	}
	393
	394	#endif /* XML_DTD */
	395
	396	static
[97]	397	int entity0(PROLOG_STATE *state,
	398	int tok,
	399	const char *ptr,
	400	const char *end,
	401	const ENCODING *enc)
[36]	402	{
[97]	403	switch (tok) {
	404	case XML_TOK_PROLOG_S:
	405	return XML_ROLE_NONE;
	406	case XML_TOK_PERCENT:
	407	state->handler = entity1;
	408	return XML_ROLE_NONE;
	409	case XML_TOK_NAME:
	410	state->handler = entity2;
	411	return XML_ROLE_GENERAL_ENTITY_NAME;
	412	}
	413	return common(state, tok);
[36]	414	}
	415
	416	static
[97]	417	int entity1(PROLOG_STATE *state,
	418	int tok,
	419	const char *ptr,
	420	const char *end,
	421	const ENCODING *enc)
[36]	422	{
[97]	423	switch (tok) {
	424	case XML_TOK_PROLOG_S:
	425	return XML_ROLE_NONE;
	426	case XML_TOK_NAME:
	427	state->handler = entity7;
	428	return XML_ROLE_PARAM_ENTITY_NAME;
	429	}
	430	return common(state, tok);
[36]	431	}
	432
	433	static
[97]	434	int entity2(PROLOG_STATE *state,
	435	int tok,
	436	const char *ptr,
	437	const char *end,
	438	const ENCODING *enc)
[36]	439	{
[97]	440	switch (tok) {
	441	case XML_TOK_PROLOG_S:
	442	return XML_ROLE_NONE;
	443	case XML_TOK_NAME:
	444	if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
	445	state->handler = entity4;
	446	return XML_ROLE_NONE;
[36]	447	}
[97]	448	if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
	449	state->handler = entity3;
	450	return XML_ROLE_NONE;
	451	}
	452	break;
	453	case XML_TOK_LITERAL:
	454	state->handler = declClose;
	455	return XML_ROLE_ENTITY_VALUE;
	456	}
	457	return common(state, tok);
[36]	458	}
	459
	460	static
[97]	461	int entity3(PROLOG_STATE *state,
	462	int tok,
	463	const char *ptr,
	464	const char *end,
	465	const ENCODING *enc)
[36]	466	{
[97]	467	switch (tok) {
	468	case XML_TOK_PROLOG_S:
	469	return XML_ROLE_NONE;
	470	case XML_TOK_LITERAL:
	471	state->handler = entity4;
	472	return XML_ROLE_ENTITY_PUBLIC_ID;
	473	}
	474	return common(state, tok);
[36]	475	}
	476
	477
	478	static
[97]	479	int entity4(PROLOG_STATE *state,
	480	int tok,
	481	const char *ptr,
	482	const char *end,
	483	const ENCODING *enc)
[36]	484	{
[97]	485	switch (tok) {
	486	case XML_TOK_PROLOG_S:
	487	return XML_ROLE_NONE;
	488	case XML_TOK_LITERAL:
	489	state->handler = entity5;
	490	return XML_ROLE_ENTITY_SYSTEM_ID;
	491	}
	492	return common(state, tok);
[36]	493	}
	494
	495	static
[97]	496	int entity5(PROLOG_STATE *state,
	497	int tok,
	498	const char *ptr,
	499	const char *end,
	500	const ENCODING *enc)
[36]	501	{
[97]	502	switch (tok) {
	503	case XML_TOK_PROLOG_S:
	504	return XML_ROLE_NONE;
	505	case XML_TOK_DECL_CLOSE:
	506	setTopLevel(state);
	507	return XML_ROLE_ENTITY_COMPLETE;
	508	case XML_TOK_NAME:
	509	if (XmlNameMatchesAscii(enc, ptr, end, KW_NDATA)) {
	510	state->handler = entity6;
	511	return XML_ROLE_NONE;
[36]	512	}
[97]	513	break;
	514	}
	515	return common(state, tok);
[36]	516	}
	517
	518	static
[97]	519	int entity6(PROLOG_STATE *state,
	520	int tok,
	521	const char *ptr,
	522	const char *end,
	523	const ENCODING *enc)
[36]	524	{
[97]	525	switch (tok) {
	526	case XML_TOK_PROLOG_S:
	527	return XML_ROLE_NONE;
	528	case XML_TOK_NAME:
	529	state->handler = declClose;
	530	return XML_ROLE_ENTITY_NOTATION_NAME;
	531	}
	532	return common(state, tok);
[36]	533	}
	534
	535	static
[97]	536	int entity7(PROLOG_STATE *state,
	537	int tok,
	538	const char *ptr,
	539	const char *end,
	540	const ENCODING *enc)
[36]	541	{
[97]	542	switch (tok) {
	543	case XML_TOK_PROLOG_S:
	544	return XML_ROLE_NONE;
	545	case XML_TOK_NAME:
	546	if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
	547	state->handler = entity9;
	548	return XML_ROLE_NONE;
[36]	549	}
[97]	550	if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
	551	state->handler = entity8;
	552	return XML_ROLE_NONE;
	553	}
	554	break;
	555	case XML_TOK_LITERAL:
	556	state->handler = declClose;
	557	return XML_ROLE_ENTITY_VALUE;
	558	}
	559	return common(state, tok);
[36]	560	}
	561
	562	static
[97]	563	int entity8(PROLOG_STATE *state,
	564	int tok,
	565	const char *ptr,
	566	const char *end,
	567	const ENCODING *enc)
[36]	568	{
[97]	569	switch (tok) {
	570	case XML_TOK_PROLOG_S:
	571	return XML_ROLE_NONE;
	572	case XML_TOK_LITERAL:
	573	state->handler = entity9;
	574	return XML_ROLE_ENTITY_PUBLIC_ID;
	575	}
	576	return common(state, tok);
[36]	577	}
	578
	579	static
[97]	580	int entity9(PROLOG_STATE *state,
	581	int tok,
	582	const char *ptr,
	583	const char *end,
	584	const ENCODING *enc)
[36]	585	{
[97]	586	switch (tok) {
	587	case XML_TOK_PROLOG_S:
	588	return XML_ROLE_NONE;
	589	case XML_TOK_LITERAL:
	590	state->handler = declClose;
	591	return XML_ROLE_ENTITY_SYSTEM_ID;
	592	}
	593	return common(state, tok);
[36]	594	}
	595
	596	static
[97]	597	int notation0(PROLOG_STATE *state,
	598	int tok,
	599	const char *ptr,
	600	const char *end,
	601	const ENCODING *enc)
[36]	602	{
[97]	603	switch (tok) {
	604	case XML_TOK_PROLOG_S:
	605	return XML_ROLE_NONE;
	606	case XML_TOK_NAME:
	607	state->handler = notation1;
	608	return XML_ROLE_NOTATION_NAME;
	609	}
	610	return common(state, tok);
[36]	611	}
	612
	613	static
[97]	614	int notation1(PROLOG_STATE *state,
	615	int tok,
	616	const char *ptr,
	617	const char *end,
	618	const ENCODING *enc)
[36]	619	{
[97]	620	switch (tok) {
	621	case XML_TOK_PROLOG_S:
	622	return XML_ROLE_NONE;
	623	case XML_TOK_NAME:
	624	if (XmlNameMatchesAscii(enc, ptr, end, KW_SYSTEM)) {
	625	state->handler = notation3;
	626	return XML_ROLE_NONE;
[36]	627	}
[97]	628	if (XmlNameMatchesAscii(enc, ptr, end, KW_PUBLIC)) {
	629	state->handler = notation2;
	630	return XML_ROLE_NONE;
	631	}
	632	break;
	633	}
	634	return common(state, tok);
[36]	635	}
	636
	637	static
[97]	638	int notation2(PROLOG_STATE *state,
	639	int tok,
	640	const char *ptr,
	641	const char *end,
	642	const ENCODING *enc)
[36]	643	{
[97]	644	switch (tok) {
	645	case XML_TOK_PROLOG_S:
	646	return XML_ROLE_NONE;
	647	case XML_TOK_LITERAL:
	648	state->handler = notation4;
	649	return XML_ROLE_NOTATION_PUBLIC_ID;
	650	}
	651	return common(state, tok);
[36]	652	}
	653
	654	static
[97]	655	int notation3(PROLOG_STATE *state,
	656	int tok,
	657	const char *ptr,
	658	const char *end,
	659	const ENCODING *enc)
[36]	660	{
[97]	661	switch (tok) {
	662	case XML_TOK_PROLOG_S:
	663	return XML_ROLE_NONE;
	664	case XML_TOK_LITERAL:
	665	state->handler = declClose;
	666	return XML_ROLE_NOTATION_SYSTEM_ID;
	667	}
	668	return common(state, tok);
[36]	669	}
	670
	671	static
[97]	672	int notation4(PROLOG_STATE *state,
	673	int tok,
	674	const char *ptr,
	675	const char *end,
	676	const ENCODING *enc)
[36]	677	{
[97]	678	switch (tok) {
	679	case XML_TOK_PROLOG_S:
	680	return XML_ROLE_NONE;
	681	case XML_TOK_LITERAL:
	682	state->handler = declClose;
	683	return XML_ROLE_NOTATION_SYSTEM_ID;
	684	case XML_TOK_DECL_CLOSE:
	685	setTopLevel(state);
	686	return XML_ROLE_NOTATION_NO_SYSTEM_ID;
	687	}
	688	return common(state, tok);
[36]	689	}
	690
	691	static
[97]	692	int attlist0(PROLOG_STATE *state,
	693	int tok,
	694	const char *ptr,
	695	const char *end,
	696	const ENCODING *enc)
[36]	697	{
[97]	698	switch (tok) {
	699	case XML_TOK_PROLOG_S:
	700	return XML_ROLE_NONE;
	701	case XML_TOK_NAME:
	702	case XML_TOK_PREFIXED_NAME:
	703	state->handler = attlist1;
	704	return XML_ROLE_ATTLIST_ELEMENT_NAME;
	705	}
	706	return common(state, tok);
[36]	707	}
	708
	709	static
[97]	710	int attlist1(PROLOG_STATE *state,
	711	int tok,
	712	const char *ptr,
	713	const char *end,
	714	const ENCODING *enc)
[36]	715	{
[97]	716	switch (tok) {
	717	case XML_TOK_PROLOG_S:
	718	return XML_ROLE_NONE;
	719	case XML_TOK_DECL_CLOSE:
	720	setTopLevel(state);
	721	return XML_ROLE_NONE;
	722	case XML_TOK_NAME:
	723	case XML_TOK_PREFIXED_NAME:
	724	state->handler = attlist2;
	725	return XML_ROLE_ATTRIBUTE_NAME;
	726	}
	727	return common(state, tok);
[36]	728	}
	729
	730	static
[97]	731	int attlist2(PROLOG_STATE *state,
	732	int tok,
	733	const char *ptr,
	734	const char *end,
	735	const ENCODING *enc)
[36]	736	{
[97]	737	switch (tok) {
	738	case XML_TOK_PROLOG_S:
	739	return XML_ROLE_NONE;
	740	case XML_TOK_NAME:
[36]	741	{
[97]	742	static const char *types[] = {
	743	KW_CDATA,
	744	KW_ID,
	745	KW_IDREF,
	746	KW_IDREFS,
	747	KW_ENTITY,
	748	KW_ENTITIES,
	749	KW_NMTOKEN,
	750	KW_NMTOKENS,
	751	};
	752	int i;
	753	for (i = 0; i < (int)(sizeof(types)/sizeof(types[0])); i++)
	754	if (XmlNameMatchesAscii(enc, ptr, end, types[i])) {
	755	state->handler = attlist8;
	756	return XML_ROLE_ATTRIBUTE_TYPE_CDATA + i;
[36]	757	}
[97]	758	}
	759	if (XmlNameMatchesAscii(enc, ptr, end, KW_NOTATION)) {
	760	state->handler = attlist5;
	761	return XML_ROLE_NONE;
	762	}
	763	break;
	764	case XML_TOK_OPEN_PAREN:
	765	state->handler = attlist3;
	766	return XML_ROLE_NONE;
	767	}
	768	return common(state, tok);
[36]	769	}
	770
	771	static
[97]	772	int attlist3(PROLOG_STATE *state,
	773	int tok,
	774	const char *ptr,
	775	const char *end,
	776	const ENCODING *enc)
[36]	777	{
[97]	778	switch (tok) {
	779	case XML_TOK_PROLOG_S:
	780	return XML_ROLE_NONE;
	781	case XML_TOK_NMTOKEN:
	782	case XML_TOK_NAME:
	783	case XML_TOK_PREFIXED_NAME:
	784	state->handler = attlist4;
	785	return XML_ROLE_ATTRIBUTE_ENUM_VALUE;
	786	}
	787	return common(state, tok);
[36]	788	}
	789
	790	static
[97]	791	int attlist4(PROLOG_STATE *state,
	792	int tok,
	793	const char *ptr,
	794	const char *end,
	795	const ENCODING *enc)
[36]	796	{
[97]	797	switch (tok) {
	798	case XML_TOK_PROLOG_S:
	799	return XML_ROLE_NONE;
	800	case XML_TOK_CLOSE_PAREN:
	801	state->handler = attlist8;
	802	return XML_ROLE_NONE;
	803	case XML_TOK_OR:
	804	state->handler = attlist3;
	805	return XML_ROLE_NONE;
	806	}
	807	return common(state, tok);
[36]	808	}
	809
	810	static
[97]	811	int attlist5(PROLOG_STATE *state,
	812	int tok,
	813	const char *ptr,
	814	const char *end,
	815	const ENCODING *enc)
[36]	816	{
[97]	817	switch (tok) {
	818	case XML_TOK_PROLOG_S:
	819	return XML_ROLE_NONE;
	820	case XML_TOK_OPEN_PAREN:
	821	state->handler = attlist6;
	822	return XML_ROLE_NONE;
	823	}
	824	return common(state, tok);
[36]	825	}
	826
	827
	828	static
[97]	829	int attlist6(PROLOG_STATE *state,
	830	int tok,
	831	const char *ptr,
	832	const char *end,
	833	const ENCODING *enc)
[36]	834	{
[97]	835	switch (tok) {
	836	case XML_TOK_PROLOG_S:
	837	return XML_ROLE_NONE;
	838	case XML_TOK_NAME:
	839	state->handler = attlist7;
	840	return XML_ROLE_ATTRIBUTE_NOTATION_VALUE;
	841	}
	842	return common(state, tok);
[36]	843	}
	844
	845	static
[97]	846	int attlist7(PROLOG_STATE *state,
	847	int tok,
	848	const char *ptr,
	849	const char *end,
	850	const ENCODING *enc)
[36]	851	{
[97]	852	switch (tok) {
	853	case XML_TOK_PROLOG_S:
	854	return XML_ROLE_NONE;
	855	case XML_TOK_CLOSE_PAREN:
	856	state->handler = attlist8;
	857	return XML_ROLE_NONE;
	858	case XML_TOK_OR:
	859	state->handler = attlist6;
	860	return XML_ROLE_NONE;
	861	}
	862	return common(state, tok);
[36]	863	}
	864
	865	/* default value */
	866	static
[97]	867	int attlist8(PROLOG_STATE *state,
	868	int tok,
	869	const char *ptr,
	870	const char *end,
	871	const ENCODING *enc)
[36]	872	{
[97]	873	switch (tok) {
	874	case XML_TOK_PROLOG_S:
	875	return XML_ROLE_NONE;
	876	case XML_TOK_POUND_NAME:
	877	if (XmlNameMatchesAscii(enc,
	878	ptr + MIN_BYTES_PER_CHAR(enc),
	879	end,
	880	KW_IMPLIED)) {
	881	state->handler = attlist1;
	882	return XML_ROLE_IMPLIED_ATTRIBUTE_VALUE;
[36]	883	}
[97]	884	if (XmlNameMatchesAscii(enc,
	885	ptr + MIN_BYTES_PER_CHAR(enc),
	886	end,
	887	KW_REQUIRED)) {
	888	state->handler = attlist1;
	889	return XML_ROLE_REQUIRED_ATTRIBUTE_VALUE;
	890	}
	891	if (XmlNameMatchesAscii(enc,
	892	ptr + MIN_BYTES_PER_CHAR(enc),
	893	end,
	894	KW_FIXED)) {
	895	state->handler = attlist9;
	896	return XML_ROLE_NONE;
	897	}
	898	break;
	899	case XML_TOK_LITERAL:
	900	state->handler = attlist1;
	901	return XML_ROLE_DEFAULT_ATTRIBUTE_VALUE;
	902	}
	903	return common(state, tok);
[36]	904	}
	905
	906	static
[97]	907	int attlist9(PROLOG_STATE *state,
	908	int tok,
	909	const char *ptr,
	910	const char *end,
	911	const ENCODING *enc)
[36]	912	{
[97]	913	switch (tok) {
	914	case XML_TOK_PROLOG_S:
	915	return XML_ROLE_NONE;
	916	case XML_TOK_LITERAL:
	917	state->handler = attlist1;
	918	return XML_ROLE_FIXED_ATTRIBUTE_VALUE;
	919	}
	920	return common(state, tok);
[36]	921	}
	922
	923	static
[97]	924	int element0(PROLOG_STATE *state,
	925	int tok,
	926	const char *ptr,
	927	const char *end,
	928	const ENCODING *enc)
[36]	929	{
[97]	930	switch (tok) {
	931	case XML_TOK_PROLOG_S:
	932	return XML_ROLE_NONE;
	933	case XML_TOK_NAME:
	934	case XML_TOK_PREFIXED_NAME:
	935	state->handler = element1;
	936	return XML_ROLE_ELEMENT_NAME;
	937	}
	938	return common(state, tok);
[36]	939	}
	940
	941	static
[97]	942	int element1(PROLOG_STATE *state,
	943	int tok,
	944	const char *ptr,
	945	const char *end,
	946	const ENCODING *enc)
[36]	947	{
[97]	948	switch (tok) {
	949	case XML_TOK_PROLOG_S:
	950	return XML_ROLE_NONE;
	951	case XML_TOK_NAME:
	952	if (XmlNameMatchesAscii(enc, ptr, end, KW_EMPTY)) {
	953	state->handler = declClose;
	954	return XML_ROLE_CONTENT_EMPTY;
[36]	955	}
[97]	956	if (XmlNameMatchesAscii(enc, ptr, end, KW_ANY)) {
	957	state->handler = declClose;
	958	return XML_ROLE_CONTENT_ANY;
	959	}
	960	break;
	961	case XML_TOK_OPEN_PAREN:
	962	state->handler = element2;
	963	state->level = 1;
	964	return XML_ROLE_GROUP_OPEN;
	965	}
	966	return common(state, tok);
[36]	967	}
	968
	969	static
[97]	970	int element2(PROLOG_STATE *state,
	971	int tok,
	972	const char *ptr,
	973	const char *end,
	974	const ENCODING *enc)
[36]	975	{
[97]	976	switch (tok) {
	977	case XML_TOK_PROLOG_S:
	978	return XML_ROLE_NONE;
	979	case XML_TOK_POUND_NAME:
	980	if (XmlNameMatchesAscii(enc,
	981	ptr + MIN_BYTES_PER_CHAR(enc),
	982	end,
	983	KW_PCDATA)) {
	984	state->handler = element3;
	985	return XML_ROLE_CONTENT_PCDATA;
[36]	986	}
[97]	987	break;
	988	case XML_TOK_OPEN_PAREN:
	989	state->level = 2;
	990	state->handler = element6;
	991	return XML_ROLE_GROUP_OPEN;
	992	case XML_TOK_NAME:
	993	case XML_TOK_PREFIXED_NAME:
	994	state->handler = element7;
	995	return XML_ROLE_CONTENT_ELEMENT;
	996	case XML_TOK_NAME_QUESTION:
	997	state->handler = element7;
	998	return XML_ROLE_CONTENT_ELEMENT_OPT;
	999	case XML_TOK_NAME_ASTERISK:
	1000	state->handler = element7;
	1001	return XML_ROLE_CONTENT_ELEMENT_REP;
	1002	case XML_TOK_NAME_PLUS:
	1003	state->handler = element7;
	1004	return XML_ROLE_CONTENT_ELEMENT_PLUS;
	1005	}
	1006	return common(state, tok);
[36]	1007	}
	1008
	1009	static
[97]	1010	int element3(PROLOG_STATE *state,
	1011	int tok,
	1012	const char *ptr,
	1013	const char *end,
	1014	const ENCODING *enc)
[36]	1015	{
[97]	1016	switch (tok) {
	1017	case XML_TOK_PROLOG_S:
	1018	return XML_ROLE_NONE;
	1019	case XML_TOK_CLOSE_PAREN:
	1020	state->handler = declClose;
	1021	return XML_ROLE_GROUP_CLOSE;
	1022	case XML_TOK_CLOSE_PAREN_ASTERISK:
	1023	state->handler = declClose;
	1024	return XML_ROLE_GROUP_CLOSE_REP;
	1025	case XML_TOK_OR:
	1026	state->handler = element4;
	1027	return XML_ROLE_NONE;
	1028	}
	1029	return common(state, tok);
[36]	1030	}
	1031
	1032	static
[97]	1033	int element4(PROLOG_STATE *state,
	1034	int tok,
	1035	const char *ptr,
	1036	const char *end,
	1037	const ENCODING *enc)
[36]	1038	{
[97]	1039	switch (tok) {
	1040	case XML_TOK_PROLOG_S:
	1041	return XML_ROLE_NONE;
	1042	case XML_TOK_NAME:
	1043	case XML_TOK_PREFIXED_NAME:
	1044	state->handler = element5;
	1045	return XML_ROLE_CONTENT_ELEMENT;
	1046	}
	1047	return common(state, tok);
[36]	1048	}
	1049
	1050	static
[97]	1051	int element5(PROLOG_STATE *state,
	1052	int tok,
	1053	const char *ptr,
	1054	const char *end,
	1055	const ENCODING *enc)
[36]	1056	{
[97]	1057	switch (tok) {
	1058	case XML_TOK_PROLOG_S:
	1059	return XML_ROLE_NONE;
	1060	case XML_TOK_CLOSE_PAREN_ASTERISK:
	1061	state->handler = declClose;
	1062	return XML_ROLE_GROUP_CLOSE_REP;
	1063	case XML_TOK_OR:
	1064	state->handler = element4;
	1065	return XML_ROLE_NONE;
	1066	}
	1067	return common(state, tok);
[36]	1068	}
	1069
	1070	static
[97]	1071	int element6(PROLOG_STATE *state,
	1072	int tok,
	1073	const char *ptr,
	1074	const char *end,
	1075	const ENCODING *enc)
[36]	1076	{
[97]	1077	switch (tok) {
	1078	case XML_TOK_PROLOG_S:
	1079	return XML_ROLE_NONE;
	1080	case XML_TOK_OPEN_PAREN:
	1081	state->level += 1;
	1082	return XML_ROLE_GROUP_OPEN;
	1083	case XML_TOK_NAME:
	1084	case XML_TOK_PREFIXED_NAME:
	1085	state->handler = element7;
	1086	return XML_ROLE_CONTENT_ELEMENT;
	1087	case XML_TOK_NAME_QUESTION:
	1088	state->handler = element7;
	1089	return XML_ROLE_CONTENT_ELEMENT_OPT;
	1090	case XML_TOK_NAME_ASTERISK:
	1091	state->handler = element7;
	1092	return XML_ROLE_CONTENT_ELEMENT_REP;
	1093	case XML_TOK_NAME_PLUS:
	1094	state->handler = element7;
	1095	return XML_ROLE_CONTENT_ELEMENT_PLUS;
	1096	}
	1097	return common(state, tok);
[36]	1098	}
	1099
	1100	static
[97]	1101	int element7(PROLOG_STATE *state,
	1102	int tok,
	1103	const char *ptr,
	1104	const char *end,
	1105	const ENCODING *enc)
[36]	1106	{
[97]	1107	switch (tok) {
	1108	case XML_TOK_PROLOG_S:
	1109	return XML_ROLE_NONE;
	1110	case XML_TOK_CLOSE_PAREN:
	1111	state->level -= 1;
	1112	if (state->level == 0)
	1113	state->handler = declClose;
	1114	return XML_ROLE_GROUP_CLOSE;
	1115	case XML_TOK_CLOSE_PAREN_ASTERISK:
	1116	state->level -= 1;
	1117	if (state->level == 0)
	1118	state->handler = declClose;
	1119	return XML_ROLE_GROUP_CLOSE_REP;
	1120	case XML_TOK_CLOSE_PAREN_QUESTION:
	1121	state->level -= 1;
	1122	if (state->level == 0)
	1123	state->handler = declClose;
	1124	return XML_ROLE_GROUP_CLOSE_OPT;
	1125	case XML_TOK_CLOSE_PAREN_PLUS:
	1126	state->level -= 1;
	1127	if (state->level == 0)
	1128	state->handler = declClose;
	1129	return XML_ROLE_GROUP_CLOSE_PLUS;
	1130	case XML_TOK_COMMA:
	1131	state->handler = element6;
	1132	return XML_ROLE_GROUP_SEQUENCE;
	1133	case XML_TOK_OR:
	1134	state->handler = element6;
	1135	return XML_ROLE_GROUP_CHOICE;
	1136	}
	1137	return common(state, tok);
[36]	1138	}
	1139
	1140	#ifdef XML_DTD
	1141
	1142	static
[97]	1143	int condSect0(PROLOG_STATE *state,
	1144	int tok,
	1145	const char *ptr,
	1146	const char *end,
	1147	const ENCODING *enc)
[36]	1148	{
[97]	1149	switch (tok) {
	1150	case XML_TOK_PROLOG_S:
	1151	return XML_ROLE_NONE;
	1152	case XML_TOK_NAME:
	1153	if (XmlNameMatchesAscii(enc, ptr, end, KW_INCLUDE)) {
	1154	state->handler = condSect1;
	1155	return XML_ROLE_NONE;
[36]	1156	}
[97]	1157	if (XmlNameMatchesAscii(enc, ptr, end, KW_IGNORE)) {
	1158	state->handler = condSect2;
	1159	return XML_ROLE_NONE;
	1160	}
	1161	break;
	1162	}
	1163	return common(state, tok);
[36]	1164	}
	1165
	1166	static
[97]	1167	int condSect1(PROLOG_STATE *state,
	1168	int tok,
	1169	const char *ptr,
	1170	const char *end,
	1171	const ENCODING *enc)
[36]	1172	{
[97]	1173	switch (tok) {
	1174	case XML_TOK_PROLOG_S:
	1175	return XML_ROLE_NONE;
	1176	case XML_TOK_OPEN_BRACKET:
	1177	state->handler = externalSubset1;
	1178	state->includeLevel += 1;
	1179	return XML_ROLE_NONE;
	1180	}
	1181	return common(state, tok);
[36]	1182	}
	1183
	1184	static
[97]	1185	int condSect2(PROLOG_STATE *state,
	1186	int tok,
	1187	const char *ptr,
	1188	const char *end,
	1189	const ENCODING *enc)
[36]	1190	{
[97]	1191	switch (tok) {
	1192	case XML_TOK_PROLOG_S:
	1193	return XML_ROLE_NONE;
	1194	case XML_TOK_OPEN_BRACKET:
	1195	state->handler = externalSubset1;
	1196	return XML_ROLE_IGNORE_SECT;
	1197	}
	1198	return common(state, tok);
[36]	1199	}
	1200
	1201	#endif /* XML_DTD */
	1202
	1203	static
[97]	1204	int declClose(PROLOG_STATE *state,
	1205	int tok,
	1206	const char *ptr,
	1207	const char *end,
	1208	const ENCODING *enc)
[36]	1209	{
[97]	1210	switch (tok) {
	1211	case XML_TOK_PROLOG_S:
	1212	return XML_ROLE_NONE;
	1213	case XML_TOK_DECL_CLOSE:
	1214	setTopLevel(state);
	1215	return XML_ROLE_NONE;
	1216	}
	1217	return common(state, tok);
[36]	1218	}
	1219
	1220	#if 0
	1221
	1222	static
[97]	1223	int ignore(PROLOG_STATE *state,
	1224	int tok,
	1225	const char *ptr,
	1226	const char *end,
	1227	const ENCODING *enc)
[36]	1228	{
[97]	1229	switch (tok) {
	1230	case XML_TOK_DECL_CLOSE:
	1231	state->handler = internalSubset;
	1232	return 0;
	1233	default:
	1234	return XML_ROLE_NONE;
	1235	}
	1236	return common(state, tok);
[36]	1237	}
	1238	#endif
	1239
	1240	static
[97]	1241	int error(PROLOG_STATE *state,
	1242	int tok,
	1243	const char *ptr,
	1244	const char *end,
	1245	const ENCODING *enc)
[36]	1246	{
[97]	1247	return XML_ROLE_NONE;
[36]	1248	}
	1249
	1250	static
[97]	1251	int common(PROLOG_STATE *state, int tok)
[36]	1252	{
	1253	#ifdef XML_DTD
[97]	1254	if (!state->documentEntity && tok == XML_TOK_PARAM_ENTITY_REF)
	1255	return XML_ROLE_INNER_PARAM_ENTITY_REF;
[36]	1256	#endif
[97]	1257	state->handler = error;
	1258	return XML_ROLE_ERROR;
[36]	1259	}
	1260
[97]	1261	void XmlPrologStateInit(PROLOG_STATE *state)
[36]	1262	{
[97]	1263	state->handler = prolog0;
[36]	1264	#ifdef XML_DTD
[97]	1265	state->documentEntity = 1;
	1266	state->includeLevel = 0;
[36]	1267	#endif /* XML_DTD */
	1268	}
	1269
	1270	#ifdef XML_DTD
	1271
[97]	1272	void XmlPrologStateInitExternalEntity(PROLOG_STATE *state)
[36]	1273	{
[97]	1274	state->handler = externalSubset0;
	1275	state->documentEntity = 0;
	1276	state->includeLevel = 0;
[36]	1277	}
	1278
	1279	#endif /* XML_DTD */

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: trunk/src/helpers/xmlrole.c

Download in other formats: