dsource.org

Open Source Development for
the D Programming Language

Navigation

← Previous Changeset
Next Changeset →

Changeset 80

Timestamp:

05/15/05 22:52:48 (4 years ago)

Author:

pragma

Message:

Tweaked xmlns

Files:

trunk/xml/xmlns/IXMLNamespaceConsumer.d (modified) (1 diff)
trunk/xml/xmlns/IXMLNamespaceConsumerAdapter.d (modified) (1 diff)
trunk/xml/xmlns/QName.d (modified) (2 diffs)
trunk/xml/xmlns/XMLNSAttributes.d (modified) (1 diff)
trunk/xml/xmlns/XMLNamespaceParser.d (modified) (10 diffs)
trunk/xml/xmlns/all.d (modified) (1 diff)
trunk/xml/xmlns/utf16all.d (added)
trunk/xml/xmlns/utf32all.d (added)
trunk/xml/xmlns/utf8all.d (added)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/xml/xmlns/IXMLNamespaceConsumer.d

r47	r80
26	26	module xml.xmlns.IXMLNamespaceConsumer;
27	27
	28	private import xml.XMLAttributes;
28	29	private import xml.IXMLConsumer;
29		~~private import xml.XMLAttributes;~~
30	30
31	31	private import xml.xmlns.QName;
32	32	private import xml.xmlns.XMLNSAttributes;
33	33
34		interface IXMLNamespaceConsumer : IXMLConsumer{
35		void xmlProlog(XMLAttributes attribs);
36		void xmlStartDoctype(char[] name);
37		void xmlEndDoctype(char[] name);
	34	interface IXMLNamespaceConsumer(CharT){
	35	mixin MXMLAttribute!(CharT);
	36	mixin MXMLNSAttribute!(CharT);
38	37
39		void xmlProcessingInstruction(char[] name,char[] data);
	38	enum DTDOperation: CharT{
	39	StartSequence = '(',
	40	EndSequence = ')',
	41	Or = '\|',
	42	And = '&',
	43	OneOrMore = '*',
	44	ZeroOrMore = '+',
	45	ZeroOrOne = '?',
	46	}
40	47
41		void xmlComment(char[] text);
	48	CharT[] getEntityValue(CharT[] entity,bit parsed);
	49	bit xmlIsParsedProcessingInstruction(CharT[] name);
42	50
43		void xmlStartElement(QName qName,XMLNSAttributes attribs,bit isEmpty);
44		void xmlEndElement(QName qName,XMLNSAttributes attribs,bit isEmpty);
45		void xmlText(char[] text);
	51	void xmlStartDTD(CharT[] name,XMLAttributes externalID);
	52	void xmlEndDTD(CharT[] name,XMLAttributes externalID);
46	53
47		void xmlStartNamespace(char[] name, char[] uri);
48		void xmlEndNamespace(char[] name, char[] uri);
	54	void xmlStartDTDElement(CharT[] name);
	55	void xmlSetDTDElementChild(CharT[] name,CharT[] childName);
	56	void xmlSetDTDElementOperation(CharT[] name,DTDOperation type);
	57	void xmlEndDTDElement(CharT[] name);
	58
	59	void xmlStartDTDAttlist(CharT[] name);
	60	void xmlSetDTDAttlistDef(CharT[] name,CharT[] type,CharT[] defaultDecl,CharT[] defaultValue);
	61	void xmlEndDTDAttlist(CharT[] name);
	62
	63	void xmlSetDTDEntity(CharT[] name,CharT[] value,CharT[] ndata,bit parsed);
	64
	65	void xmlSetDTDNotation(CharT[] name, CharT[] publicId, CharT[] systemLiteral);
	66
	67	void xmlParsedProcessingInstruction(CharT[] name,XMLAttributes attribs);
	68	void xmlProcessingInstruction(CharT[] name,CharT[] data);
	69
	70	void xmlComment(CharT[] text);
	71
	72	void xmlStartElement(QName!(CharT) qName,XMLNSAttributes attribs,bit isEmpty);
	73	void xmlEndElement(QName!(CharT) qName,XMLNSAttributes attribs,bit isEmpty);
	74	void xmlText(CharT[] text,TextType type);
	75
	76	void xmlStartNamespace(CharT[] name, CharT[] uri);
	77	void xmlEndNamespace(CharT[] name, CharT[] uri);
49	78	}
	79
	80	alias IXMLNamespaceConsumer!(char) Utf8IXMLNamespaceConsumer;
	81	alias IXMLNamespaceConsumer!(wchar) Utf16IXMLNamespaceConsumer;
	82	alias IXMLNamespaceConsumer!(dchar) Utf32IXMLNamespaceConsumer;

trunk/xml/xmlns/IXMLNamespaceConsumerAdapter.d

r47	r80
26	26	module xml.xmlns.IXMLNamespaceConsumerAdapter;
27	27
	28	private import xml.XMLAttributes;
	29	private import xml.IXMLConsumer;
	30
28	31	private import xml.xmlns.QName;
29	32	private import xml.xmlns.XMLNSAttributes;
30	33	private import xml.xmlns.IXMLNamespaceConsumer;
31	34
32		abstract class IXMLNamespaceConsumerAdapter : IXMLNamespaceConsumer{
33		void xmlProlog(XMLNSAttributes attribs){}
34		void xmlStartDoctype(char[] name){}
35		void xmlEndDoctype(char[] name){}
	35	abstract class IXMLNamespaceConsumerAdapter(CharT) : IXMLNamespaceConsumer!(CharT){
	36	mixin MXMLAttribute!(CharT);
	37	mixin MXMLNSAttribute!(CharT);
36	38
37		void xmlProcessingInstruction(char[] name,char[] data){}
	39	CharT[] getEntityValue(CharT[] entity,bit parsed){ return "&" ~ entity ~ ";"; }
	40	bit xmlIsParsedProcessingInstruction(CharT[] name){ return false; }
38	41
39		void xmlComment(char[] text){}
	42	void xmlStartDTD(CharT[] name,XMLAttributes externalID){}
	43	void xmlEndDTD(CharT[] name,XMLAttributes externalID){}
40	44
41		void xmlStartElement(QName qName,XMLNSAttributes attribs,bit isEmpty){}
42		void xmlEndElement(QName qName,XMLNSAttributes attribs,bit isEmpty){}
43		void xmlText(char[] text){}
	45	void xmlStartDTDElement(CharT[] name){}
	46	void xmlSetDTDElementChild(CharT[] name,CharT[] childName){}
	47	void xmlSetDTDElementOperation(CharT[] name,DTDOperation type){}
	48	void xmlEndDTDElement(CharT[] name){}
	49
	50	void xmlStartDTDAttlist(CharT[] name){}
	51	void xmlSetDTDAttlistDef(CharT[] name,CharT[] type,CharT[] defaultDecl,CharT[] defaultValue){}
	52	void xmlEndDTDAttlist(CharT[] name){}
44	53
45		void xmlStartNamespace(char[] name, char[] uri){}
46		void xmlEndNamespace(char[] name, char[] uri){}
	54	void xmlSetDTDEntity(CharT[] name,CharT[] value,CharT[] ndata,bit parsed){}
	55
	56	void xmlSetDTDNotation(CharT[] name, CharT[] publicId, CharT[] systemLiteral){}
	57
	58	void xmlParsedProcessingInstruction(CharT[] name,XMLAttributes attribs){}
	59	void xmlProcessingInstruction(CharT[] name,CharT[] data){}
	60
	61	void xmlComment(CharT[] text){}
	62
	63	void xmlStartElement(QName!(CharT) qName,XMLNSAttributes attribs,bit isEmpty){}
	64	void xmlEndElement(QName!(CharT) qName,XMLNSAttributes attribs,bit isEmpty){}
	65	void xmlText(CharT[] text,TextType type){}
	66
	67	void xmlStartNamespace(CharT[] name, CharT[] uri){}
	68	void xmlEndNamespace(CharT[] name, CharT[] uri){}
47	69	}
	70
	71
	72	alias IXMLNamespaceConsumerAdapter!(char) Utf8IXMLNamespaceConsumerAdapter;
	73	alias IXMLNamespaceConsumerAdapter!(wchar) Utf16IXMLNamespaceConsumerAdapter;
	74	alias IXMLNamespaceConsumerAdapter!(dchar) Utf32IXMLNamespaceConsumerAdapter;

trunk/xml/xmlns/QName.d

r47	r80
29	29
30	30	//TODO: make this a class instead?
31		struct QName{
32		~~char~~[] ns;
33		~~char~~[] local;
	31	struct QName(CharT){
	32	CharT[] ns;
	33	CharT[] local;
34	34
35	35	/*
…	…
41	41	int opCmp(Object o){
42	42	QName other = cast(QName)o;
43		if(ns != ns){
44		return std.string.cmp(ns,other.ns);
	43
	44	if(ns.length == other.ns.length){
	45	foreach(uint idx,CharT ch; ns){
	46	uint result = ch - other.ns[idx];
	47	if(result > 0) return 1;
	48	if(result < 0) return -1;
	49	}
45	50	}
46		return std.string.cmp(local,other.local);
	51	if(local.length == other.local.length){
	52	foreach(uint idx,CharT ch; local){
	53	uint result = ch - other.local[idx];
	54	if(result > 0) return 1;
	55	if(result < 0) return -1;
	56	}
	57	}
	58	return 0;
47	59	}
48	60
49	61	int toHash(){
50		return(*this); //TODO: something better?
	62	return(cast(int)cast(void*)this); //TODO: something better?
51	63	}
52	64	*/
53	65
54		char[] toString(){
	66
	67	CharT[] toStringValue(){
	68	if(!ns \|\| ns == "") return local;
55	69	return(ns ~ ":" ~ local);
56	70	}
57	71	}
	72
	73	alias QName!(char) Utf8QName;
	74	alias QName!(wchar) Utf16QName;
	75	alias QName!(dchar) Utf32QName;

trunk/xml/xmlns/XMLNSAttributes.d

r47	r80
28	28	private import xml.xmlns.QName;
29	29
30		alias char[][QName] XMLNSAttributes;
	30	template MXMLNSAttribute(CharT){
	31	alias CharT[][QName!(CharT)] XMLNSAttributes;
	32	}
	33
	34	template MXMLNSAttributeFunctions(CharT){
	35	CharT[] toCharTString(XMLNSAttributes attribs){
	36	CharT[] output = "";
	37	foreach(QName!(CharT) name,CharT[] value; attribs){
	38	output ~= name.toStringValue() ~ "=" ~ "\"" ~ value ~ "\"" ~ " ";
	39	}
	40	return output;
	41	}
	42
	43	CharT[] toCharTString(CharT ch){
	44	CharT[] value;
	45	value.length = 1;
	46	value[0] = ch;
	47	return value;
	48	}
	49	}

trunk/xml/xmlns/XMLNamespaceParser.d

r48	r80
29	29	private import xml.IXMLConsumer;
30	30	private import xml.XMLException;
	31	private import xml.IXMLProvider;
	32	private import xml.OfflineProvider;
	33	private import xml.XMLParser;
31	34
32	35	private import xml.xmlns.QName;
…	…
51	54	}
52	55
53		class XMLNamespaceParser : IXMLConsumer{
54		IXMLNamespaceConsumer consumer;
55		QName[] tagNames;
	56	class XMLNamespaceParser(CharT) : IXMLConsumer!(CharT){
	57	mixin MXMLAttribute!(CharT);
	58	mixin MXMLAttributeFunctions!(CharT);
	59	mixin MXMLNSAttribute!(CharT);
	60	mixin MXMLNSAttributeFunctions!(CharT);
	61
	62	IXMLNamespaceConsumer!(CharT) consumer;
	63	QName!(CharT)[] tagNames;
56	64	XMLNSAttributes[] tagAttributes;
57		char[][][char[]] namespaces;
58
59		public this(IXMLNamespaceConsumer consumer){
	65	CharT[][][CharT[]] namespaces;
	66
	67	public void parse(IXMLNamespaceConsumer!(CharT) consumer,CharT[] source){
	68	parse(consumer,new OfflineProvider!(CharT),source);
	69	}
	70
	71	public void parse(IXMLNamespaceConsumer!(CharT) consumer,IXMLProvider!(CharT) provider,CharT[] source){
	72	// keep the consumer for forwarding purposes
60	73	this.consumer = consumer;
61		}
62
63		private QName parseQName(char[] name){
64		QName newName;
65		int split = find(name,":");
66
67		if(split>0){
	74
	75	XMLParser!(CharT) parser = new XMLParser!(CharT)();
	76
	77	// parse and pass 'this' as the consumer
	78	parser.parse(this,provider,source);
	79	}
	80
	81	/+++ helper functions +++/
	82
	83	private QName!(CharT) parseQName(CharT[] name){
	84	QName!(CharT) newName;
	85	int split;
	86
	87	for(split=0; split<name.length && name[split]!=':'; split++){}
	88
	89	if(split == name.length){
	90	newName.ns = "";
	91	newName.local = name;
	92	}
	93	else if(split>0){
68	94	newName.ns = name[0..split+1];
69	95	newName.local = name[split..name.length];
…	…
80	106	}
81	107
82		private void pushTagname(QName tagname){
83		push!(QName)(tagNames,tagname);
84		}
85
86		private QName popTagname(){
87		return pop!(QName)(tagNames);
88		}
89
90		private void pushNamespace(~~char[] name, char~~[] value){
	108	private void pushTagname(QName!(CharT) tagname){
	109	push!(QName!(CharT))(tagNames,tagname);
	110	}
	111
	112	private QName!(CharT) popTagname(){
	113	return pop!(QName!(CharT))(tagNames);
	114	}
	115
	116	private void pushNamespace(CharT[] name, CharT[] value){
91	117	namespaces[name].length = namespaces[name].length + 1;
92	118	namespaces[name][$-1] = value;
93	119	}
94	120
95		private void popNamespace(~~char~~[] name){
	121	private void popNamespace(CharT[] name){
96	122	namespaces[name].length = namespaces[name].length - 1;
97	123	}
98	124
99		private ~~char[] getNamespaceURI(char~~[] name){
	125	private CharT[] getNamespaceURI(CharT[] name){
100	126	if(name in namespaces){
101	127	return namespaces[name][$-1];
…	…
104	130	}
105	131
106		void xmlProlog(XMLAttributes attribs){
107		consumer.xmlProlog(attribs);
108		}
109
110		void xmlStartDoctype(char[] name){
111		consumer.xmlStartDoctype(name);
112		}
113
114		void xmlEndDoctype(char[] name){
115		consumer.xmlEndDoctype(name);
116		}
117
118		void xmlProcessingInstruction(char[] name,char[] data){
	132	/+++ IXMLConsumer callbacks +++/
	133
	134	CharT[] getEntityValue(CharT[] entity,bit parsed){
	135	consumer.getEntityValue(entity,parsed);
	136	}
	137
	138	bit xmlIsParsedProcessingInstruction(CharT[] name){
	139	consumer.xmlIsParsedProcessingInstruction(name);
	140	}
	141
	142	void xmlStartDTD(CharT[] name,XMLAttributes externalID){
	143	consumer.xmlStartDTD(name,externalID);
	144	}
	145
	146	void xmlEndDTD(CharT[] name,XMLAttributes externalID){
	147	consumer.xmlEndDTD(name,externalID);
	148	}
	149
	150	void xmlStartDTDElement(CharT[] name){
	151	consumer.xmlStartDTDElement(name);
	152	}
	153
	154	void xmlSetDTDElementChild(CharT[] name,CharT[] childName){
	155	consumer.xmlSetDTDElementChild(name,childName);
	156	}
	157
	158	void xmlSetDTDElementOperation(CharT[] name,DTDOperation type){
	159	consumer.xmlSetDTDElementOperation(name,type);
	160	}
	161
	162	void xmlEndDTDElement(CharT[] name){
	163	consumer.xmlEndDTDElement(name);
	164	}
	165
	166	void xmlStartDTDAttlist(CharT[] name){
	167	consumer.xmlStartDTDAttlist(name);
	168	}
	169
	170	void xmlSetDTDAttlistDef(CharT[] name,CharT[] type,CharT[] defaultDecl,CharT[] defaultValue){
	171	consumer.xmlSetDTDAttlistDef(name,type,defaultDecl,defaultValue);
	172	}
	173
	174	void xmlEndDTDAttlist(CharT[] name){
	175	consumer.xmlEndDTDAttlist(name);
	176	}
	177
	178	void xmlSetDTDEntity(CharT[] name,CharT[] value,CharT[] ndata,bit parsed){
	179	consumer.xmlSetDTDEntity(name,value,ndata,parsed);
	180	}
	181
	182	void xmlSetDTDNotation(CharT[] name, CharT[] publicId, CharT[] systemLiteral){
	183	consumer.xmlSetDTDNotation(name,publicId,systemLiteral);
	184	}
	185
	186	void xmlParsedProcessingInstruction(CharT[] name,XMLAttributes attribs){
	187	consumer.xmlParsedProcessingInstruction(name,attribs);
	188	}
	189
	190	void xmlProcessingInstruction(CharT[] name,CharT[] data){
119	191	consumer.xmlProcessingInstruction(name,data);
120	192	}
121
122		void xmlComment(~~char~~[] text){
	193
	194	void xmlComment(CharT[] text){
123	195	consumer.xmlComment(text);
124	196	}
125	197
126		void xmlStartElement(~~char~~[] name,XMLAttributes attribs,bit isEmpty){
	198	void xmlStartElement(CharT[] name,XMLAttributes attribs,bit isEmpty){
127	199	XMLNSAttributes nsAttribs;
128	200
129		foreach(~~char[] name, char~~[] value; attribs){
	201	foreach(CharT[] name, CharT[] value; attribs){
130	202	// handle default namespace
131		if(name == "xmlns"){
	203	if(name == "xmlns"){
132	204	pushNamespace("",value);
133	205	consumer.xmlStartNamespace("",value);
…	…
136	208	// handle typical attribute
137	209	else{
138		QName qname = parseQName(name);
	210	QName!(CharT) qname = parseQName(name);
139	211
140	212	// handle namespace definition
…	…
164	236
165	237	// establish the namespace for the name
166		QName tagname = parseQName(name);
	238	QName!(CharT) tagname = parseQName(name);
167	239	tagname.ns = getNamespaceURI(tagname.ns);
168	240	pushTagname(tagname);
…	…
172	244	}
173	245
174		void xmlEndElement(~~char~~[] name,XMLAttributes attribs,bit isEmpty){
	246	void xmlEndElement(CharT[] name,XMLAttributes attribs,bit isEmpty){
175	247	// keep things symmetrical: fire element end first
176	248	consumer.xmlEndElement(popTagname(),popAttributes(),isEmpty);
…	…
178	250	// unwind all that was done with these attributes
179	251	//TODO: get these in reverse order
180		foreach(~~char[] name, char~~[] value; attribs){
	252	foreach(CharT[] name, CharT[] value; attribs){
181	253	// handle default namespace
182	254	if(name == "xmlns"){
…	…
187	259	// handle typical attribute
188	260	else{
189		QName qname = parseQName(name);
	261	QName!(CharT) qname = parseQName(name);
190	262
191	263	// handle namespace definition
…	…
197	269	}
198	270	}
199
200		}
201
202		void xmlText(char[] text){
203		consumer.xmlText(text);
	271	}
	272
	273	void xmlText(CharT[] text,TextType type){
	274	consumer.xmlText(text,type);
204	275	}
205	276	}
	277
	278
	279	alias XMLNamespaceParser!(char) Utf8XMLNamespaceParser;
	280	alias XMLNamespaceParser!(wchar) Utf16XMLNamespaceParser;
	281	alias XMLNamespaceParser!(dchar) Utf32XMLNamespaceParser;

trunk/xml/xmlns/all.d

r47	r80
26	26	module xml.xmlns.all;
27	27
28		~~private~~ import xml.xmlns.QName;
29		~~private~~ import xml.xmlns.IXMLNamespaceConsumer;
30		~~private~~ import xml.xmlns.IXMLNamespaceConsumerAdapter;
31		~~private~~ import xml.xmlns.XMLNamespaceParser;
32		~~private~~ import xml.xmlns.XMLNSAttributes;
	28	import xml.xmlns.QName;
	29	import xml.xmlns.IXMLNamespaceConsumer;
	30	import xml.xmlns.IXMLNamespaceConsumerAdapter;
	31	import xml.xmlns.XMLNamespaceParser;
	32	import xml.xmlns.XMLNSAttributes;

Download in other formats:

© Copyright 2004-2009 - The Sankaty Group, Inc. All rights reserved.

Make a Donation

Privacy Statement Terms of Service