Source for file RdfParser.php

Documentation is available at RdfParser.php

  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: fsource_syntax__syntaxRdfParser.php.html 443 2007-06-01 16:25:38Z cax $
  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 ereg("[A-Za-z0-9]",$val);
  412. }
  413.   /**
  414.    * @param string $val 
  415.    * @access    private
  416.    */  
  417. function _istalpha($val) {
  418.   return ereg("[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 ) && (  ereg(" |\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. ?>

Documentation generated on Fri, 1 Jun 2007 16:50:45 +0200 by phpDocumentor 1.3.2