Context Navigation

source: Dev/branches/rest-dojo-ui/jQueryUI/server/rdfapi/syntax/RdfParser.php @ 312

Last change on this file since 312 was 312, checked in by jkraaijeveld, 13 years ago

File size: 66.7 KB

Line
1	<?php
2
3	// ----------------------------------------------------------------------------------
4	// Class: RdfParser
5	// ----------------------------------------------------------------------------------
6
7
8	/**
9	* An RDF paser.
10	* This class reads RDF data from files or URIs and generates models out of it. All valid
11	* RDF XML syntaxes defined by the W3C in RDF/XML Syntax Specification (Revised)
12	* - W3C Working Draft 10 October 2003
13	* (http://www.w3.org/TR/2003/WD-rdf-syntax-grammar-20031010/) are supported.
14	* The parser is based on the PHP version of repat
15	* (http://phpxmlclasses.sourceforge.net/show_doc.php?class=class_rdf_parser.html)
16	* by Luis Argerich (lrargerich@yahoo.com).
17	*
18	* @version $Id: RdfParser.php 493 2007-08-12 17:43:07Z cweiske $
19	* @author Luis Argerich <lrargerich@yahoo.com>,
20	* Chris Bizer <chris@bizer.de>,
21	* Radoslaw Oldakowski <radol@gmx.de>
22	* Daniel Westphal <mail@d-westphal.de>
23	* @package syntax
24	* @access public
25	*
26	*/
27
28	class RdfParser extends Object {
29
30	var $rdf_parser;
31	var $model;
32
33	/* Private Methods */
34
35
36	/**
37	* converts a string to its unicode NFC form (e.g. \uHHHH or \UHHHHHHHH).
38	*
39	* @param String $str
40	* @return String
41	* @access private
42	*
43	*/
44	function str2unicode_nfc($str=""){
45	$result="";
46	/* try to detect encoding */
47	$tmp=str_replace("?", "", $str);
48	if(strpos(utf8_decode($tmp), "?")===false){
49	$str=utf8_decode($str);
50	}
51	for($i=0,$i_max=strlen($str);$i<$i_max;$i++){
52	$nr=0;/* unicode dec nr */
53	/* char */
54	$char=$str[$i];
55	/* utf8 binary */
56	$utf8_char=utf8_encode($char);
57	$bytes=strlen($utf8_char);
58	if($bytes==1){
59	/* 0####### (0-127) */
60	$nr=ord($utf8_char);
61	}
62	elseif($bytes==2){
63	/* 110##### 10###### = 192+x 128+x */
64	$nr=((ord($utf8_char[0])-192)*64) + (ord($utf8_char[1])-128);
65	}
66	elseif($bytes==3){
67	/* 1110#### 10###### 10###### = 224+x 128+x 128+x */
68	$nr=((ord($utf8_char[0])-224)4096) + ((ord($utf8_char[1])-128)64) + (ord($utf8_char[2])-128);
69	}
70	elseif($bytes==4){
71	/* 1111#### 10###### 10###### 10###### = 240+x 128+x 128+x 128+x */
72	$nr=((ord($utf8_char[0])-240)262144) + ((ord($utf8_char[1])-128)4096) + ((ord($utf8_char[2])-128)*64) + (ord($utf8_char[3])-128);
73	}
74	/* result (see http://www.w3.org/TR/rdf-testcases/#ntrip_strings) */
75	if($nr<9){/* #x0-#x8 (0-8) */
76	$result.="\\u".sprintf("%04X",$nr);
77	}
78	elseif($nr==9){/* #x9 (9) */
79	$result.='\t';
80	}
81	elseif($nr==10){/* #xA (10) */
82	$result.='\n';
83	}
84	elseif($nr<13){/* #xB-#xC (11-12) */
85	$result.="\\u".sprintf("%04X",$nr);
86	}
87	elseif($nr==13){/* #xD (13) */
88	$result.='\t';
89	}
90	elseif($nr<32){/* #xE-#x1F (14-31) */
91	$result.="\\u".sprintf("%04X",$nr);
92	}
93	elseif($nr<34){/* #x20-#x21 (32-33) */
94	$result.=$char;
95	}
96	elseif($nr==34){/* #x22 (34) */
97	$result.='\"';
98	}
99	elseif($nr<92){/* #x23-#x5B (35-91) */
100	$result.=$char;
101	}
102	elseif($nr==92){/* #x5C (92) */
103	$result.='\\';
104	}
105	elseif($nr<127){/* #x5D-#x7E (93-126) */
106	$result.=$char;
107	}
108	elseif($nr<65536){/* #x7F-#xFFFF (128-65535) */
109	$result.="\\u".sprintf("%04X",$nr);
110	}
111	elseif($nr<1114112){/* #x10000-#x10FFFF (65536-1114111) */
112	$result.="\\U".sprintf("%08X",$nr);
113	}
114	else{
115	/* other chars are not defined => ignore */
116	}
117	}
118	return $result;
119	}
120
121
122
123
124	/**
125	* @access private
126	*/
127	function _new_element()
128	{
129	$e['parent']=Array(); // Parent is a blank Array
130	$e['state']=0;
131	$e['has_property_atributes']=0;
132	$e['has_member_attributes']=0;
133	$e['subject_type']=0;
134	$e['subject']='';
135	$e['predicate']='';
136	$e['ordinal']=0;
137	$e['members']=0;
138	$e['data']='';
139	$e['xml_lang']='';
140	$e['bag_id']='';
141	$e['statements']=0;
142	$e['statement_id']='';
143	$e['datatype']='';
144	$e['element_base_uri'] = '';
145
146	return $e;
147	}
148
149	/**
150
151	* @param string $source
152	* @param string &$destination
153	*
154	* @access private
155	*/
156	function _copy_element($source, &$destination )
157	{
158	if( $source )
159	{
160	$destination['parent'] = $source;
161	$destination['state'] = $source['state'];
162	$destination['xml_lang'] = $source['xml_lang'];
163	$destination['element_base_uri'] = $source['element_base_uri'];
164	}
165	}
166
167	/**
168	* @param string &$e
169	* @access private
170	*/
171	function _clear_element(&$e)
172	{
173	$e['subject']='';
174	$e['predicate']='';
175	$e['data']='';
176	$e['bag_id']='';
177	$e['statement_id']='';
178
179	if(isset($e['parent'])) {
180	if( $e['parent'] )
181	{
182	if( $e['parent']['xml_lang'] != $e['xml_lang'] )
183	{
184	$e['xml_lang']='';
185	}
186	}
187	else
188	{
189	$e['xml_lang']='';
190	}
191	} else {
192	$e['xml_lang']='';
193	}
194
195	$e['parent']=Array();
196	$e['state']=0;
197	$e['has_property_attributes']=0;
198	$e['has_member_attributes']=0;
199	$e['subject_type']=0;
200	$e['subject']='';
201	$e['predicate']='';
202	$e['ordinal']=0;
203	$e['members']=0;
204	$e['data']='';
205	$e['xml_lang']='';
206	$e['bag_id']='';
207	$e['statements']=0;
208	$e['statement_id']='';
209	$e['datatype']='';
210	$e['element_base_uri'] = '';
211	}
212
213	/**
214	* @access private
215	*/
216	function _push_element()
217	{
218	if(!isset($this->rdf_parser['free'])) {
219	$this->rdf_parser['free']=Array();
220	}
221	if(count($this->rdf_parser['free'])>0)
222	{
223	$e = $this->rdf_parser['free'];
224	if(isset($e['parent'])) {
225	$this->rdf_parser['free'] = $e['parent'];
226	} else {
227	$this->rdf_parser['free']=$this->_new_element();
228	}
229	}
230	else
231	{
232	$e = $this->_new_element();
233	}
234	if(!isset($this->rdf_parser['top'])) {
235	$this->rdf_parser['top']=Array();
236	}
237	$this->_copy_element( $this->rdf_parser['top'], $e );
238	$this->rdf_parser['top'] = $e;
239	}
240
241	/**
242	* @access private
243	*/
244	function _pop_element()
245	{
246	$e = $this->rdf_parser['top'];
247	$this->rdf_parser['top'] = $e['parent'];
248	$this->_clear_element( $e );
249	$this->rdf_parser['free'] = $e;
250	}
251
252	/**
253	* @param string $local_name
254	* @access private
255	*/
256	function _is_rdf_property_attribute_resource($local_name )
257	{
258	return ( $local_name == RDF_TYPE );
259	}
260
261	/**
262	* @param string $local_name
263	* @access private
264	*/
265	function _is_rdf_property_attribute_literal($local_name )
266	{
267	return ( $local_name == RDF_VALUE )
268	\|\| ( $local_name == RDF_BAG )
269	\|\| ( $local_name == RDF_SEQ )
270	\|\| ( $local_name == RDF_ALT )
271	\|\| ( $local_name == RDF_STATEMENT )
272	\|\| ( $local_name == RDF_PROPERTY )
273	\|\| ( $local_name == RDF_LIST );
274	}
275
276	/**
277	* @param string $local_name
278	* @access private
279	*/
280	function _is_rdf_ordinal( $local_name )
281	{
282	$ordinal = -1;
283
284	if( $local_name{0} == '_' )
285	{
286	$ordinal = substr($local_name,1) + 1 ;
287	}
288
289	return ( $ordinal > 0 ) ? $ordinal : 0;
290	}
291
292	/**
293	* @param string $local_name
294	* @access private
295	*/
296	function _is_rdf_property_attribute( $local_name )
297	{
298	return $this->_is_rdf_property_attribute_resource( $local_name )
299	\|\| $this->_is_rdf_property_attribute_literal( $local_name );
300	}
301
302	function _is_forbidden_rdf_property_attribute($local_name)
303	{
304	return ( $local_name == RDF_RDF )
305	\|\| ( $local_name == RDF_DESCRIPTION)
306	\|\| ( $local_name == RDF_ID)
307	\|\| ( $local_name == RDF_ABOUT )
308	\|\| ( $local_name == RDF_BAG_ID )
309	\|\| ( $local_name == RDF_PARSE_TYPE )
310	\|\| ( $local_name == RDF_RESOURCE )
311	\|\| ( $local_name == RDF_NODEID )
312	\|\| ( $local_name == RDF_LI )
313	\|\| ( $local_name == RDF_ABOUT_EACH )
314	\|\| ( $local_name == RDF_ABOUT_EACH_PREFIX )
315	\|\| ( $local_name == RDF_DATATYPE );
316	}
317
318	/**
319	* @param string $local_name
320	* @access private
321	*/
322	function _is_rdf_property_element( $local_name )
323	{
324	return ( $local_name == RDF_TYPE )
325	\|\| ( $local_name == RDF_SUBJECT )
326	\|\| ( $local_name == RDF_PREDICATE )
327	\|\| ( $local_name == RDF_OBJECT )
328	\|\| ( $local_name == RDF_VALUE )
329	\|\| ( $local_name == RDF_LI )
330	\|\| ( $local_name == RDF_SEEALSO )
331	\|\| ( $local_name == RDF_BAG )
332	\|\| ( $local_name == RDF_SEQ )
333	\|\| ( $local_name == RDF_ALT )
334	\|\| ( $local_name == RDF_STATEMENT )
335	\|\| ( $local_name == RDF_PROPERTY )
336	\|\| ( $local_name == RDF_LIST )
337	\|\| ( $local_name == RDF_FIRST )
338	\|\| ( $local_name == RDF_REST )
339	\|\| ( $local_name{0} == '_' );
340	}
341
342	/**
343	* @param string $local_name
344	* @access private
345	*/
346	function _is_forbidden_rdf_property_element ($local_name)
347	{
348	return ( $local_name == RDF_RDF )
349	\|\| ( $local_name == RDF_DESCRIPTION)
350	\|\| ( $local_name == RDF_ID)
351	\|\| ( $local_name == RDF_ABOUT )
352	\|\| ( $local_name == RDF_BAG_ID )
353	\|\| ( $local_name == RDF_PARSE_TYPE )
354	\|\| ( $local_name == RDF_RESOURCE )
355	\|\| ( $local_name == RDF_NODEID )
356	\|\| ( $local_name == RDF_ABOUT_EACH )
357	\|\| ( $local_name == RDF_ABOUT_EACH_PREFIX )
358	\|\| ( $local_name == RDF_DATATYPE );
359	}
360
361
362	/**
363	* @param string $local_name
364	* @access private
365	*/
366	function _is_rdf_node_element( $local_name )
367	{
368	return ( $local_name == RDF_DESCRIPTION )
369	\|\| ( $local_name == RDF_STATEMENT )
370	\|\| ( $local_name == RDF_SUBJECT )
371	\|\| ( $local_name == RDF_PREDICATE )
372	\|\| ( $local_name == RDF_OBJECT )
373	\|\| ( $local_name == RDF_PROPERTY )
374	\|\| ( $local_name == RDF_TYPE )
375	\|\| ( $local_name == RDF_VALUE )
376	\|\| ( $local_name == RDF_BAG )
377	\|\| ( $local_name == RDF_SEQ )
378	\|\| ( $local_name == RDF_ALT )
379	\|\| ( $local_name == RDF_SEEALSO )
380	\|\| ( $local_name == RDF_LIST )
381	\|\| ( $local_name == RDF_FIRST )
382	\|\| ( $local_name == RDF_REST )
383	\|\| ( $local_name == RDF_NIL )
384	\|\| ( $local_name{0} == '_' );
385	}
386
387	/**
388	* @param string $local_name
389	* @access private
390	*/
391	function _is_forbidden_rdf_node_element ($local_name)
392	{
393	return ( $local_name == RDF_RDF )
394	\|\| ( $local_name == RDF_ID)
395	\|\| ( $local_name == RDF_ABOUT )
396	\|\| ( $local_name == RDF_BAG_ID )
397	\|\| ( $local_name == RDF_PARSE_TYPE )
398	\|\| ( $local_name == RDF_RESOURCE )
399	\|\| ( $local_name == RDF_NODEID )
400	\|\| ( $local_name == RDF_LI )
401	\|\| ( $local_name == RDF_ABOUT_EACH )
402	\|\| ( $local_name == RDF_ABOUT_EACH_PREFIX )
403	\|\| ( $local_name == RDF_DATATYPE );
404	}
405
406	/**
407	* @param string $val
408	* @access private
409	*/
410	function _istalnum($val) {
411	return preg_match('/([A-Za-z0-9])/',$val);
412	}
413	/**
414	* @param string $val
415	* @access private
416	*/
417	function _istalpha($val) {
418	return preg_match('/([A-Za-z])/',$val);
419	}
420
421	/**
422	* @param string $uri
423	* @access private
424	*/
425	function _is_absolute_uri($uri )
426	{
427	$result = false;
428	$uri_p=0;
429	if( $uri && $this->_istalpha( $uri{$uri_p} ) )
430	{
431	++$uri_p;
432
433	while( ($uri_p<strlen($uri))
434	&& ( $this->_istalnum( $uri{$uri_p} )
435	\|\| ( $uri{$uri_p} == '+' )
436	\|\| ( $uri{$uri_p} == '-' )
437	\|\| ( $uri{$uri_p} == '.' ) ) )
438	{
439	++$uri_p;
440	}
441
442	$result = ( $uri{$uri_p} == ':' );
443	}
444	return $result;
445	}
446
447
448	/*
449	* This function returns an associative array returning any of the various components of the URL that are present. This includes the
450	* $arr=parse_url($url)
451	* scheme - e.g. http
452	* host
453	* port
454	* user
455	* pass
456	* path
457	* query - after the question mark ?
458	* fragment - after the hashmark #
459	*
460	* @param string $uri
461	* @param string $buffer
462	* @param string &$scheme
463	* @param string &$authority
464	* @param string &$path
465	* @param string &$query
466	* @param string &$fragment
467	* @access private
468	*/
469	function _parse_uri($uri,$buffer,&$scheme,&$authority,&$path,&$query,&$fragment ) {
470
471	$parsed=parse_url($uri);
472	if(isset($parsed['scheme'])) {
473	$scheme=$parsed['scheme'];
474	} else {
475	$scheme='';
476	}
477	if(isset($parsed['host'])) {
478	$host=$parsed['host'];
479	} else {
480	$host='';
481	}
482	if(isset($parsed['host'])) {
483	$authority=$parsed['host'];
484	} else {
485	$authority='';
486	}
487	if(isset($parsed['path'])) {
488	$path=$parsed['path'];
489	} else {
490	$path='';
491	}
492	if(isset($parsed['query'])) {
493	$query=$parsed['query'];
494	} else {
495	$query='';
496	}
497	if(isset($parsed['fragment'])) {
498	$fragment=$parsed['fragment'];
499	} else {
500	$fragment='';
501	}
502
503	}
504
505	/**
506	* @param string $base_uri
507	* @param string $reference_uri
508	* @param string &$buffer
509	* @access private
510	*/
511	function _resolve_uri_reference($base_uri,$reference_uri,&$buffer )
512	{
513	if ($reference_uri == '')
514	return ($buffer = preg_replace("/\#[^\/\\\]*$/", '', $base_uri));
515
516	$base_buffer='';
517	$reference_buffer='';
518	$path_buffer='';
519
520	$buffer = '';
521
522	$this->_parse_uri($reference_uri,
523	$reference_buffer,
524	$reference_scheme,
525	$reference_authority,
526	$reference_path,
527	$reference_query,
528	$reference_fragment );
529
530	$this->_parse_uri($base_uri,
531	$base_buffer,
532	$base_scheme,
533	$base_authority,
534	$base_path,
535	$base_query,
536	$base_fragment );
537
538	if( $reference_scheme == ''
539	&& $reference_authority == ''
540	&& $reference_path == ''
541	&& $reference_query == '' )
542	{
543	$buffer=$base_uri;
544
545	if( $reference_fragment != '' )
546	{
547	if ($base_path == '' \|\| $base_path == '/' \|\| $base_path == "\\") {
548	$buffer = $this->rdf_parser['document_base_uri'];
549	}
550	else
551	{
552	$buffer = preg_replace("/\#[^\/\\\]*$/", '', $base_uri);
553	}
554
555	// CB: Changed for base URI
556	$c = substr($buffer, strlen($buffer)-1 ,1);
557	if (!($c=='#' \|\| $c==':' \|\| $c=='/' \|\| $c=="\\"))
558	$buffer.= '#' ;
559	$buffer.=$reference_fragment;
560
561	}
562	}
563	else if( $reference_scheme != '' )
564	{
565	$buffer=$reference_uri;
566	}
567	else
568	{
569	$result_scheme = $base_scheme;
570	$result_path = '';
571
572	if( $reference_authority != '' )
573	{
574	$result_authority = $reference_authority;
575	}
576	else
577	{
578	$result_authority = $base_authority;
579
580	if ($reference_path != '')
581	{
582	if ($reference_path{0} == '/' \|\| $reference_path{0} == "\\")
583	{
584	if ($reference_path{1} == '/' \|\| $reference_path{1} == "\\")
585	{
586	$result_authority = '';
587	$result_path = $reference_path;
588	}
589	else
590	$result_path = $reference_path;
591	}
592	elseif (substr($reference_path, 0, 3) == '../' \|\|
593	substr($reference_path, 0, 3) == '..\\')
594	{
595	$slash = $reference_path{2};
596	while($base_path != '' && ( substr($reference_path, 0, 3) == '../'
597	\|\| substr($reference_path, 0, 3) == '..\\'))
598	{
599	$base_path = preg_replace("/((\/)\|(\\\))[^\/\\\]*$/", '', $base_path);
600	if ($base_path != '') {
601	$base_path = preg_replace("/((\/)\|(\\\))[^\/\\\]*$/", '', $base_path);
602	$reference_path = substr($reference_path, 3);
603	}
604	}
605
606	$result_path = $base_path .$slash .$reference_path;
607	}
608	else
609	{
610	if ($base_path)
611	$result_path = preg_replace("/[^\/\\\]*$/", $reference_path, $base_path, 1);
612	else
613	$result_path = '/' .$reference_path;
614	}
615	}
616
617	}
618
619	if( $result_scheme != '' )
620	{
621	$buffer=$result_scheme;
622	$buffer.=':';
623	}
624
625	if( $result_authority != '' )
626	{
627	$buffer.="//";
628	$buffer.=$result_authority;
629	}
630
631	if( $result_path != '' )
632	{
633	$buffer.=$result_path;
634	}
635
636	if( $reference_query != '' )
637	{
638	$buffer.='?';
639	$buffer.=$reference_query;
640	}
641
642	if( $reference_fragment != '' )
643	{
644	$buffer.='#';
645	$buffer.=$reference_fragment;
646	}
647	}
648	}
649
650
651	/**
652	* IDs which contain CombiningChars or Extenders
653	* (see http://www.w3.org/TR/REC-xml-names/#NT-NCName) are assumed to be invalid.
654	* If you want to use IDs containing these characters you can turn off
655	* the validating by setting the constant VALIDATE_IDS to FALSE (see constants.php).
656	*
657	* @param string $id
658	* @access private
659	*/
660	function is_valid_id($id )
661	{
662	if (!VALIDATE_IDS)
663	return TRUE;
664
665	$result = FALSE;
666
667	if( $id )
668	{
669	if( $this->_istalpha($id{0}) \|\| $id{0} == '_')
670	{
671	$result = TRUE;
672	$i=0;
673	$len = strlen($id);
674	while( $result != FALSE && ++$i < $len )
675	{
676	if( !($this->_istalnum( $id{$i})
677	\|\| $id{$i} == '.'
678	\|\| $id{$i} == '-'
679	\|\| $id{$i} == '_'))
680	{
681	$result = FALSE;
682	}
683	}
684	}
685	}
686
687	if (!$result)
688	$this->_report_error('illegal ID, nodeID or bagID attribute value');
689	else
690	return TRUE;
691	}
692
693	/**
694	* @param string $id
695	* @param string &$buffer
696	* @access private
697	*/
698	function _resolve_id($id,&$buffer )
699	{
700	$id_buffer='';
701
702	if( $this->is_valid_id($id) )
703	{
704	$id_buffer="#$id";
705	}
706
707	$this->_resolve_uri_reference( $this->rdf_get_base(), $id_buffer, $buffer );
708
709	}
710
711	/**
712	* @param string $name
713	* @param string &$buffer
714	* @param string &$namespace_uri
715	* @param string &$local_name
716	* @access private
717	*/
718	function _split_name($name, &$buffer, &$namespace_uri, &$local_name )
719	{
720	static $nul = 0;
721	$buffer=$name;
722
723	if( strstr( $buffer, NAMESPACE_SEPARATOR_CHAR ) )
724	{
725	$cosas=explode(NAMESPACE_SEPARATOR_CHAR,$buffer);
726	$namespace_uri = $cosas[0];
727	$local_name = $cosas[1];
728	}
729	else
730	{
731	if( ( $buffer{ 0 } == 'x' )
732	&& ( $buffer{ 1 } == 'm' )
733	&& ( $buffer{ 2 } == 'l' )
734	&& ( $buffer{ 3 } == ':' ) )
735	{
736	$namespace_uri = XML_NAMESPACE_URI;
737	$local_name = substr($buffer,4);
738	}
739	else
740	{
741	$namespace_uri = '';
742	$local_name = $buffer;
743	}
744	}
745	}
746	/**
747	* @param string &$buf
748	* @access private
749	*/
750	function _generate_anonymous_uri(&$buf )
751	{
752	$id='';
753	if(!isset($this->rdf_parser['anonymous_id'])) {
754	$this->rdf_parser['anonymous_id']=0;
755	}
756	$this->rdf_parser['anonymous_id']++;
757
758	$buf= BNODE_PREFIX . $this->rdf_parser['anonymous_id'];
759
760	}
761	/**
762	* @param string $subject_type
763	* @param string $subject
764	* @param string $predicate
765	* @param string $ordinal
766	* @param string $object_type
767	* @param string $object
768	* @param string $xml_lang
769	* @param string $bag_id
770	* @param string $statements
771	* @param string $statement_id
772	* @access private
773	*/
774	function _report_statement( $subject_type, $subject, $predicate, $ordinal, $object_type, $object, $xml_lang, $bag_id, $statements, $statement_id, $datatype )
775	{
776	$statement_id_type = RDF_SUBJECT_TYPE_URI;
777	$statement_id_buffer='';
778	$predicate_buffer='';
779	if (!$xml_lang && $object_type == RDF_OBJECT_TYPE_LITERAL && isset($this->rdf_parser['document_xml_lang']))
780	$xml_lang = $this->rdf_parser['document_xml_lang'];
781
782	// call add statement
783	$this->add_statement_to_model($this->rdf_parser['user_data'],$subject_type,$subject,$predicate,$ordinal,$object_type,$object,$xml_lang, $datatype );
784
785	if( $bag_id )
786	{
787	if( $statements == '' )
788	{
789	$this->_report_statement(RDF_SUBJECT_TYPE_URI,
790	$bag_id,
791	RDF_NAMESPACE_URI.RDF_TYPE,
792	0,
793	RDF_OBJECT_TYPE_RESOURCE,
794	RDF_NAMESPACE_URI.RDF_BAG,
795	'',
796	'',
797	'',
798	'',
799	$datatype );
800	}
801
802	if( ! $statement_id )
803	{
804	$statement_id_type = RDF_SUBJECT_TYPE_BNODE;
805	$this->_generate_anonymous_uri( $statement_id_buffer );
806	$statement_id = $statement_id_buffer;
807	}
808	$statements++;
809	$predicate_buffer='RDF_NAMESPACE_URI_'.$statements;
810
811	$this->_report_statement(
812	RDF_SUBJECT_TYPE_URI,
813	$bag_id,
814	$predicate_buffer,
815	$statements,
816	RDF_OBJECT_TYPE_BNODE,
817	$statement_id,
818	'',
819	'',
820	'',
821	'',
822	$datatype );
823	}
824
825	if( $statement_id )
826	{
827	// rdf:type = rdf:Statement
828	$this->_report_statement(
829	$statement_id_type,
830	$statement_id,
831	RDF_NAMESPACE_URI.RDF_TYPE,
832	0,
833	RDF_OBJECT_TYPE_RESOURCE,
834	RDF_NAMESPACE_URI.RDF_STATEMENT,
835	'',
836	'',
837	'',
838	'',
839	$datatype );
840
841	if ($subject_type == RDF_SUBJECT_TYPE_BNODE)
842	$obj_type = RDF_OBJECT_TYPE_BNODE;
843	else
844	$obj_type = RDF_OBJECT_TYPE_RESOURCE;
845
846
847	// rdf:subject
848	$this->_report_statement(
849	$statement_id_type,
850	$statement_id,
851	RDF_NAMESPACE_URI.RDF_SUBJECT,
852	0,
853	$obj_type,
854	$subject,
855	'',
856	'',
857	'',
858	'',
859	$datatype );
860
861	// rdf:predicate
862	$this->_report_statement(
863	$statement_id_type,
864	$statement_id,
865	RDF_NAMESPACE_URI.RDF_PREDICATE,
866	0,
867	RDF_OBJECT_TYPE_RESOURCE,
868	$predicate,
869	'',
870	'',
871	'',
872	'',
873	$datatype );
874
875	// rdf:object
876	$this->_report_statement(
877	$statement_id_type,
878	$statement_id,
879	RDF_NAMESPACE_URI.RDF_OBJECT,
880	0,
881	$object_type,
882	$object,
883	'',
884	'',
885	'',
886	'',
887	$datatype );
888	}
889	}
890	/**
891	* @param string $subject_type
892	* @param string $subject
893	* @param string $attributes
894	* @param string $xml_lang
895	* @param string $bag_id
896	* @param string $statements
897	* @access private
898	*/
899	function _handle_property_attributes($subject_type, $subject, $attributes, $xml_lang, $bag_id, $statements )
900	{
901	$i=0;
902
903	$attribute='';
904	$predicate='';
905
906	$attribute_namespace_uri='';
907	$attribute_local_name='';
908	$attribute_value='';
909
910	$ordinal=0;
911
912	for( $i = 0; isset($attributes[ $i ]); $i += 2 )
913	{
914	$this->_split_name(
915	$attributes[ $i ],
916	$attribute,
917	$attribute_namespace_uri,
918	$attribute_local_name );
919
920	$attribute_value = $attributes[ $i + 1 ];
921
922	$predicate=$attribute_namespace_uri;
923	$predicate.=$attribute_local_name;
924
925	if( RDF_NAMESPACE_URI == $attribute_namespace_uri )
926	{
927	if( $this->_is_rdf_property_attribute_literal( $attribute_local_name ) )
928	{
929	$this->_report_statement(
930	$subject_type,
931	$subject,
932	$predicate,
933	0,
934	RDF_OBJECT_TYPE_LITERAL,
935	$attribute_value,
936	$xml_lang,
937	$bag_id,
938	$statements,
939	'',
940	'');
941	}
942	else if( $this->_is_rdf_property_attribute_resource( $attribute_local_name ) )
943	{
944	$this->_report_statement(
945	$subject_type,
946	$subject,
947	$predicate,
948	0,
949	RDF_OBJECT_TYPE_RESOURCE,
950	$attribute_value,
951	'',
952	$bag_id,
953	$statements,
954	'',
955	'');
956	}
957	else if( ( $ordinal = $this->_is_rdf_ordinal( $attribute_local_name ) ) != 0 )
958	{
959	$this->_report_statement(
960	$subject_type,
961	$subject,
962	$predicate,
963	$ordinal,
964	RDF_OBJECT_TYPE_LITERAL,
965	$attribute_value,
966	$xml_lang,
967	$bag_id,
968	$statements,
969	'',
970	'' );
971	}
972	else if ( ($attribute_local_name != RDF_ABOUT)
973	&& ($attribute_local_name != RDF_RDF)
974	&& ($attribute_local_name != RDF_DESCRIPTION)
975	&& ($attribute_local_name != RDF_ID)
976	&& ($attribute_local_name != RDF_ABOUT_EACH)
977	&& ($attribute_local_name != RDF_ABOUT_EACH_PREFIX)
978	&& ($attribute_local_name != RDF_BAG_ID)
979	&& ($attribute_local_name != RDF_RESOURCE)
980	&& ($attribute_local_name != RDF_PARSE_TYPE)
981	&& ($attribute_local_name != RDF_PARSE_TYPE_LITERAL)
982	&& ($attribute_local_name != RDF_PARSE_TYPE_RESOURCE)
983	&& ($attribute_local_name != RDF_LI)
984	&& ($attribute_local_name != RDF_SUBJECT)
985	&& ($attribute_local_name != RDF_PREDICATE)
986	&& ($attribute_local_name != RDF_OBJECT)
987	&& ($attribute_local_name != RDF_NODEID)
988	&& ($attribute_local_name != RDF_DATATYPE)
989	&& ($attribute_local_name != RDF_SEEALSO)
990	&& ($attribute_local_name != RDF_NIL)
991	&& ($attribute_local_name != RDF_REST)
992	&& ($attribute_local_name != RDF_FIRST)
993	)
994	{
995	$this->_report_statement(
996	$subject_type,
997	$subject,
998	$predicate,
999	0,
1000	RDF_OBJECT_TYPE_LITERAL,
1001	$attribute_value,
1002	$xml_lang,
1003	$bag_id,
1004	$statements,
1005	'',
1006	'' );
1007	}
1008	}
1009	else if( XML_NAMESPACE_URI == $attribute_namespace_uri )
1010	{
1011	if ($attribute_local_name == 'base')
1012	{
1013	$this->rdf_parser['top']['element_base_uri'] = $attribute_value;
1014	}
1015	}
1016	else if( $attribute_namespace_uri )
1017	{
1018	// is it required that property attributes be in an explicit namespace?
1019
1020	$this->_report_statement(
1021	$subject_type,
1022	$subject,
1023	$predicate,
1024	0,
1025	RDF_OBJECT_TYPE_LITERAL,
1026	$attribute_value,
1027	$xml_lang,
1028	$bag_id,
1029	$statements,
1030	'',
1031	'' );
1032	}
1033	}
1034	}
1035
1036
1037
1038	/**
1039	* @param string $warning
1040	* @access private
1041	*/
1042	function _report_warning($warning)
1043	{
1044	$errmsg = RDFAPI_ERROR . '(class: parser): ' . $warning .'.';
1045	trigger_error($errmsg, E_USER_WARNING);
1046	}
1047
1048
1049	function _report_error($error)
1050	{
1051	$errmsg = RDFAPI_ERROR . '(class: parser): ' . $error .'.';
1052	trigger_error($errmsg, E_USER_ERROR);
1053	}
1054
1055
1056	/**
1057	* @param string $namespace_uri
1058	* @param string $local_name
1059	* @param string $attributes
1060	* @param string $parent
1061	* @access private
1062	*/
1063	function _handle_resource_element( $namespace_uri, $local_name, $attributes, $parent )
1064	{
1065	$subjects_found = 0;
1066	$aux=$attributes;
1067	$aux2=Array();
1068	foreach($attributes as $atkey=>$atvalue) {
1069	$aux2[]=$atkey;
1070	$aux2[]=$atvalue;
1071	}
1072	$attributes=$aux2;
1073	$id = '';
1074	$about = '';
1075
1076	$bag_id = '';
1077	$node_id = '';
1078	$datatype = '';
1079
1080	$i=0;
1081
1082	$attribute='';
1083
1084	$attribute_namespace_uri='';
1085	$attribute_local_name='';
1086	$attribute_value='';
1087
1088	$id_buffer='';
1089
1090	$type='';
1091
1092	$this->rdf_parser['top']['has_property_attributes'] = false;
1093	$this->rdf_parser['top']['has_member_attributes'] = false;
1094
1095
1096	if( $namespace_uri == RDF_NAMESPACE_URI )
1097	{
1098	if( ! $this->_is_rdf_node_element( $local_name ) )
1099	{
1100	$msg = 'unknown or out of context rdf node element: '.$local_name;
1101
1102	if ($this->_is_forbidden_rdf_node_element($local_name))
1103	$this->_report_error($msg);
1104	else
1105	$this->_report_warning($msg);
1106	}
1107	}
1108
1109	// examine each attribute for the standard RDF "keywords"
1110	for( $i = 0; isset($attributes[$i]); $i += 2 )
1111	{
1112	$this->_split_name(
1113	$attributes[ $i ],
1114	$attribute,
1115	$attribute_namespace_uri,
1116	$attribute_local_name );
1117
1118	$attribute_value = $attributes[ $i + 1 ];
1119
1120	// if the attribute is not in any namespace
1121	// or the attribute is in the RDF namespace
1122	if( ( $attribute_namespace_uri == '' )
1123	\|\| ( $attribute_namespace_uri == RDF_NAMESPACE_URI ))
1124	{
1125	if( $attribute_local_name == RDF_ID )
1126	{
1127	$id = $attribute_value;
1128	++$subjects_found;
1129	} else if( $attribute_local_name == RDF_ABOUT ) {
1130	$about = '_'.$attribute_value;
1131	++$subjects_found;
1132	} else if( $attribute_local_name == RDF_NODEID) {
1133	$node_id = $attribute_value;
1134	++$subjects_found;
1135	} else if( $attribute_local_name == RDF_ABOUT_EACH ) {
1136	$error = 'aboutEach has been removed from the RDF specifications';
1137	$this->_report_error($error);
1138	} else if( $attribute_local_name == RDF_ABOUT_EACH_PREFIX ) {
1139	$error = 'aboutEachPrefix has been removed from the RDF specifications';
1140	$this->_report_error($error);
1141	} else if( $attribute_local_name == RDF_BAG_ID) {
1142	$bag_id = $attribute_value;
1143	} else if( $attribute_local_name == RDF_DATATYPE) {
1144	$datatype = $attribute_value;
1145	} else if( $this->_is_rdf_property_attribute( $attribute_local_name )) {
1146	$this->rdf_parser['top']['has_property_attributes'] = true;
1147	} else if( $this->_is_rdf_ordinal( $attribute_local_name )) {
1148	$this->rdf_parser['top']['has_property_attributes'] = true;
1149	$this->rdf_parser['top']['has_member_attributes'] = true;
1150	} else {
1151	$this->rdf_parser['top']['has_property_attributes'] = true;
1152	$msg = 'unknown or out of context rdf attribute: '.$attribute_local_name;
1153
1154	if ($this->_is_forbidden_rdf_property_attribute($attribute_local_name))
1155	$this->_report_error($msg);
1156	else
1157	$this->_report_warning($msg);
1158	}
1159	}
1160	else if( $attribute_namespace_uri == XML_NAMESPACE_URI )
1161	{
1162	if( $attribute_local_name == XML_LANG )
1163	{
1164	$this->rdf_parser['top']['xml_lang'] = $attribute_value;
1165	}
1166	elseif ($attribute_local_name == 'base')
1167	{
1168	$this->rdf_parser['top']['element_base_uri'] = $attribute_value;
1169	}
1170	}
1171	else if( $attribute_namespace_uri )
1172	{
1173	$this->rdf_parser['top']['has_property_attributes'] = true;
1174	}
1175	}
1176
1177	// if no subjects were found, generate one.
1178	if( $subjects_found == 0 )
1179	{
1180	$this->_generate_anonymous_uri( $id_buffer );
1181	$this->rdf_parser['top']['subject']=$id_buffer;
1182	$this->rdf_parser['top']['subject_type'] = RDF_SUBJECT_TYPE_BNODE;
1183	}
1184	else if( $subjects_found > 1 )
1185	{
1186	$this->_report_error('ID, about and nodeID are mutually exclusive');
1187	}
1188	else if( $id )
1189	{
1190	$this->_resolve_id( $id, $id_buffer );
1191	$this->rdf_parser['top']['subject_type'] = RDF_SUBJECT_TYPE_URI;
1192	$this->rdf_parser['top']['subject']=$id_buffer;
1193	}
1194	else if( $about )
1195	{
1196	$this->_resolve_uri_reference( $this->rdf_get_base(), substr($about,1), $id_buffer );
1197	$this->rdf_parser['top']['subject_type'] = RDF_SUBJECT_TYPE_URI;
1198	$this->rdf_parser['top']['subject']=$id_buffer;
1199	}
1200	else if( $node_id )
1201	{
1202	$this->is_valid_id($node_id);
1203	$this->rdf_parser['top']['subject_type'] = RDF_SUBJECT_TYPE_BNODE;
1204	$this->rdf_parser['top']['subject']=$node_id;
1205	}
1206
1207	// if the subject is empty, assign it the document uri
1208	if( $this->rdf_parser['top']['subject'] == '' )
1209	{
1210	$this->rdf_parser['top']['subject']=$this->rdf_get_base();
1211	}
1212
1213	if( $bag_id )
1214	{
1215	$this->_resolve_id( $bag_id, $id_buffer );
1216	$this->rdf_parser['top']['bag_id']=$id_buffer;
1217	}
1218
1219	// only report the type for non-rdf:Description elements.
1220	if( ($local_name != RDF_DESCRIPTION )
1221	\|\| ( $namespace_uri != RDF_NAMESPACE_URI ) )
1222	{
1223	$type=$namespace_uri;
1224	$type.=$local_name;
1225
1226	$this->_report_statement(
1227	$this->rdf_parser['top']['subject_type'],
1228	$this->rdf_parser['top']['subject'],
1229	RDF_NAMESPACE_URI.RDF_TYPE,
1230	0,
1231	RDF_OBJECT_TYPE_RESOURCE,
1232	$type,
1233	'',
1234	$this->rdf_parser['top']['bag_id'],
1235	$this->rdf_parser['top']['statements'],
1236	'',
1237	$datatype);
1238
1239	}
1240
1241	// if this element is the child of some property,
1242	// report the appropriate statement.
1243	if( $parent )
1244	{
1245	if ($this->rdf_parser['top']['subject_type'] == RDF_SUBJECT_TYPE_BNODE)
1246	$objtype = RDF_OBJECT_TYPE_BNODE;
1247	else
1248	$objtype = RDF_OBJECT_TYPE_RESOURCE;
1249
1250	$this->_report_statement(
1251	$parent['parent']['subject_type'],
1252	$parent['parent']['subject'],
1253	$parent['predicate'],
1254	$parent['ordinal'],
1255	$objtype,
1256	$this->rdf_parser['top']['subject'],
1257	'',
1258	$parent['parent']['bag_id'],
1259	$parent['parent']['statements'],
1260	$parent['statement_id'],
1261	$parent['datatype']);
1262
1263	}
1264
1265	if( $this->rdf_parser['top']['has_property_attributes'] )
1266	{
1267	$this->_handle_property_attributes(
1268	$this->rdf_parser['top']['subject_type'],
1269	$this->rdf_parser['top']['subject'],
1270	$attributes,
1271	$this->rdf_parser['top']['xml_lang'],
1272	$this->rdf_parser['top']['bag_id'],
1273	$this->rdf_parser['top']['statements'] );
1274	}
1275	}
1276
1277	/**
1278	* @param string &$namespace_uri
1279	* @param string &$local_name
1280	* @param string &$attributes
1281	* @access private
1282	*/
1283	function _handle_property_element( &$namespace_uri, &$local_name, &$attributes )
1284	{
1285	$buffer='';
1286
1287	$i=0;
1288
1289	$aux=$attributes;
1290	$aux2=Array();
1291	foreach($attributes as $atkey=>$atvalue) {
1292	$aux2[]=$atkey;
1293	$aux2[]=$atvalue;
1294	}
1295	$attributes=$aux2;
1296
1297	$attribute_namespace_uri='';
1298	$attribute_local_name='';
1299	$attribute_value = '';
1300
1301	$resource = NULL;
1302	$statement_id = '';
1303	$bag_id = '';
1304	$parse_type = '';
1305	$node_id = '';
1306	$datatype = '';
1307
1308	$this->rdf_parser['top']['ordinal'] = 0;
1309
1310	if( $namespace_uri == RDF_NAMESPACE_URI )
1311	{
1312	if( ! $this->_is_rdf_property_element( $local_name ) )
1313	{
1314	$msg = 'unknown or out of context rdf property element: '.$local_name;
1315
1316	if ($this->_is_forbidden_rdf_property_element($local_name))
1317	$this->_report_error($msg);
1318	else
1319	$this->_report_warning($msg);
1320	}
1321
1322	}
1323
1324	$buffer=$namespace_uri;
1325
1326	if( ( $namespace_uri == RDF_NAMESPACE_URI )
1327	&& ( $local_name == RDF_LI ) )
1328	{
1329	$this->rdf_parser['top']['parent']['members']++;
1330	$this->rdf_parser['top']['ordinal'] = $this->rdf_parser['top']['parent']['members'];
1331
1332	$this->rdf_parser['top']['ordinal']=$this->rdf_parser['top']['ordinal'];
1333
1334	$buffer.='_'.$this->rdf_parser['top']['ordinal'];
1335
1336	}
1337	else
1338	{
1339	$buffer.=$local_name;
1340	}
1341
1342	$this->rdf_parser['top']['predicate']=$buffer;
1343
1344	$this->rdf_parser['top']['has_property_attributes'] = false;
1345	$this->rdf_parser['top']['has_member_attributes'] = false;
1346
1347
1348	for( $i = 0; isset($attributes[$i]); $i += 2 )
1349	{
1350	$this->_split_name(
1351	$attributes[$i],
1352	$buffer,
1353	$attribute_namespace_uri,
1354	$attribute_local_name );
1355
1356	$attribute_value = $attributes[$i + 1];
1357
1358	// if the attribute is not in any namespace
1359	// or the attribute is in the RDF namespace
1360	if( ( $attribute_namespace_uri == '' )
1361	\|\| ( $attribute_namespace_uri == RDF_NAMESPACE_URI ) )
1362	{
1363	if( ( $attribute_local_name == RDF_ID ) )
1364	{
1365	$statement_id = $attribute_value;
1366	}
1367	else if( $attribute_local_name == RDF_PARSE_TYPE )
1368	{
1369	$parse_type = $attribute_value;
1370	}
1371	else if( $attribute_local_name == RDF_RESOURCE )
1372	{
1373	$resource = $attribute_value;
1374	}
1375	else if( $attribute_local_name == RDF_NODEID )
1376	{
1377	$node_id = $attribute_value;
1378	}
1379	else if( $attribute_local_name == RDF_BAG_ID )
1380	{
1381	$bag_id = $attribute_value;
1382	}
1383	else if( $attribute_local_name == RDF_DATATYPE )
1384	{
1385	$datatype = $attribute_value;
1386	$this->rdf_parser['top']['datatype'] = $attribute_value;
1387	}
1388	else if( $this->_is_rdf_property_attribute( $attribute_local_name ) )
1389	{
1390	$this->rdf_parser['top']['has_property_attributes'] = true;
1391	}
1392	else
1393	{
1394	$this->_report_warning('unknown rdf attribute: '.$attribute_local_name );
1395	return;
1396	}
1397	}
1398	else if( $attribute_namespace_uri == XML_NAMESPACE_URI )
1399	{
1400	if( $attribute_local_name == XML_LANG )
1401	{
1402	$this->rdf_parser['top']['xml_lang'] = $attribute_value;
1403	}
1404	elseif ($attribute_local_name == 'base')
1405	{
1406	$this->rdf_parser['top']['element_base_uri'] = $attribute_value;
1407	}
1408	}
1409	else if( $attribute_namespace_uri )
1410	{
1411	$this->rdf_parser['top']['has_property_attributes'] = true;
1412	}
1413	}
1414
1415	if( $statement_id )
1416	{
1417	$this->_resolve_id($statement_id, $buffer );
1418	$this->rdf_parser['top']['statement_id']=$buffer;
1419	}
1420
1421	if ($node_id)
1422	{
1423	$this->is_valid_id($node_id);
1424
1425	if ($resource)
1426	{
1427	$this->_report_error('nodeID and resource are mutually exclusive');
1428	}
1429	if ($statement_id)
1430	{
1431	// reify statement
1432	$this->_report_statement(
1433	$this->rdf_parser['top']['parent']['subject_type'],
1434	$this->rdf_parser['top']['parent']['subject'],
1435	$this->rdf_parser['top']['predicate'],
1436	$this->rdf_parser['top']['ordinal'],
1437	RDF_OBJECT_TYPE_BNODE,
1438	$node_id,
1439	'',
1440	$this->rdf_parser['top']['parent']['bag_id'],
1441	$this->rdf_parser['top']['parent']['statements'],
1442	$this->rdf_parser['top']['statement_id'],
1443	'');
1444	$statement_id = '';
1445	}
1446	else
1447	{
1448	$this->_report_statement(
1449	$this->rdf_parser['top']['parent']['subject_type'],
1450	$this->rdf_parser['top']['parent']['subject'],
1451	$this->rdf_parser['top']['predicate'],
1452	$this->rdf_parser['top']['ordinal'],
1453	RDF_OBJECT_TYPE_BNODE,
1454	$node_id,
1455	'',
1456	$this->rdf_parser['top']['parent']['bag_id'],
1457	$this->rdf_parser['top']['parent']['statements'],
1458	'',
1459	$datatype );
1460	}
1461
1462	$this->rdf_parser['top']['state'] = IN_PROPERTY_EMPTY_RESOURCE;
1463	}
1464
1465	if( $parse_type )
1466	{
1467	if( $resource ) {
1468	$this->_report_error('property elements with rdf:parseType do not allow rdf:resource' );
1469	}
1470
1471	if( $bag_id ) {
1472	$this->_report_warning('property elements with rdf:parseType do not allow rdf:bagID' );
1473	return;
1474	}
1475
1476	if( $this->rdf_parser['top']['has_property_attributes'] )
1477	{
1478	$this->_report_error('property elements with rdf:parseType do not allow property attributes');
1479	return;
1480	}
1481
1482	if( $attribute_value == RDF_PARSE_TYPE_RESOURCE )
1483	{
1484	$this->_generate_anonymous_uri( $buffer );
1485	// since we are sure that this is now a resource property we can report it
1486	$this->_report_statement(
1487	$this->rdf_parser['top']['parent']['subject_type'],
1488	$this->rdf_parser['top']['parent']['subject'],
1489	$this->rdf_parser['top']['predicate'],
1490	0,
1491	RDF_OBJECT_TYPE_BNODE,
1492	$buffer,
1493	'',
1494	$this->rdf_parser['top']['parent']['bag_id'],
1495	$this->rdf_parser['top']['parent']['statements'],
1496	$this->rdf_parser['top']['statement_id'],
1497	$datatype );
1498
1499	$this->_push_element( );
1500
1501	$this->rdf_parser['top']['state'] = IN_PROPERTY_PARSE_TYPE_RESOURCE;
1502	$this->rdf_parser['top']['subject_type'] = RDF_SUBJECT_TYPE_BNODE;
1503	$this->rdf_parser['top']['subject']=$buffer;
1504	$this->rdf_parser['top']['bag_id']='';
1505	$this->rdf_parser['top']['datatype']= $datatype;
1506
1507	}
1508	elseif ( $attribute_value == RDF_PARSE_TYPE_LITERAL )
1509	{
1510	$this->rdf_parser['top']['state'] = IN_PROPERTY_PARSE_TYPE_LITERAL;
1511	$this->rdf_parser['top']['datatype']= RDF_NAMESPACE_URI .RDF_XMLLITERAL;
1512	$this->rdf_parser['xml_literal']['buffer'] = '';
1513	$this->rdf_parser['xml_literal']['depth'] = 0;
1514	}
1515	elseif ($attribute_value == RDF_PARSE_TYPE_COLLECTION)
1516	{
1517	$this->_generate_anonymous_uri( $buffer );
1518	$this->_report_statement(
1519	$this->rdf_parser['top']['parent']['subject_type'],
1520	$this->rdf_parser['top']['parent']['subject'],
1521	$this->rdf_parser['top']['predicate'],
1522	0,
1523	RDF_OBJECT_TYPE_BNODE,
1524	$buffer,
1525	'',
1526	$this->rdf_parser['top']['parent']['bag_id'],
1527	$this->rdf_parser['top']['parent']['statements'],
1528	$this->rdf_parser['top']['statement_id'],
1529	$datatype );
1530
1531	$this->rdf_parser['top']['state'] = IN_PROPERTY_PARSE_TYPE_COLLECTION;
1532	$this->rdf_parser['top']['collection']['first_blank_node_id'] = $buffer;
1533	}
1534
1535	else
1536	{
1537
1538	$this->_report_statement(
1539	$this->rdf_parser['top']['parent']['subject_type'],
1540	$this->rdf_parser['top']['parent']['subject'],
1541	$this->rdf_parser['top']['predicate'],
1542	0,
1543	RDF_OBJECT_TYPE_XML,
1544	'',
1545	'',
1546	$this->rdf_parser['top']['parent']['bag_id'],
1547	$this->rdf_parser['top']['parent']['statements'],
1548	$this->rdf_parser['top']['statement_id'],
1549	$datatype );
1550
1551	$this->rdf_parser['top']['state'] = IN_PROPERTY_PARSE_TYPE_LITERAL;
1552	}
1553	}
1554	else if( $resource !== NULL \|\| $bag_id \|\| $this->rdf_parser['top']['has_property_attributes'] )
1555	{
1556	if( $resource !== NULL )
1557	{
1558	$subject_type = RDF_SUBJECT_TYPE_URI;
1559	$this->_resolve_uri_reference( $this->rdf_get_base(), $resource, $buffer );
1560	$object_type=RDF_OBJECT_TYPE_RESOURCE;
1561	}
1562	else
1563	{
1564	$subject_type = RDF_SUBJECT_TYPE_BNODE;
1565	$this->_generate_anonymous_uri( $buffer );
1566	$object_type=RDF_OBJECT_TYPE_BNODE;
1567	}
1568	$this->rdf_parser['top']['state'] = IN_PROPERTY_EMPTY_RESOURCE;
1569
1570	// since we are sure that this is now a resource property we can report it.
1571	$this->_report_statement(
1572	$this->rdf_parser['top']['parent']['subject_type'],
1573	$this->rdf_parser['top']['parent']['subject'],
1574	$this->rdf_parser['top']['predicate'],
1575	$this->rdf_parser['top']['ordinal'],
1576	$object_type,
1577	$buffer,
1578	'',
1579	$this->rdf_parser['top']['parent']['bag_id'],
1580	$this->rdf_parser['top']['parent']['statements'],
1581	$this->rdf_parser['top']['statement_id'],
1582	$datatype ); // should we allow IDs?
1583
1584	if( $bag_id )
1585	{
1586	$this->_resolve_id( $bag_id, $buffer );
1587	$this->rdf_parser['top']['bag_id']=$buffer;
1588	}
1589
1590	if( $this->rdf_parser['top']['has_property_attributes'] )
1591	{
1592	$this->_handle_property_attributes(
1593	$subject_type,
1594	$buffer,
1595	$attributes,
1596	$this->rdf_parser['top']['xml_lang'],
1597	$this->rdf_parser['top']['bag_id'],
1598	$this->rdf_parser['top']['statements'] );
1599	}
1600	}
1601	}
1602
1603	/**
1604	* @param string &$namespace_uri
1605	* @param string &$local_name
1606	* @param string &$attributes
1607	* @access private
1608	*/
1609	function _handle_collection_element(&$namespace_uri, &$local_name, &$attributes)
1610	{
1611	$aux2=Array();
1612	foreach($attributes as $atkey=>$atvalue) {
1613	$aux2[]=$atkey;
1614	$aux2[]=$atvalue;
1615	}
1616	$attributes=$aux2;
1617	/* collection construction site
1618	// old:
1619	if ( ($namespace_uri == RDF_NAMESPACE_URI \|\| $namespace_uri == '')
1620	&& ($local_name == RDF_DESCRIPTION \|\| $local_name == RDF_LI) )
1621	{
1622	for( $i = 0; isset($attributes[$i]); $i += 2 )
1623	{
1624	$this->_split_name(
1625	$attributes[ $i ],
1626	$attribute,
1627	$attribute_namespace_uri,
1628	$attribute_local_name );
1629
1630	$attribute_value = $attributes[ $i + 1 ];
1631
1632	if( $attribute_namespace_uri == '' \|\| $attribute_namespace_uri == RDF_NAMESPACE_URI )
1633	{
1634	if( $attribute_local_name == RDF_ABOUT \|\|
1635	$attribute_local_name == RDF_RESOURCE)
1636	{
1637	$this->rdf_parser['top']['parent']['collection']['object_type'][] = RDF_OBJECT_TYPE_RESOURCE;
1638	}
1639	elseif ( $attribute_local_name == RDF_NODEID ) {
1640	$this->rdf_parser['top']['parent']['collection']['object_type'][] = RDF_OBJECT_TYPE_BNODE;
1641	}
1642	$this->rdf_parser['top']['parent']['collection']['object_label'][] = $attribute_value;
1643	}
1644	}
1645	}
1646	*/
1647	// new
1648
1649	for( $i = 0; isset($attributes[$i]); $i += 2 )
1650	{
1651	$this->_split_name(
1652	$attributes[ $i ],
1653	$attribute,
1654	$attribute_namespace_uri,
1655	$attribute_local_name );
1656
1657	$attribute_value = $attributes[ $i + 1 ];
1658
1659	if( $attribute_namespace_uri == '' \|\| $attribute_namespace_uri == RDF_NAMESPACE_URI )
1660	{
1661	$tmp_subject_type = RDF_SUBJECT_TYPE_URI;
1662	if( $attribute_local_name == RDF_ABOUT \|\|
1663	$attribute_local_name == RDF_RESOURCE)
1664	{
1665	$this->rdf_parser['top']['parent']['collection']['object_type'][] = RDF_OBJECT_TYPE_RESOURCE;
1666	}
1667	elseif ( $attribute_local_name == RDF_NODEID ) {
1668	$this->rdf_parser['top']['parent']['collection']['object_type'][] = RDF_OBJECT_TYPE_BNODE;
1669	$tmp_subject_type = RDF_SUBJECT_TYPE_BNODE;
1670	}
1671	$id_buffer = '';
1672	$this->_resolve_uri_reference( $this->rdf_get_base(), $attribute_value, $id_buffer );
1673	$this->rdf_parser['top']['parent']['collection']['object_label'][] = $id_buffer;
1674
1675	if (!( ($namespace_uri == RDF_NAMESPACE_URI \|\| $namespace_uri == '')
1676	&& ($local_name == RDF_DESCRIPTION \|\| $local_name == RDF_LI) ))
1677	{
1678	$this->_report_statement(
1679	$tmp_subject_type,
1680	$id_buffer,
1681	RDF_NAMESPACE_URI.RDF_TYPE,
1682	'',
1683	RDF_OBJECT_TYPE_RESOURCE,
1684	$namespace_uri.$local_name,
1685	'',
1686	'',
1687	'',
1688	'',
1689	'');
1690	}
1691	}
1692	}
1693
1694
1695	// collection construction site
1696	}
1697
1698	/**
1699	* @param string &$namespace_uri
1700	* @param string &$local_name
1701	* @param string &$attributes
1702	* @access private
1703	*/
1704	function _handle_xml_start_element(&$namespace_uri, &$local_name, &$attributes)
1705	{
1706	$aux2=Array();
1707	foreach($attributes as $atkey=>$atvalue) {
1708	$aux2[]=$atkey;
1709	$aux2[]=$atvalue;
1710	}
1711	$attributes=$aux2;
1712
1713	$element = '<' .$this->_join_name_and_declare_prefix($namespace_uri, $local_name);
1714
1715	for( $i = 0; isset($attributes[$i]); $i += 2 )
1716	{
1717	$this->_split_name(
1718	$attributes[ $i ],
1719	$attribute,
1720	$attribute_namespace_uri,
1721	$attribute_local_name );
1722
1723	$attribute_value = $attributes[ $i + 1 ];
1724
1725	$element .= ' ' .$this->_join_name_and_declare_prefix($attribute_namespace_uri, $attribute_local_name);
1726	$element .= '=\"' .$attribute_value .'\"';
1727	}
1728	$element .= '>';
1729
1730	$this->rdf_parser['xml_literal']['buffer'] .= $element;
1731	}
1732
1733	/**
1734	* @param string $name
1735	* @access private
1736	*/
1737	function _handle_xml_end_element($name)
1738	{
1739	$buffer='';
1740	$namespace_uri='';
1741	$local_name='';
1742
1743	$this->_split_name(
1744	$name,
1745	$buffer,
1746	$namespace_uri,
1747	$local_name );
1748
1749	$element = '</';
1750
1751	if ($namespace_uri && isset($this->rdf_parser['default_namespace'])
1752	&&$namespace_uri != $this->rdf_parser['default_namespace'])
1753	{
1754	$element .= $this->rdf_parser['namespaces'][$namespace_uri] .':';
1755	}
1756
1757	$element .= $local_name .'>';
1758
1759	$this->rdf_parser['xml_literal']['buffer'] .= $element;
1760	$depth = $this->rdf_parser['xml_literal']['depth']--;
1761
1762	if (isset($this->rdf_parser['xml_literal']['declared_ns']))
1763	foreach ($this->rdf_parser['xml_literal']['declared_ns'] as $prefix => $_depth)
1764	{
1765	if ($depth == $_depth)
1766	unset($this->rdf_parser['xml_literal']['declared_ns'][$prefix]);
1767	}
1768	}
1769
1770	/**
1771	* @param string $namespace_uri
1772	* @param string $local_name
1773	* @access private
1774	*/
1775	function _join_name_and_declare_prefix($namespace_uri, $local_name) {
1776
1777	$name = '';
1778
1779	if ($namespace_uri)
1780	{
1781	if (isset($this->rdf_parser['default_namespace'])
1782	&& $namespace_uri == $this->rdf_parser['default_namespace'])
1783	{
1784	$name .= $local_name;
1785
1786	if (!isset($this->rdf_parser['xml_literal']['declared_ns']['_DEFAULT_'])
1787	&& $namespace_uri != XML_NAMESPACE_URI)
1788	{
1789	$name .= ' xmlns=' . '\"' .$namespace_uri .'\"';
1790
1791	$this->rdf_parser['xml_literal']['declared_ns']['_DEFAULT_']
1792	= $this->rdf_parser['xml_literal']['depth'];
1793	}
1794	}
1795	else
1796	{
1797	$ns_prefix = $this->rdf_parser['namespaces'][$namespace_uri];
1798	$name .= $ns_prefix .':' .$local_name;
1799
1800	if (!isset($this->rdf_parser['xml_literal']['declared_ns'][$ns_prefix])
1801	&& $namespace_uri != XML_NAMESPACE_URI)
1802	{
1803	$name .= " xmlns:$ns_prefix=" . '\"' .$namespace_uri .'\"';
1804
1805	$this->rdf_parser['xml_literal']['declared_ns'][$ns_prefix]
1806	= $this->rdf_parser['xml_literal']['depth'];
1807	}
1808	}
1809
1810	}
1811	else
1812	$name .= $local_name;
1813
1814	return $name;
1815
1816	}
1817
1818	/**
1819	* @access private
1820	*/
1821	function _end_collection() {
1822
1823	if (isset($this->rdf_parser['top']['collection']))
1824	{
1825
1826	$subject = $this->rdf_parser['top']['collection']['first_blank_node_id'];
1827
1828	for ($i=0; isset($this->rdf_parser['top']['collection']['object_label'][$i]); $i++)
1829	{
1830
1831	$this->_report_statement(
1832	RDF_SUBJECT_TYPE_BNODE,
1833	$subject,
1834	RDF_NAMESPACE_URI.RDF_FIRST,
1835	'',
1836	$this->rdf_parser['top']['collection']['object_type'][$i],
1837	$this->rdf_parser['top']['collection']['object_label'][$i],
1838	'',
1839	'',
1840	'',
1841	'',
1842	'');
1843
1844	if (!isset($this->rdf_parser['top']['collection']['object_label'][$i+1]))
1845	{
1846	$obj_type_2 = RDF_OBJECT_TYPE_RESOURCE;
1847	$object_2 = RDF_NAMESPACE_URI.RDF_NIL;
1848	}
1849	else
1850	{
1851	$obj_type_2= RDF_OBJECT_TYPE_BNODE;
1852	$this->_generate_anonymous_uri($object_2);
1853	}
1854
1855
1856	$this->_report_statement(
1857	RDF_SUBJECT_TYPE_BNODE,
1858	$subject,
1859	RDF_NAMESPACE_URI.RDF_REST,
1860	'',
1861	$obj_type_2,
1862	$object_2,
1863	'',
1864	'',
1865	'',
1866	'',
1867	'');
1868
1869	$subject = $object_2;
1870	}
1871	}
1872	}
1873
1874	/**
1875	* @param string $parser
1876	* @param string $name
1877	* @param string $attributes
1878	* @access private
1879	*/
1880	function _start_element_handler($parser, $name, $attributes )
1881	{
1882	$buffer='';
1883
1884	$namespace_uri='';
1885	$local_name='';
1886
1887	$this->_push_element();
1888
1889
1890	$this->_split_name(
1891	$name,
1892	$buffer,
1893	$namespace_uri,
1894	$local_name );
1895
1896	switch( $this->rdf_parser['top']['state'] )
1897	{
1898	case IN_TOP_LEVEL:
1899	// set base_uri, if possible
1900	foreach ($attributes as $key => $value) {
1901	if($key == XML_NAMESPACE_URI . NAMESPACE_SEPARATOR_CHAR . 'base') {
1902	$this->rdf_parser['base_uri'] = $value;
1903	$this->rdf_parser['document_base_uri'] = $value;
1904
1905	$c = substr($value, strlen($value)-1 ,1);
1906	if (!($c=='#' \|\| $c==':' \|\| $c=='/' \|\| $c=="\\"))
1907	$this->rdf_parser['normalized_base_uri'] = $value . '#';
1908	else
1909	$this->rdf_parser['normalized_base_uri'] = $value;
1910
1911	}
1912	elseif ($key == XML_NAMESPACE_URI . NAMESPACE_SEPARATOR_CHAR .'lang')
1913	$this->rdf_parser['document_xml_lang'] = $value;
1914	echo "";
1915	}
1916
1917
1918	if( RDF_NAMESPACE_URI.NAMESPACE_SEPARATOR_STRING.RDF_RDF == $name )
1919	{
1920	$this->rdf_parser['top']['state'] = IN_RDF;
1921
1922	break;
1923	}
1924	case IN_RDF:
1925	$this->rdf_parser['top']['state'] = IN_DESCRIPTION;
1926	$this->_handle_resource_element( $namespace_uri, $local_name, $attributes, '' );
1927	break;
1928	case IN_DESCRIPTION:
1929	case IN_PROPERTY_PARSE_TYPE_RESOURCE:
1930	$this->rdf_parser['top']['state'] = IN_PROPERTY_UNKNOWN_OBJECT;
1931	$this->_handle_property_element( $namespace_uri, $local_name, $attributes );
1932	break;
1933	case IN_PROPERTY_PARSE_TYPE_COLLECTION:
1934	$this->_handle_collection_element($namespace_uri, $local_name, $attributes);
1935	break;
1936	case IN_PROPERTY_UNKNOWN_OBJECT:
1937	/* if we're in a property with an unknown object type and we encounter
1938	an element, the object must be a resource, */
1939	$this->rdf_parser['top']['data']='';
1940	$this->rdf_parser['top']['parent']['state'] = IN_PROPERTY_RESOURCE;
1941	$this->rdf_parser['top']['state'] = IN_DESCRIPTION;
1942	$this->_handle_resource_element(
1943	$namespace_uri,
1944	$local_name,
1945	$attributes,
1946	$this->rdf_parser['top']['parent'] );
1947	break;
1948	case IN_PROPERTY_LITERAL:
1949	$this->_report_warning( 'no markup allowed in literals' );
1950	break;
1951	case IN_PROPERTY_PARSE_TYPE_LITERAL:
1952	$this->rdf_parser['top']['state'] = IN_XML;
1953	/* fall through */
1954	case IN_XML:
1955	$this->rdf_parser['xml_literal']['depth']++;
1956	$this->_handle_xml_start_element($namespace_uri, $local_name, $attributes);
1957	break;
1958	case IN_PROPERTY_RESOURCE:
1959	$this->_report_warning(
1960	'only one element allowed inside a property element' );
1961	break;
1962	case IN_PROPERTY_EMPTY_RESOURCE:
1963	$this->_report_warning(
1964	'no content allowed in property with rdf:resource, rdf:bagID, or property attributes' );
1965	break;
1966	case IN_UNKNOWN:
1967	break;
1968	}
1969	}
1970
1971	/**
1972	property elements with text only as content set the state to
1973	IN_PROPERTY_LITERAL. as character data is received from expat,
1974	it is saved in a buffer and reported when the end tag is
1975	received.
1976	* @access private
1977	*/
1978	function _end_literal_property()
1979	{
1980	if(!isset($this->rdf_parser['top']['statement_id'])) {
1981	$this->rdf_parser['top']['statement_id']='';
1982	}
1983	if(!isset($this->rdf_parser['top']['parent']['subject_type'])) {
1984	$this->rdf_parser['top']['parent']['subject_type']='';
1985	}
1986	if(!isset($this->rdf_parser['top']['parent']['subject'])) {
1987	$this->rdf_parser['top']['parent']['subject']='';
1988	}
1989	if(!isset($this->rdf_parser['top']['parent']['bag_id'])) {
1990	$this->rdf_parser['top']['parent']['bag_id']='';
1991	}
1992	if(!isset($this->rdf_parser['top']['parent']['statements'])) {
1993	$this->rdf_parser['top']['parent']['statements']=0;
1994	}
1995	if(!isset($this->rdf_parser['top']['predicate'])) {
1996	$this->rdf_parser['top']['predicate']='';
1997	}
1998	if(!isset($this->rdf_parser['top']['datatype'])) {
1999	$this->rdf_parser['top']['datatype']='';
2000	}
2001	if(!isset($this->rdf_parser['top']['ordinal'])) {
2002	$this->rdf_parser['top']['ordinal']=0;
2003	}
2004	$this->_report_statement(
2005	$this->rdf_parser['top']['parent']['subject_type'],
2006	$this->rdf_parser['top']['parent']['subject'],
2007	$this->rdf_parser['top']['predicate'],
2008	$this->rdf_parser['top']['ordinal'],
2009	RDF_OBJECT_TYPE_LITERAL,
2010	$this->rdf_parser['top']['data'],
2011	$this->rdf_parser['top']['xml_lang'],
2012	$this->rdf_parser['top']['parent']['bag_id'],
2013	$this->rdf_parser['top']['parent']['statements'],
2014	$this->rdf_parser['top']['statement_id'],
2015	$this->rdf_parser['top']['datatype']);
2016
2017	}
2018
2019	/**
2020	* @param string $parser
2021	* @param string $name
2022	* @access private
2023	*/
2024	function _end_element_handler( $parser, $name )
2025	{
2026	switch( $this->rdf_parser['top']['state'] )
2027	{
2028	case IN_TOP_LEVEL:
2029	break;
2030	case IN_XML:
2031	$this->_handle_xml_end_element($name);
2032	break;
2033	case IN_PROPERTY_UNKNOWN_OBJECT:
2034	case IN_PROPERTY_LITERAL:
2035	$this->_end_literal_property( );
2036	break;
2037	case IN_PROPERTY_PARSE_TYPE_RESOURCE:
2038	$this->_pop_element( );
2039	break;
2040	case IN_PROPERTY_PARSE_TYPE_LITERAL:
2041	// $search = array((0) => chr(10), (1) => chr(13), (2) => chr(9));
2042	// $replace = array((0) => '\n' , (1) => '\r' , (2) => '\t');
2043	// $this->rdf_parser["xml_literal"]["buffer"]
2044	// = str_replace($search, $replace, $this->rdf_parser["xml_literal"]["buffer"]);
2045
2046	$this->rdf_parser['top']['data'] = $this->rdf_parser['xml_literal']['buffer'];
2047	$this->_end_literal_property();
2048	$this->rdf_parser['xml_literal']['buffer'] = '';
2049
2050	break;
2051	case IN_PROPERTY_PARSE_TYPE_COLLECTION:
2052	$this->_end_collection();
2053	break;
2054	case IN_RDF:
2055	case IN_DESCRIPTION:
2056	case IN_PROPERTY_RESOURCE:
2057	case IN_PROPERTY_EMPTY_RESOURCE:
2058	case IN_UNKNOWN:
2059	break;
2060	}
2061
2062	$this->_pop_element();
2063	}
2064
2065	/**
2066	* @param string $parser
2067	* @param string $s
2068	* @access private
2069	*/
2070	function _character_data_handler( $parser,$s)
2071	{
2072	$len=strlen($s);
2073	switch( $this->rdf_parser['top']['state'] )
2074	{
2075	case IN_PROPERTY_LITERAL:
2076	case IN_PROPERTY_UNKNOWN_OBJECT:
2077	if( isset($this->rdf_parser['top']['data']) )
2078	{
2079	$n = strlen( $this->rdf_parser['top']['data'] );
2080	$this->rdf_parser['top']['data'].= $s;
2081
2082	}
2083	else
2084	{
2085	$this->rdf_parser['top']['data']=$s;
2086	}
2087
2088	if( $this->rdf_parser['top']['state'] == IN_PROPERTY_UNKNOWN_OBJECT )
2089	{
2090	/* look for non-whitespace */
2091	for( $i = 0; (( $i < $len ) && ( preg_match("' \|\n\|\t'",$s{ $i }) )); $i++ );
2092	/* if we found non-whitespace, this is a literal */
2093	if( $i < $len )
2094	{
2095	$this->rdf_parser['top']['state'] = IN_PROPERTY_LITERAL;
2096	}
2097	}
2098
2099	break;
2100	case IN_TOP_LEVEL:
2101	break;
2102	case IN_PROPERTY_PARSE_TYPE_LITERAL:
2103	case IN_XML:
2104	$this->rdf_parser['xml_literal']['buffer'] .= $s;
2105	break;
2106	case IN_RDF:
2107	case IN_DESCRIPTION:
2108	case IN_PROPERTY_RESOURCE:
2109	case IN_PROPERTY_EMPTY_RESOURCE:
2110	case IN_PROPERTY_PARSE_TYPE_RESOURCE:
2111	case IN_UNKNOWN:
2112	break;
2113	}
2114	}
2115
2116
2117	/**
2118	* Adds a new statement to the model
2119	* This method is called by generateModel().
2120	*
2121	* @access private
2122	* @param string &$user_data
2123	* @param string $subject_type
2124	* @param string $subject
2125	* @param string $predicate
2126	* @param string $ordinal
2127	* @param string $object_type
2128	* @param string $object
2129	* @param string $xml_lang )
2130	* @return object MemModel
2131	*/
2132	function add_statement_to_model(
2133	&$user_data,
2134	$subject_type,
2135	$subject,
2136	$predicate,
2137	$ordinal,
2138	$object_type,
2139	$object,
2140	$xml_lang,
2141	$datatype )
2142	{
2143
2144	// ParseUnicode
2145	if(UNIC_RDF){
2146	$subject=$this->str2unicode_nfc($subject);
2147	$predicate=$this->str2unicode_nfc($predicate);
2148	$object=$this->str2unicode_nfc($object);
2149	}
2150
2151	//create subject
2152	if ($subject_type == RDF_SUBJECT_TYPE_BNODE)
2153	$objsub = new BlankNode($subject);
2154	else
2155	$objsub = new Resource($subject);
2156
2157	// create predicate
2158	$objpred = new Resource($predicate);
2159
2160	// create object
2161	if (($object_type == RDF_OBJECT_TYPE_RESOURCE) \|\| ($object_type == RDF_OBJECT_TYPE_BNODE)) {
2162	if ($object_type == RDF_OBJECT_TYPE_BNODE)
2163	$objobj = new BlankNode($object);
2164	else
2165	$objobj = new Resource($object);
2166	} else {
2167
2168	$objobj = new Literal($object);
2169	if ($datatype != '') {
2170	$objobj->setDatatype($datatype);
2171	}
2172	elseif ($xml_lang !='') {
2173	$objobj->setLanguage($xml_lang);
2174	}
2175	}
2176
2177	// create statement
2178	$statement = new Statement($objsub, $objpred, $objobj);
2179
2180	// add statement to model
2181	if(CREATE_MODEL_WITHOUT_DUPLICATES == TRUE){
2182	$this->model->addWithoutDuplicates($statement);
2183	}else
2184	$this->model->add($statement);
2185	}
2186
2187
2188	/* public functions */
2189
2190	/**
2191	* Generates a new MemModel from a URI, a file or from memory.
2192	* If you want to parse an RDF document, pass the URI or location in the filesystem
2193	* of the RDF document. You can also pass RDF code direct to the function. If you pass
2194	* RDF code directly to the parser and there is no xml:base included, you should set
2195	* the base URI manually using the optional second parameter $rdfBaseURI.
2196	* Make sure that here are proper namespace declarations in your input document.
2197	*
2198	* @access public
2199	* @param string $base
2200	* @param boolean $rdfBaseURI
2201	* @return object MemModel
2202	*/
2203	function & generateModel($base,$rdfBaseURI = false, $model = false) {
2204
2205	// Check if $base is a URI or filename or a string containing RDF code.
2206	if (substr(ltrim($base),0 ,1) != '<') {
2207
2208	// $base is URL or filename
2209	$this->model = $model?$model:new MemModel($base);
2210
2211	$input = fopen($base,'r') or die("RDF Parser: Could not open File: $base. Stopped parsing.");
2212	$this->rdf_parser_create( NULL );
2213	$this->rdf_set_base($base);
2214	$done=false;
2215	while(!$done)
2216	{
2217	$buf = fread( $input, 512 );
2218	$done = feof($input);
2219
2220	if ( ! $this->rdf_parse( $buf, feof($input) ) )
2221	{
2222	$err_code = xml_get_error_code( $this->rdf_get_xml_parser());
2223	$line = xml_get_current_line_number($this->rdf_get_xml_parser() );
2224	$errmsg = RDFAPI_ERROR . '(class: parser; method: generateModel): XML-parser-error ' . $err_code .' in Line ' . $line .' of input document.';
2225	trigger_error($errmsg, E_USER_ERROR);
2226	}
2227	}
2228	/* close file. */
2229	fclose( $input );
2230
2231	} else {
2232	// $base is RDF string
2233	$this->model = $model?$model:new MemModel($base);
2234
2235	$this->rdf_parser_create( NULL );
2236
2237	if ($rdfBaseURI!==false)
2238	{
2239	$this->rdf_set_base($rdfBaseURI);
2240	} else
2241	{
2242	$this->rdf_set_base( NULL );
2243	}
2244
2245	if ( ! $this->rdf_parse( $base, TRUE ) )
2246	{
2247	$err_code = xml_get_error_code( $this->rdf_get_xml_parser());
2248	$line = xml_get_current_line_number($this->rdf_get_xml_parser() );
2249	$errmsg = RDFAPI_ERROR . '(class: parser; method: generateModel): XML-parser-error ' . $err_code .' in Line ' . $line .' of input document.';
2250	trigger_error($errmsg, E_USER_ERROR);
2251	}
2252	}
2253	// base_uri could have changed while parsing
2254	$this->model->setBaseURI($this->rdf_parser['base_uri']);
2255
2256	if(isset($this->rdf_parser['namespaces'])){
2257	$this->model->addParsedNamespaces($this->rdf_parser['namespaces']);
2258	}
2259
2260	$this->rdf_parser_free();
2261
2262	return $this->model;
2263
2264	}
2265
2266	/**
2267	* @param string $encoding
2268
2269	* @access private
2270	*/
2271	function rdf_parser_create( $encoding )
2272	{
2273
2274	$parser = xml_parser_create_ns( $encoding, NAMESPACE_SEPARATOR_CHAR );
2275
2276	xml_parser_set_option($parser,XML_OPTION_CASE_FOLDING,0);
2277	$this->rdf_parser['xml_parser'] = $parser;
2278
2279	xml_set_object($this->rdf_parser['xml_parser'], $this);
2280	xml_set_element_handler( $this->rdf_parser['xml_parser'], '_start_element_handler', '_end_element_handler' );
2281	xml_set_character_data_handler( $this->rdf_parser['xml_parser'], '_character_data_handler' );
2282	xml_set_start_namespace_decl_handler($this->rdf_parser['xml_parser'], '_start_ns_declaration_handler');
2283
2284	return $this->rdf_parser;
2285	}
2286
2287	/**
2288	* @param resource &$parser
2289	* @param string $ns_prefix
2290	* @param string $ns_uri
2291	* @access private
2292	*/
2293	function _start_ns_declaration_handler(&$parser, $ns_prefix, $ns_uri)
2294	{
2295	if (!$ns_prefix)
2296	$this->rdf_parser['default_namespace'] = $ns_uri;
2297	else
2298	$this->rdf_parser['namespaces'][$ns_uri] = $ns_prefix;
2299	}
2300
2301
2302	/**
2303	* @access private
2304	*/
2305	function rdf_parser_free( )
2306	{
2307	$z=3;
2308
2309	$this->rdf_parser['base_uri']='';
2310	$this->rdf_parser['document_base_uri'] = '';
2311
2312	unset( $this->rdf_parser );
2313	}
2314
2315	/**
2316	* @param string $s
2317	* @param string $is_final
2318	* @access private
2319	*/
2320	function rdf_parse( $s, $is_final )
2321	{
2322	return XML_Parse( $this->rdf_parser['xml_parser'], $s, $is_final );
2323	}
2324
2325	/**
2326	* @access private
2327	*/
2328	function rdf_get_xml_parser()
2329	{
2330	return ( $this->rdf_parser['xml_parser']);
2331	}
2332
2333	/**
2334	* @param string $base
2335	* @access private
2336	*/
2337	function rdf_set_base($base )
2338	{
2339
2340	$this->rdf_parser['base_uri']=$base;
2341
2342	$c = substr($base, strlen($base)-1 ,1);
2343	if (!($c=='#' \|\| $c==':' \|\| $c=='/' \|\| $c=="\\"))
2344	$this->rdf_parser['normalized_base_uri'] = $base . '#';
2345	else
2346	$this->rdf_parser['normalized_base_uri'] = $base;
2347
2348	return 0;
2349	}
2350
2351	/**
2352	* @access private
2353	*/
2354	function rdf_get_base()
2355	{
2356	if ($this->rdf_parser['top']['element_base_uri'])
2357	return $this->rdf_parser['top']['element_base_uri'];
2358	else
2359	return $this->rdf_parser['base_uri'];
2360	}
2361
2362
2363	} // end: rdf_parser
2364
2365	?>

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

Download in other formats: