<?php
  //   
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
###





















  // Title                     : Class Rdf_parser
  // Version                   : 1.0
  // Author                    : Jason Diammond -repat RDF parser-
  //                           : Luis Argerich -PHP version of repat- (lrargerich@yahoo.com)
  // Last modification date    : 06-13-2002
  // Description               : A port to PHP of the Repat an RDF parser.
  //                             This parser based on expat parses RDF files producing events
  //                             proper of RDF documents.
  //   
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
###





















  // History:
  // 06-13-2002                : First version of this class.
  // 07-17-2002                  Minor bugfix (Leandro Mariano Lopez)
  //   
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
###





















  // To-Dos:
  //
  //   
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
###





















  // How to use it:
  // Read the documentation in rdf_parser.html
  //   
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
#  
###





















  
  if(defined("_class_rdf_is_included")) {
    // do nothing since the class is already included
  } else {
    define("_class_rdf_is_included",1);
  
  /* First we define some constants */
  define("XML_NAMESPACE_URI","http://www.w3.org/XML/1998/namespace" );
  define("XML_LANG","lang");
  define("RDF_NAMESPACE_URI","http://www.w3.org/1999/02/22-rdf-syntax-ns#" );
  define("RDF_RDF","RDF");
  define("RDF_DESCRIPTION","Description");
  define("RDF_ID","ID");
  define("RDF_ABOUT","about");
  define("RDF_ABOUT_EACH","aboutEach");
  define("RDF_ABOUT_EACH_PREFIX","aboutEachPrefix");
  define("RDF_BAG_ID","bagID");
  define("RDF_RESOURCE","resource");
  define("RDF_VALUE","value");
  define("RDF_PARSE_TYPE","parseType");
  define("RDF_PARSE_TYPE_LITERAL","Literal");
  define("RDF_PARSE_TYPE_RESOURCE","Resource");
  define("RDF_TYPE","type");
  define("RDF_BAG","Bag");
  define("RDF_SEQ","Seq");
  define("RDF_ALT","Alt");
  define("RDF_LI","li");
  define("RDF_STATEMENT","Statement");
  define("RDF_SUBJECT","subject");
  define("RDF_PREDICATE","predicate");
  define("RDF_OBJECT","object");
  
  define("NAMESPACE_SEPARATOR_CHAR",'^');
  define("NAMESPACE_SEPARATOR_STRING","^");
  //define("FALSE",0);
  //define("TRUE",1);
  define("IN_TOP_LEVEL",0);
  define("IN_RDF",1);
  define("IN_DESCRIPTION",2);
  define("IN_PROPERTY_UNKNOWN_OBJECT",3);
  define("IN_PROPERTY_RESOURCE",4);
  define("IN_PROPERTY_EMPTY_RESOURCE",5);
  define("IN_PROPERTY_LITERAL",6);
  define("IN_PROPERTY_PARSE_TYPE_LITERAL",7);
  define("IN_PROPERTY_PARSE_TYPE_RESOURCE",8);
  define("IN_XML",9);
  define("IN_UNKNOWN",10);
  //define("IN_PROPERTY_PARSE_TYPE_LITERAL",9);
  
  define("RDF_SUBJECT_TYPE_URI",0);
  define("RDF_SUBJECT_TYPE_DISTRIBUTED",1);
  define("RDF_SUBJECT_TYPE_PREFIX",2);
  define("RDF_SUBJECT_TYPE_ANONYMOUS",3);
  
  define("RDF_OBJECT_TYPE_RESOURCE",0);
  define("RDF_OBJECT_TYPE_LITERAL",1);
  define("RDF_OBJECT_TYPE_XML",2);
  
  class Rdf_parser {
  
  var $rdf\_parser;$/* Private Methods */
  
  function _new_element()
  {
      e["parent"]=Array();  // Parent is a blank Array
      //$this->clear\_element($e["parent"]);
      $e["state"]=0;$e["has_property_atributes"]=0;
      $e["has\_member\_attributes"]=0;$e["subject_type"]=0;
      $e["subject"]=\text{'}\text{'};$e["predicate"]='';
      $e["ordinal"]=0;$e["members"]=0;
      $e["data"]=\text{'}\text{'};$e["xml_lang"]='';
      $e["bag\_id"]=\text{'}\text{'};$e["statements"]=0;
      $e["statement\_id"]=\text{'}\text{'};\; return$e;
  }
  
  function _copy_element(destination )
  {
      if( $source\; )\; \{$destination["parent"] = $source;$destination["state"] = $source["state"];$destination["xml_lang"] = e)
  {
          $e["subject"]=\text{'}\text{'};$e["predicate"]='';
          $e["data"]=\text{'}\text{'};$e["bag_id"]='';
          $e["statement\_id"]=\text{'}\text{'};\; if(isset($e["parent"])) {
            if( $e["parent"]\; )\; \{\; if($e["parent"]["xml_lang"] != $e["xml\_lang"]\; )\; \{$e["xml_lang"]='';
                }
            }
            else
            {
                $e["xml\_lang"]=\text{'}\text{'};\; \}\; \}\; else\; \{$e["xml_lang"]='';
          }
          //memset( e, 0, strlen( _rdf_element ) );
          $e["parent"]=Array();$e["state"]=0;
          $e["has\_property\_attributes"]=0;$e["has_member_attributes"]=0;
          $e["subject\_type"]=0;$e["subject"]='';
          $e["predicate"]=\text{'}\text{'};$e["ordinal"]=0;
          $e["members"]=0;$e["data"]='';
          $e["xml\_lang"]=\text{'}\text{'};$e["bag_id"]='';
          $e["statements"]=0;$e["statement_id"]='';
  
  }
  
  function _push_element()
  {
      if(!isset($this->rdf\_parser["free"]))\; \{$this->rdf_parser["free"]=Array();
      }
      if(count($this->rdf\_parser["free"])>0)\; \{$e = $this->rdf\_parser["free"];\; if(isset($e["parent"])) {
            $this->rdf\_parser["free"]\; =$e["parent"];
          } else {
            $this->rdf\_parser["free"]=$this->_new_element();
          }
      }
      else
      {
          $e\; =$this->_new_element();
      }
      if(!isset($this->rdf\_parser["top"]))\; \{$this->rdf_parser["top"]=Array();
      }
      $this->\_copy\_element($this->rdf_parser["top"], $e\; );$this->rdf_parser["top"] = $e;\; \}\; function\; \_pop\_element()\; \{$e = $this->rdf\_parser["top"];$this->rdf_parser["top"] = $e["parent"];$this->_clear_element( $e\; );$/*
      if(isset(this->rdf_parser["free"])) {
        $e["parent"]\; =$this->rdf_parser["free"];
      } else {
        $e["parent"]=0;\; \}\; */$
      this->rdf_parser["free"] = $e;\; \}\; function\; \_delete\_elements()\; \{\; \}\; function\; \_is\_rdf\_property\_attribute\_resource($local_name )
  {
      return ( $local\_name\; ==\; RDF\_TYPE\; );\; \}\; function\; \_is\_rdf\_property\_attribute\_literal($local_name )
  {
      return ( $local\_name\; ==\; RDF\_VALUE\; );\; \}\; function\; \_is\_rdf\_ordinal($local_name )
  {
      $ordinal\; =\; -1;$//if(local_name{0}=='_')
      if( $local\_name\{0\}\; ==\; \text{'}\_\text{'}\; )\; \{$ordinal =  substr($local\_name,1)\; +\; 1\; ;\; \}\; return\; ($ordinal > 0 ) ? $ordinal\; :\; 0;\; \}\; function\; \_is\_rdf\_property\_attribute($local_name )
  {
      return $this->\_is\_rdf\_property\_attribute\_resource($local_name )
          || $this->\_is\_rdf\_property\_attribute\_literal($local_name );
  }
  
  function _is_rdf_property_element( $local\_name\; )\; \{\; return\; ($local_name == RDF_TYPE  )
          || (  $local\_name\; ==\; RDF\_SUBJECT\; )\; ||\; ($local_name == RDF_PREDICATE )
          || (  $local\_name\; ==\; RDF\_OBJECT\; )\; ||\; ($local_name == RDF_VALUE )
          || (  $local\_name\; ==\; RDF\_LI\; )\; ||\; ($local_name{0} == '_'  );
  }
  
  function _istalnum($val)\; \{\; return\; ereg("[A-Za-z0-9]",$val);
  }
  
  function _istalpha($val)\; \{\; return\; ereg("[A-Za-z]",$val);
  }
  
  function _is_absolute_uri($uri\; )\; \{$result = false;
          $uri\_p=0;\; if($uri && $this->\_istalpha($uri{$uri\_p\}\; )\; )\; \{\; ++$uri_p;
  
          while( ($uri\_p$<strlen(uri))
              && ( $this->\_istalnum($uri{$uri\_p\}\; )\; ||\; ($uri{$uri\_p\}\; ==\; \text{'}+\text{'}\; )\; ||\; ($uri{$uri\_p\}\; ==\; \text{'}-\text{'}\; )\; ||\; ($uri{$uri\_p\}\; ==\; \text{'}.\text{'}\; )\; )\; )\; \{\; ++$uri_p;
          }
  
          $result\; =\; ($uri{$uri\_p\}\; ==\; \text{'}:\text{'}\; );\; \}\; return$result;
  }
  
  /*
  This function returns an associative array returning any of the various components of the URL that are present. This includes the
  $arr=parse\_url($url)
  scheme - e.g. http
  host
  port
  user
  pass
  path
  query - after the question mark ?
  fragment - after the hashmark #
  */
  function _parse_uri($uri,$buffer,scheme,&path,&fragment ) {
    $parsed=parse\_url($uri);
    if(isset($parsed["scheme"]))\; \{$scheme=$parsed["scheme"];\}\; else\; \{$scheme='';
    }
    if(isset($parsed["host"]))\; \{$host=$parsed["host"];\}\; else\; \{$host='';
    }
    if(isset($parsed["host"]))\; \{$authority=$parsed["host"];\}\; else\; \{$authority='';
    }
    if(isset($parsed["path"]))\; \{$path=$parsed["path"];\}\; else\; \{$path='';
    }
    if(isset($parsed["query"]))\; \{$query=$parsed["query"];\}\; else\; \{$query='';
    }
    if(isset($parsed["fragment"]))\; \{$fragment=$parsed["fragment"];\}\; else\; \{$fragment='';
    }
  
  }
  
  function _resolve_uri_reference($base\_uri,$reference_uri,&$buffer,$length )
  {
      $base\_buffer=\text{'}\text{'};$reference_buffer='';
      $path\_buffer=\text{'}\text{'};$buffer = '';
  
      $this->\_parse\_uri($reference_uri,$reference\_buffer,strlen($reference_buffer ),$reference\_scheme,$reference_authority,
          $reference\_path,$reference_query,$reference\_fragment\; );\; if($reference_scheme == ''
          && reference_path == ''
          && $reference\_query\; ==\; \text{'}\text{'}\; )\; \{$buffer=$base\_uri;\; if($reference_fragment != '' )
          {
              $buffer.=\; "\#"\; ;$buffer.=$reference\_fragment;\; \}\; \}\; else\; if($reference_scheme != '' )
      {
          $buffer=$reference_uri;
      }
      else
      {
          $this->\_parse\_uri($base_uri,
              $base\_buffer,\; strlen($base_buffer ),
              $base\_scheme,$base_authority,
              $base\_path,$base_query,
              $base\_fragment\; );$result_scheme = $base\_scheme;\; if($reference_authority != '' )
          {
              $result\_authority\; =$reference_authority;
          }
          else
          {
              $result\_authority\; =$base_authority;
  
              if( reference_path{0} == '/')
                      || ($reference\_path\{0\}\; ==\; \text{'}\backslash \backslash \text{'})\; )\; )\; \{$result_path = $reference\_path;\; \}\; else\; \{$p = '';
  
                  $result\_path\; =$path_buffer;
  
                  $path\_buffer=\text{'}\text{'};$p = strstr( $base\_path,\; \text{'}/\text{'}\; );\; if(\; !$p )
                  {
                      $p\; =\; strstr($base_path, '\\'  );
                  }
  
                  if( $p\; )\; \{$path_buffer.=$base\_path;$//while( s <= p )
                      //{
                      //  *d++ = *s++;
                      //}
  
                      //*d++ = 0;
  
                  }
  
                  if( reference_path != '' )
                  {
                      $path\_buffer.=$reference_path;
                  }
  
                  {
                      //remove all occurrences of "./"
                      //print($path\_buffer);$path_buffer=preg_replace("/\/\.\//","/",$path\_buffer);$path_buffer=preg_replace("/\/([^\/\.])*\/..$/","/",$path_buffer);
                      while(preg_match("/\.\./",$path\_buffer))\; \{$path_buffer=preg_replace("/\/([^\/\.]*)\/..\//","/",$path\_buffer);\; \}$path_buffer=preg_replace("/\.$/","",$path_buffer);
  
                  }
  
              }
          }
  
          // This replaces the C pointer assignament
  
          $result\_path\; =$path_buffer;
          if( $result\_scheme\; !=\; \text{'}\text{'}\; )\; \{$buffer=$result\_scheme;$buffer.=":";
          }
  
          if( $result\_authority\; !=\; \text{'}\text{'}\; )\; \{$buffer.="//";
              $buffer.=$result_authority;
          }
  
          if( $result\_path\; !=\; \text{'}\text{'}\; )\; \{$buffer.=$result\_path;\; \}\; if($reference_query != '' )
          {
              $buffer.="?";$buffer.=$reference\_query;\; \}\; if($reference_fragment != '' )
          {
              $buffer.="\#";$buffer.=$reference\_fragment;\; \}\; \}\; \}\; function\; is\_valid\_id($id )
  {
      $result\; =\; false;$p = $id;$p_p=0;
  
      if( $id\; !=\; \text{'}\text{'}\; )\; \{\; if($this->_istalpha( $p\; )\; ||$p{0} == '_'
              || $p\{0\}\; ==\; \text{'}:\text{'}\; )\; \{$result = true;
  
              while( p{++$p\_p\}\; !=\; 0\; )\; )\; \{\; if(\; !\; ($this->_istalnum( $p\{$p_p} )
                          || $p\{$p_p} == '.'
                          || $p\{$p_p} == '-'
                          || $p\{$p_p} == '_'
                          || $p\{$p_p} == ':'  ) )
                  {
                      $result\; =\; false;\; \}\; \}\; \}\; \}\; return$result;
  }
  
  function _resolve_id(buffer,$length\; )\; \{$id_buffer='';
  
      if( $this->is\_valid\_id($id ) == true )
      {
          $id\_buffer="\#$id";
      }
      else
      {
          $this->report\_warning(\; "bad\; ID\; attribute:\; ".$id_buffer."#_bad_ID_attribute_");
      }
  
      $this->\_resolve\_uri\_reference($this->rdf_parser["base_uri"], $id\_buffer,$buffer, $length\; );\; \}\; function\; \_split\_name($name, &$buffer,$len,&local_name )
  {
  
      static $nul\; =\; 0;$buffer=$name;\; if(\; strstr($buffer, NAMESPACE_SEPARATOR_CHAR ) )
          {
              $cosas=explode(NAMESPACE\_SEPARATOR\_CHAR,$buffer);
              $namespace\_uri\; =$cosas[0];
              $local\_name\; =$cosas[1];
          }
          else
          {
              if( ( buffer{ 1 } ==  'm'  )
                  && ( buffer{ 3 } ==  ':'  ) )
              {
                  $namespace\_uri\; =\; XML\_NAMESPACE\_URI;$local_name = substr($buffer,4);\; \}\; else\; \{$namespace_uri = '';
                  $local\_name\; =$buffer;
              }
          }
  
  }
  
  function _generate_anonymous_uri(&$buf,$len )
  {
      $id=\text{'}\text{'};\; if(!isset($this->rdf_parser["anonymous_id"])) {
        $this->rdf\_parser["anonymous\_id"]=0;\; \}$this->rdf_parser["anonymous_id"]++;
  
      $id="\#genid".$this->rdf_parser["anonymous_id"];
      $this->\_resolve\_uri\_reference($this->rdf_parser["base_uri"], $id,$buf, $len\; );\; \}\; function\; \_report\_statement($subject_type, $subject,$predicate, $ordinal,$object_type,  $object,$xml_lang, $bag\_id,$statements, $statement\_id\; )\; \{$statement_id_type = RDF_SUBJECT_TYPE_URI;
      $statement\_id\_buffer=\text{'}\text{'};$predicate_buffer='';
  
      if( $this->rdf\_parser["statement\_handler"]\; )\; \{$this->rdf_parser["statement_handler"]($this->rdf\_parser["user\_data"],$subject_type,$subject,$predicate,$ordinal,$object_type,$object,$xml_lang );
  
          if( $bag\_id\; )\; \{\; if($statements == '' )
              {
                  $this->\_report\_statement(RDF\_SUBJECT\_TYPE\_URI,$bag_id,
                      RDF_NAMESPACE_URI.RDF_TYPE,
                      0,
                      RDF_OBJECT_TYPE_RESOURCE,
                      RDF_NAMESPACE_URI.RDF_BAG,
                      '',
                      '',
                      '',
                      '' );
              }
  
              if( ! $statement\_id\; )\; \{$statement_id_type = RDF_SUBJECT_TYPE_ANONYMOUS;
                  $this->\_generate\_anonymous\_uri($statement_id_buffer,
                      strlen( $statement\_id\_buffer\; )\; );$statement_id = $statement\_id\_buffer;\; \}$statements++;
              $predicate\_buffer="RDF\_NAMESPACE\_URI\_".$statements;
  
              $this->\_report\_statement(\; RDF\_SUBJECT\_TYPE\_URI,$bag_id,
                  $predicate\_buffer,$statements,
                  RDF_OBJECT_TYPE_RESOURCE,
                  $statement\_id,\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'}\; );\; \}\; if($statement_id )
          {
              // rdf:type = rdf:Statement
              $this->\_report\_statement($statement_id_type,
                  $statement\_id,\; RDF\_NAMESPACE\_URI.RDF\_TYPE,\; 0,\; RDF\_OBJECT\_TYPE\_RESOURCE,\; RDF\_NAMESPACE\_URI.RDF\_STATEMENT,\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'}\; );\; //\; rdf:subject$this->_report_statement(
                  $statement\_id\_type,$statement_id,
                  RDF_NAMESPACE_URI.RDF_SUBJECT,
                  0,
                  RDF_OBJECT_TYPE_RESOURCE,
                  $subject,\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'}\; );\; //\; rdf:predicate$this->_report_statement(
                  $statement\_id\_type,$statement_id,
                  RDF_NAMESPACE_URI.RDF_PREDICATE,
                  0,
                  RDF_OBJECT_TYPE_RESOURCE,
                  $predicate,\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'},\; \text{'}\text{'}\; );\; //\; rdf:object$this->_report_statement(
                  $statement\_id\_type,$statement_id,
                  RDF_NAMESPACE_URI.RDF_OBJECT,
                  0,
                  $object\_type,$object,
                  '',
                  '',
                  '',
                  '' );
          }
      }
  }
  
  function _report_start_parse_type_literal()
  {
      if( $this->rdf\_parser["start\_parse\_type\_literal\_handler"]\; )\; \{$this->rdf_parser["start_parse_type_literal_handler"](
              $this->rdf\_parser["user\_data"]\; );\; \}\; \}\; function\; \_report\_end\_parse\_type\_literal()\; \{\; if($this->rdf_parser["end_parse_type_literal_handler"] )
      {
          $this->rdf\_parser["end\_parse\_type\_literal\_handler"]($this->rdf_parser["user_data"] );
      }
  }
  
  function _handle_property_attributes($subject\_type,$subject, $attributes,$xml_lang, $bag\_id,$statements )
  {
      $i=0;$attribute='';
      $predicate=\text{'}\text{'};$attribute_namespace_uri='';
      $attribute\_local\_name=\text{'}\text{'};$attribute_value='';
  
      $ordinal=0;\; for($i = 0; isset($attributes[$i ]); $i\; +=\; 2\; )\; \{$this->_split_name(
              $attributes[$i ],
              $attribute,\; strlen($attribute ),
              $attribute\_namespace\_uri,$attribute_local_name );
  
          $attribute\_value\; =$attributes[ $i\; +\; 1\; ];$predicate=$attribute\_namespace\_uri;$predicate.=$attribute\_local\_name;\; if(\; RDF\_NAMESPACE\_URI\; ==$attribute_namespace_uri )
          {
              if( $this->\_is\_rdf\_property\_attribute\_literal($attribute_local_name ) )
              {
                  $this->\_report\_statement($subject_type,
                      $subject,$predicate,
                      0,
                      RDF_OBJECT_TYPE_LITERAL,
                      $attribute\_value,$xml_lang,
                      $bag\_id,$statements,
                      '' );
              }
              else if( $this->\_is\_rdf\_property\_attribute\_resource($attribute_local_name ) )
              {
                  $this->\_report\_statement($subject_type,
                      $subject,$predicate,
                      0,
                      RDF_OBJECT_TYPE_RESOURCE,
                      $attribute\_value,\; \text{'}\text{'},$bag_id,
                      $statements,\; \text{'}\text{'}\; );\; \}\; else\; if(\; ($ordinal = $this->\_is\_rdf\_ordinal($attribute_local_name ) ) != 0 )
              {
                  $this->\_report\_statement($subject_type,
                      $subject,$predicate,
                      $ordinal,\; RDF\_OBJECT\_TYPE\_LITERAL,$attribute_value,
                      $xml\_lang,$bag_id,
                      $statements,\; \text{'}\text{'}\; );\; \}\; \}\; else\; if(\; XML\_NAMESPACE\_URI\; ==$attribute_namespace_uri )
          {
              //do nothing
          }
          else if( $attribute\_namespace\_uri\; )\; \{\; //\; is\; it\; required\; that\; property\; attributes\; be\; in\; an\; explicit\; namespace?$this->_report_statement(
                  $subject\_type,$subject,
                  $predicate,\; 0,\; RDF\_OBJECT\_TYPE\_LITERAL,$attribute_value,
                  $xml\_lang,$bag_id,
                  $statements,\; \text{'}\text{'}\; );\; \}\; \}\; \}\; function\; \_report\_start\_element($name, $attributes\; )\; \{\; if(\; isset($this->rdf_parser["start_element_handler"]) )
      {
           $this->rdf\_parser["start\_element\_handler"]($this->rdf_parser["user_data"],
              $name,$attributes );
      }
  }
  
  function _report_end_element( $name\; )\; \{\; if(\; isset($this->rdf_parser["end_element_handler"]) )
      {
          $this->rdf\_parser["end\_element\_handler"]($this->rdf_parser["user_data"],
              $name\; );\; \}\; \}\; function\; \_report\_character\_data($s,$len\; )\; \{\; if(\; isset($this->rdf_parser["character_data_handler"]) )
      {
          $this->rdf\_parser["character\_data\_handler"]($this->rdf_parser["user_data"],
              $s,$len );
      }
  }
  
  function _report_warning( $warning)\; \{\; //\; rdf\_parser->top->state\; =\; IN\_UNKNOWN;\; if(\; isset($this->rdf_parser["warning_handler"]) )
      {
              $this->rdf\_parser["warning\_handler"]\; ($warning);
      }
  }
  
  function _handle_resource_element( $namespace\_uri,$local_name, $attributes,$parent )
  {
      $subjects\_found\; =\; 0;$aux=$attributes;$aux2=Array();
      foreach($attributes\; as$atkey=>$atvalue)\; \{$aux2[]=$atkey;$aux2[]=$atvalue;\; \}$attributes=$aux2;$id = '';
      $about\; =\; \text{'}\text{'};$about_each = '';
      $about\_each\_prefix\; =\; \text{'}\text{'};$bag_id = '';
  
      $i=0;$attribute='';
  
      $attribute\_namespace\_uri=\text{'}\text{'};$attribute_local_name='';
      $attribute\_value=\text{'}\text{'};$id_buffer='';
  
      $type=\text{'}\text{'};$this->rdf_parser["top"]["has_property_attributes"] = false;
      $this->rdf\_parser["top"]["has\_member\_attributes"]\; =\; false;\; //\; examine\; each\; attribute\; for\; the\; standard\; RDF\; "keywords"\; for($i = 0; isset($attributes[$i]); $i\; +=\; 2\; )\; \{$this->_split_name(
              $attributes[$i ],
              $attribute,\; strlen($attribute ),
              $attribute\_namespace\_uri,$attribute_local_name );
  
          $attribute\_value\; =$attributes[ $i\; +\; 1\; ];\; //\; if\; the\; attribute\; is\; not\; in\; any\; namespace\; //\; or\; the\; attribute\; is\; in\; the\; RDF\; namespace\; if(\; ($attribute_namespace_uri == '' )
              || (  $attribute\_namespace\_uri\; ==\; RDF\_NAMESPACE\_URI\; ))\; \{\; if($attribute_local_name == RDF_ID )
              {
                  $id\; =$attribute_value;
                  ++$subjects\_found;\; \}\; else\; if($attribute_local_name == RDF_ABOUT )
              {
                  $about\; =$attribute_value;
                  ++$subjects\_found;\; \}\; else\; if($attribute_local_name == RDF_ABOUT_EACH )
              {
                  $about\_each\; =$attribute_value;
                  ++$subjects\_found;\; \}\; else\; if($attribute_local_name == RDF_ABOUT_EACH_PREFIX )
              {
                  $about\_each\_prefix\; =$attribute_value;
                  ++$subjects\_found;\; \}\; else\; if($attribute_local_name == RDF_BAG_ID)
              {
                  $bag\_id\; =$attribute_value;
              }
              else if( $this->\_is\_rdf\_property\_attribute($attribute_local_name ) )
              {
                  $this->rdf\_parser["top"]["has\_property\_attributes"]\; =\; true;\; \}\; else\; if($this->_is_rdf_ordinal( $attribute\_local\_name\; )\; )\; \{$this->rdf_parser["top"]["has_property_attributes"] = true;
                  $this->rdf\_parser["top"]["has\_member\_attributes"]\; =\; true;\; \}\; else\; \{$this->_report_warning(
                      "unknown or out of context rdf attribute:".$attribute\_local\_name\; );\; \}\; \}\; else\; if($attribute_namespace_uri == XML_NAMESPACE_URI )
          {
              if( $attribute\_local\_name\; ==\; XML\_LANG\; )\; \{$this->rdf_parser["top"]["xml_lang"] = $attribute\_value;\; \}\; \}\; else\; if($attribute_namespace_uri )
          {
              $this->rdf\_parser["top"]["has\_property\_attributes"]\; =\; true;\; \}\; \}\; //\; if\; no\; subjects\; were\; found,\; generate\; one.\; if($subjects_found == 0 )
      {
          $this->\_generate\_anonymous\_uri($id_buffer, strlen( $id\_buffer\; )\; );$this->rdf_parser["top"]["subject"]=$id\_buffer;$this->rdf_parser["top"]["subject_type"] = RDF_SUBJECT_TYPE_ANONYMOUS;
      }
      else if( $subjects\_found\; >\; 1\; )\; \{$this->_report_warning(
              "ID, about, aboutEach, and aboutEachPrefix are mutually exclusive" );
          return;
      }
      else if( $id\; )\; \{$this->_resolve_id( $id,$id_buffer, strlen( $id\_buffer\; )\; );$this->rdf_parser["top"]["subject_type"] = RDF_SUBJECT_TYPE_URI;
          $this->rdf\_parser["top"]["subject"]=$id_buffer;
      }
      else if( $about\; )\; \{$this->_resolve_uri_reference( $this->rdf\_parser["base\_uri"],$about, $id\_buffer,\; strlen($id_buffer ) );
          $this->rdf\_parser["top"]["subject\_type"]\; =\; RDF\_SUBJECT\_TYPE\_URI;$this->rdf_parser["top"]["subject"]=$id\_buffer;\; \}\; else\; if($about_each )
      {
          $this->rdf\_parser["top"]["subject\_type"]\; =\; RDF\_SUBJECT\_TYPE\_DISTRIBUTED;$this->rdf_parser["top"]["subject"]=$about\_each;\; \}\; else\; if($about_each_prefix )
      {
          $this->rdf\_parser["top"]["subject\_type"]\; =\; RDF\_SUBJECT\_TYPE\_PREFIX;$this->rdf_parser["top"]["subject"]=$about\_each\_prefix;\; \}\; //\; if\; the\; subject\; is\; empty,\; assign\; it\; the\; document\; uri\; if($this->rdf_parser["top"]["subject"] == '' )
      {
          $len\; =\; 0;$this->rdf_parser["top"]["subject"]=$this->rdf\_parser["base\_uri"];\; //\; now\; remove\; the\; trailing\; \text{'}\#\text{'}$len = strlen( $this->rdf\_parser["top"]["subject"]);\; if($len > 0 )
          {
              //$rdf\_parser["top"]["subject"]["\; len\; -\; 1\; "]\; =\; 0;\; \}\; \}\; if($bag_id )
      {
          $this->\_resolve\_id($bag_id, $id\_buffer,\; strlen($id_buffer ) );
          $this->rdf\_parser["top"]["bag\_id"]=$id_buffer;
      }
  
      // only report the type for non-rdf:Description elements.
      if( ($local\_name\; !=\; RDF\_DESCRIPTION\; )\; ||\; ($namespace_uri != RDF_NAMESPACE_URI ) )
      {
          $type=$namespace_uri;
          $type.=$local_name;
  
          $this->\_report\_statement($this->rdf_parser["top"]["subject_type"],
              $this->rdf\_parser["top"]["subject"],\; RDF\_NAMESPACE\_URI.RDF\_TYPE,\; 0,\; RDF\_OBJECT\_TYPE\_RESOURCE,$type,
              '',
              $this->rdf\_parser["top"]["bag\_id"],$this->rdf_parser["top"]["statements"],
              '' );
  
      }
  
      // if this element is the child of some property,
      //   report the appropriate statement.
      if( $parent\; )\; \{$this->_report_statement(
              $parent["parent"]["subject\_type"],$parent["parent"]["subject"],
              $parent["predicate"],$parent["ordinal"],
              RDF_OBJECT_TYPE_RESOURCE,
              $this->rdf\_parser["top"]["subject"],\; \text{'}\text{'},$parent["parent"]["bag_id"],
              $parent["parent"]["statements"],$parent["statement_id"] );
  
      }
  
      if( $this->rdf\_parser["top"]["has\_property\_attributes"]\; )\; \{$this->_handle_property_attributes(
              $this->rdf\_parser["top"]["subject\_type"],$this->rdf_parser["top"]["subject"],
              $attributes,$this->rdf_parser["top"]["xml_lang"],
              $this->rdf\_parser["top"]["bag\_id"],$this->rdf_parser["top"]["statements"] );
      }
  }
  
  function _handle_property_element( &local_name, &$attributes\; )\; \{$buffer='';
  
      $i=0;$aux=$attributes;$aux2=Array();
      foreach($attributes\; as$atkey=>$atvalue)\; \{$aux2[]=$atkey;$aux2[]=$atvalue;\; \}$attributes=$aux2;$attribute_namespace_uri='';
      $attribute\_local\_name=\text{'}\text{'};$attribute_value = '';
  
      $resource\; =\; \text{'}\text{'};$statement_id = '';
      $bag\_id\; =\; \text{'}\text{'};$parse_type = '';
  
      $this->rdf\_parser["top"]["ordinal"]\; =\; 0;\; if($namespace_uri == RDF_NAMESPACE_URI )
      {
          if( ($this->rdf\_parser["top"]["ordinal"]\; =\; ($this->_is_rdf_ordinal( $local\_name\; )\; )\; !=\; 0\; )\; )\; \{\; if($this->rdf_parser["top"]["ordinal"] > $this->rdf\_parser["top"]["parent"]["members"]\; )\; \{$this->rdf_parser["top"]["parent"]["members"] = $this->rdf\_parser["top"]["ordinal"];\; \}\; \}\; else\; if(\; !$this->_is_rdf_property_element( $local\_name\; )\; )\; \{$this->_report_warning(
                          "unknown or out of context rdf property element: ".$local\_name\; );\; return;\; \}\; \}$buffer=$namespace\_uri;\; if(\; ($namespace_uri == RDF_NAMESPACE_URI )
          &&  ( $local\_name\; ==\; RDF\_LI\; )\; )\; \{\; //$ordinal='';
          $this->rdf\_parser["top"]["parent"]["members"]++;$this->rdf_parser["top"]["ordinal"] = $this->rdf\_parser["top"]["parent"]["members"];$this->rdf_parser["top"]["ordinal"]=$this->rdf\_parser["top"]["ordinal"];\; //$ordinal{ 0 } =  '_' ;
  
          $buffer.=\text{'}\_\text{'}.$this->rdf_parser["top"]["ordinal"];
      }
      else
      {
          $buffer.=$local_name;
      }
  
      $this->rdf\_parser["top"]["predicate"]=$buffer;
  
      $this->rdf\_parser["top"]["has\_property\_attributes"]\; =\; false;$this->rdf_parser["top"]["has_member_attributes"] = false;
  
      for( $i\; =\; 0;\; isset($attributes[$i]);$i += 2 )
      {
          $this->\_split\_name($attributes[$i],$buffer,
              strlen( $buffer\; ),$attribute_namespace_uri,
              $attribute\_local\_name\; );$attribute_value = $attributes[$i + 1];
  
          // if the attribute is not in any namespace
          //   or the attribute is in the RDF namespace
          if( ( $attribute\_namespace\_uri\; ==\; \text{'}\text{'}\; )\; ||\; ($attribute_namespace_uri == RDF_NAMESPACE_URI ) )
          {
              if( ( $attribute\_local\_name\; ==\; RDF\_ID\; )\; )\; \{$statement_id = $attribute\_value;\; \}\; else\; if($attribute_local_name == RDF_PARSE_TYPE )
              {
                  $parse\_type\; =$attribute_value;
              }
              else if(  $attribute\_local\_name\; ==\; RDF\_RESOURCE\; )\; \{$resource = $attribute\_value;\; \}\; else\; if($attribute_local_name == RDF_BAG_ID )
              {
                  $bag\_id\; =$attribute_value;
              }
              else if( $this->\_is\_rdf\_property\_attribute($attribute_local_name ) )
              {
                  $this->rdf\_parser["top"]["has\_property\_attributes"]\; =\; true;\; \}\; else\; \{$this->_report_warning(
                                          "unknown rdf attribute: ".$attribute\_local\_name\; );\; return;\; \}\; \}\; else\; if($attribute_namespace_uri == XML_NAMESPACE_URI  )
          {
              if( $attribute\_local\_name\; ==\; XML\_LANG\; )\; \{$this->rdf_parser["top"]["xml_lang"] = $attribute\_value;\; \}\; \}\; else\; if($attribute_namespace_uri )
          {
              statement_id && $resource\; )\; \{$this->_report_warning(
                          "rdf:ID and rdf:resource are mutually exclusive" );
          return;
      }
  
      if( $statement\_id\; )\; \{$this->_resolve_id($statement\_id,$buffer, strlen( $buffer\; )\; );$this->rdf_parser["top"]["statement_id"]=$buffer;\; \}\; if($parse_type )
      {
          if( $resource\; )\; \{$this->_report_warning(
                                  "property elements with rdf:parseType do not allow rdf:resource" );
              return;
          }
  
          if( $bag\_id\; )\; \{$this->_report_warning(
                                  "property elements with rdf:parseType do not allow rdf:bagID" );
              return;
          }
  
          if( $this->rdf\_parser["top"]["has\_property\_attributes"]\; )\; \{$this->_report_warning(
                                  "property elements with rdf:parseType do not allow property attributes");
              return;
          }
  
          if(  $attribute\_value\; ==\; RDF\_PARSE\_TYPE\_RESOURCE\; )\; \{$this->_generate_anonymous_uri( $buffer,\; strlen($buffer ) );
  
              // since we are sure that this is now a resource property we can report it
              $this->\_report\_statement($this->rdf_parser["top"]["parent"]["subject_type"],
                  $this->rdf\_parser["top"]["parent"]["subject"],$this->rdf_parser["top"]["predicate"],
                  0,
                  RDF_OBJECT_TYPE_RESOURCE,
                  $buffer,\; \text{'}\text{'},$this->rdf_parser["top"]["parent"]["bag_id"],
                  $this->rdf\_parser["top"]["parent"]["statements"],$statement_id );
  
              $this->\_push\_element(\; );$this->rdf_parser["top"]["state"] = IN_PROPERTY_PARSE_TYPE_RESOURCE;
              $this->rdf\_parser["top"]["subject\_type"]\; =\; RDF\_SUBJECT\_TYPE\_ANONYMOUS;$this->rdf_parser["top"]["subject"]=$buffer;$this->rdf_parser["top"]["bag_id"]='';
          }
          else
          {
              $this->\_report\_statement($this->rdf_parser["top"]["parent"]["subject_type"],
                  $this->rdf\_parser["top"]["parent"]["subject"],$this->rdf_parser["top"]["predicate"],
                  0,
                  RDF_OBJECT_TYPE_XML,
                  '',
                  '',
                  $this->rdf\_parser["top"]["parent"]["bag\_id"],$this->rdf_parser["top"]["parent"]["statements"],
                  $statement\_id\; );$this->rdf_parser["top"]["state"] = IN_PROPERTY_PARSE_TYPE_LITERAL;
              $this->\_report\_start\_parse\_type\_literal();\; \}\; \}\; else\; if($resource || $bag\_id\; ||$this->rdf_parser["top"]["has_property_attributes"] )
      {
  
          if( $resource\; !=\; \text{'}\text{'}\; )\; \{$subject_type = RDF_SUBJECT_TYPE_URI;
              $this->\_resolve\_uri\_reference($this->rdf_parser["base_uri"], $resource,$buffer, strlen( $buffer\; )\; );\; \}\; else\; \{$subject_type = RDF_SUBJECT_TYPE_ANONYMOUS;
              $this->\_generate\_anonymous\_uri(\; buffer,\; strlen($buffer ) );
          }
  
          $this->rdf\_parser["top"]["state"]\; =\; IN\_PROPERTY\_EMPTY\_RESOURCE;\; //\; since\; we\; are\; sure\; that\; this\; is\; now\; a\; resource\; property\; we\; can\; report\; it.$this->_report_statement(
              $this->rdf\_parser["top"]["parent"]["subject\_type"],$this->rdf_parser["top"]["parent"]["subject"],
              $this->rdf\_parser["top"]["predicate"],$this->rdf_parser["top"]["ordinal"],
              RDF_OBJECT_TYPE_RESOURCE,
              $buffer,\; \text{'}\text{'},$this->rdf_parser["top"]["parent"]["bag_id"],
              $this->rdf\_parser["top"]["parent"]["statements"],\; \text{'}\text{'}\; );\; //\; should\; we\; allow\; IDs?\; if($bag_id )
          {
              $this->\_resolve\_id($bag_id, $buffer,\; strlen($buffer ) );
              $this->rdf\_parser["top"]["bag\_id"]=$buffer;
          }
  
          if( $this->rdf\_parser["top"]["has\_property\_attributes"]\; )\; \{$this->_handle_property_attributes(
                  $subject\_type,$buffer,
                  $attributes,$this->rdf_parser["top"]["xml_lang"],
                  $this->rdf\_parser["top"]["bag\_id"],$this->rdf_parser["top"]["statements"] );
          }
      }
  }
  
  function _start_element_handler($parser,$name, $attributes\; )\; \{$buffer='';
  
      $namespace\_uri=\text{'}\text{'};$local_name='';
  
  /*
      if( rdf_parser->top != '' && rdf_parser->top->state != IN_TOP_LEVEL )
      {
          ++rdf_parser->anonymous_id;
      }
  */
  
      $this->\_push\_element();$this->_split_name(
          $name,$buffer,
          strlen( $buffer\; ),$namespace_uri,
          $local\_name\; );\; switch($this->rdf_parser["top"]["state"] )
      {
      case IN_TOP_LEVEL:
          if( RDF_NAMESPACE_URI.NAMESPACE_SEPARATOR_STRING.RDF_RDF == $name\; )\; \{$this->rdf_parser["top"]["state"] = IN_RDF;
          }
          else
          {
              $this->\_report\_start\_element($name, $attributes\; );\; \}\; break;\; case\; IN\_RDF:$this->rdf_parser["top"]["state"] = IN_DESCRIPTION;
          $this->\_handle\_resource\_element($namespace_uri, $local\_name,$attributes, '' );
          break;
      case IN_DESCRIPTION:
      case IN_PROPERTY_PARSE_TYPE_RESOURCE:
          $this->rdf\_parser["top"]["state"]\; =\; IN\_PROPERTY\_UNKNOWN\_OBJECT;$this->_handle_property_element( $namespace\_uri,$local_name, $attributes\; );\; break;\; case\; IN\_PROPERTY\_UNKNOWN\_OBJECT:$/* if we're in a property with an unknown object type and we encounter
             an element, the object must be a resource, */
          this->rdf_parser["top"]["data"]='';
          $this->rdf\_parser["top"]["parent"]["state"]\; =\; IN\_PROPERTY\_RESOURCE;$this->rdf_parser["top"]["state"] = IN_DESCRIPTION;
          $this->\_handle\_resource\_element($namespace_uri,
              $local\_name,$attributes,
              $this->rdf\_parser["top"]["parent"]\; );\; break;\; case\; IN\_PROPERTY\_LITERAL:$this->_report_warning( "no markup allowed in literals" );
          break;
      case IN_PROPERTY_PARSE_TYPE_LITERAL:
          $this->rdf\_parser["top"]["state"]\; =\; IN\_XML;$/* fall through */
      case IN_XML:
          this->_report_start_element( $name,$attributes );
          break;
      case IN_PROPERTY_RESOURCE:
          $this->\_report\_warning(\; "only\; one\; element\; allowed\; inside\; a\; property\; element"\; );\; break;\; case\; IN\_PROPERTY\_EMPTY\_RESOURCE:$this->_report_warning(
                      "no content allowed in property with rdf:resource, rdf:bagID, or property attributes" );
          break;
      case IN_UNKNOWN:
          break;
      }
  }
  
  /*
      this is only called when we're in the IN_PROPERTY_UNKNOWN_OBJECT state.
      the only time we won't know what type of object a statement has is
      when we encounter property statements without property attributes or
      content:
  
          <foo:property />
          <foo:property ></foo:property>
          <foo:property>    </foo:property>
  
      notice that the state doesn't switch to IN_PROPERTY_LITERAL when
      there is only whitespace between the start and end tags. this isn't
      a very useful statement since the object is anonymous and can't
      have any statements with it as the subject but it is allowed.
  */
  
  function _end_empty_resource_property()
  {
      $buffer=\text{'}\text{'};$this->_generate_anonymous_uri($buffer,\; strlen($buffer ) );
  
      $this->\_report\_statement($this->rdf_parser["top"]["parent"]["subject_type"],
          $this->rdf\_parser["top"]["parent"]["subject"],$this->rdf_parser["top"]["predicate"],
          $this->rdf\_parser["top"]["ordinal"],\; RDF\_OBJECT\_TYPE\_RESOURCE,$buffer,
          $this->rdf\_parser["top"]["xml\_lang"],$this->rdf_parser["top"]["parent"]["bag_id"],
          $this->rdf\_parser["top"]["parent"]["statements"],$this->rdf_parser["top"]["statement_id"] );
  }
  
  /*
      property elements with text only as content set the state to
      IN_PROPERTY_LITERAL. as character data is received from expat,
      it is saved in a buffer and reported when the end tag is
      received.
  */
  function _end_literal_property()
  {
      if(!isset($this->rdf\_parser["top"]["statement\_id"]))\; \{$this->rdf_parser["top"]["statement_id"]='';
      }
      if(!isset($this->rdf\_parser["top"]["parent"]["subject\_type"]))\; \{$this->rdf_parser["top"]["parent"]["subject_type"]='';
      }
      if(!isset($this->rdf\_parser["top"]["parent"]["subject"]))\; \{$this->rdf_parser["top"]["parent"]["subject"]='';
      }
      if(!isset($this->rdf\_parser["top"]["parent"]["bag\_id"]))\; \{$this->rdf_parser["top"]["parent"]["bag_id"]='';
      }
      if(!isset($this->rdf\_parser["top"]["parent"]["statements"]))\; \{$this->rdf_parser["top"]["parent"]["statements"]=0;
      }
      if(!isset($this->rdf\_parser["top"]["predicate"]))\; \{$this->rdf_parser["top"]["predicate"]='';
      }
      if(!isset($this->rdf\_parser["top"]["ordinal"]))\; \{$this->rdf_parser["top"]["ordinal"]=0;
      }
      $this->\_report\_statement($this->rdf_parser["top"]["parent"]["subject_type"],
          $this->rdf\_parser["top"]["parent"]["subject"],$this->rdf_parser["top"]["predicate"],
          $this->rdf\_parser["top"]["ordinal"],\; RDF\_OBJECT\_TYPE\_LITERAL,$this->rdf_parser["top"]["data"],
          $this->rdf\_parser["top"]["xml\_lang"],$this->rdf_parser["top"]["parent"]["bag_id"],
          $this->rdf\_parser["top"]["parent"]["statements"],$this->rdf_parser["top"]["statement_id"] );
  }
  
  function _end_element_handler( $parser,$name )
  {
  
      switch( $this->rdf\_parser["top"]["state"]\; )\; \{\; case\; IN\_TOP\_LEVEL:$/* fall through */
      case IN_XML:
          this->_report_end_element( $name\; );\; break;\; case\; IN\_PROPERTY\_UNKNOWN\_OBJECT:$this->_end_empty_resource_property();
          break;
      case IN_PROPERTY_LITERAL:
          $this->\_end\_literal\_property(\; );\; break;\; case\; IN\_PROPERTY\_PARSE\_TYPE\_RESOURCE:$this->_pop_element(  );
          break;
      case IN_PROPERTY_PARSE_TYPE_LITERAL:
          $this->\_report\_end\_parse\_type\_literal();\; break;\; case\; IN\_RDF:\; case\; IN\_DESCRIPTION:\; case\; IN\_PROPERTY\_RESOURCE:\; case\; IN\_PROPERTY\_EMPTY\_RESOURCE:\; case\; IN\_UNKNOWN:\; break;\; \}$this->_pop_element();
  }
  
  function _character_data_handler( $parser,$s)
  {
      $len=strlen($s);
      switch( $this->rdf\_parser["top"]["state"]\; )\; \{\; case\; IN\_PROPERTY\_LITERAL:\; case\; IN\_PROPERTY\_UNKNOWN\_OBJECT:\; if(\; isset($this->rdf_parser["top"]["data"]) )
          {
              $n\; =\; strlen($this->rdf_parser["top"]["data"] );
              $this->rdf\_parser["top"]["data"].=$s;
  
          }
          else
          {
              $this->rdf\_parser["top"]["data"]=$s;
          }
  
          if( $this->rdf\_parser["top"]["state"]\; ==\; IN\_PROPERTY\_UNKNOWN\_OBJECT\; )\; \{$/* look for non-whitespace */
              for( i = 0; (( len ) && (  ereg(" |\n|\t",$s\{$i }) )); $i++\; );$i++;
              /* if we found non-whitespace, this is a literal */
              if( len )
              {
                  $this->rdf\_parser["top"]["state"]\; =\; IN\_PROPERTY\_LITERAL;\; \}\; \}\; break;\; case\; IN\_TOP\_LEVEL:\; case\; IN\_PROPERTY\_PARSE\_TYPE\_LITERAL:\; case\; IN\_XML:$this->_report_character_data(
              $s,\; strlen($s) );
          break;
      case IN_RDF:
      case IN_DESCRIPTION:
      case IN_PROPERTY_RESOURCE:
      case IN_PROPERTY_EMPTY_RESOURCE:
      case IN_PROPERTY_PARSE_TYPE_RESOURCE:
      case IN_UNKNOWN:
          break;
      }
  }
  
  /* public functions */
  
  function rdf_parser_create( $encoding\; )\; \{$parser = xml_parser_create_ns( $encoding,\; NAMESPACE\_SEPARATOR\_CHAR\; );\; xml\_parser\_set\_option($parser,XML_OPTION_CASE_FOLDING,0);
      $this->rdf\_parser["xml\_parser"]\; =$parser;
  
      xml_set_object($this->rdf\_parser["xml\_parser"],$this);
      xml_set_element_handler( $this->rdf\_parser["xml\_parser"],\; "\_start\_element\_handler",\; "\_end\_element\_handler"\; );\; xml\_set\_character\_data\_handler($this->rdf_parser["xml_parser"], "_character_data_handler" );
  
      return $this->rdf\_parser;\; \}\; function\; rdf\_parser\_free(\; )\; \{$z=3;
  //    xml_parser_free( $this->rdf\_parser["xml\_parser"]\; );$
  
      this->rdf_parser["base_uri"]='';
  
      $this->\_delete\_elements($this->rdf_parser );
  
      unset( user_data )
  {
      user_data;
  }
  
  function rdf_get_user_data( )
  {
      return ( $this->rdf\_parser["$user_data"] );
  }
  
  function rdf_set_statement_handler($handler\; )\; \{$this->rdf_parser["statement_handler"] = $handler;\; \}\; function\; rdf\_set\_parse\_type\_literal\_handler($start,$end\; )\; \{$this->rdf_parser["start_parse_type_literal_handler"] = $start;$this->rdf_parser["end_parse_type_literal_handler"] = $end;\; \}\; function\; rdf\_set\_element\_handler($start,$end)\; \{$this->rdf_parser["_start_element_handler"] = $start;$this->rdf_parser["_end_element_handler"] = $end;\; \}\; function\; rdf\_set\_character\_data\_handler($handler)
  {
      $this->rdf\_parser["\_character\_data\_handler"]\; =$handler;
  }
  
  function rdf_set_warning_handler($handler\; )\; \{$this->rdf_parser["warning_handler"] = $handler;\; \}\; function\; rdf\_parse($s, $len,$is_final )
  {
      return XML_Parse( $this->rdf\_parser["xml\_parser"],$s, $is\_final\; );\; \}\; function\; rdf\_get\_xml\_parser()\; \{\; return\; ($this->rdf_parser["xml_parser"]);
  }
  
  function rdf_set_base($base\; )\; \{\; //tcscpy(\; buffer,\; base\; );$/*
      if( buffer[" tcslen( buffer ) - 1 "] != T( '#' ) )
      {
          tcscat( buffer, T( "#" ) );
      }
  */
  
      /* check for out of memory */
      this->rdf_parser["base_uri"]=$base;\; return\; 0;\; \}\; function\; rdf\_get\_base()\; \{\; return$this->rdf_parser["base_uri"];
  }
  
  function rdf_resolve_uri(buffer)
  {
      _resolve_uri_reference( $this->rdf\_parser["base\_uri"],$uri_reference, $buffer,\; strlen($buffer) );
  }
  
  }
  
  }
  ?>